change client to user

wsServer.go

@@ -23,26 +23,26 @@ func ServeWsConnection(responseWriter http.ResponseWriter, request *http.Request
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	var client = Client{WsConn: connection}
+	var user = User{WsConn: connection}
 	var isAuthenticated bool
 	var ignoreCache bool
 
-	defer closeConnection(&client, ignoreCache)
+	defer closeConnection(&user, ignoreCache)
 	for {
-		var clientMessage map[string]any
-		err = wsjson.Read(ctx, connection, &clientMessage)
+		var userMessage map[string]any
+		err = wsjson.Read(ctx, connection, &userMessage)
 		if err != nil {
 			log.Printf("read error: %v", err)
 			return
 		}
 
-		if len(clientMessage) > 0 {
+		if len(userMessage) > 0 {
 			if isAuthenticated {
-				if !handleAuthenticatedMessage(&client, &clientMessage) {
+				if !handleAuthenticatedMessage(&user, &userMessage) {
 					return
 				}
 			} else {
-				if !handleUnauthenticatedMessage(ctx, &client, &clientMessage) {
+				if !handleUnauthenticatedMessage(ctx, &user, &userMessage) {
 					ignoreCache = true
 					return
 				}
@@ -52,18 +52,18 @@ func ServeWsConnection(responseWriter http.ResponseWriter, request *http.Request
 	}
 }
 
-func sendMessageCloseIfTimeout(client *Client, message *map[string]any) {
-	if client.WsConn == nil {
+func sendMessageCloseIfTimeout(user *User, message *map[string]any) {
+	if user.WsConn == nil {
 		return
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
-	err := wsjson.Write(ctx, client.WsConn, message)
+	err := wsjson.Write(ctx, user.WsConn, message)
 	if err != nil {
 		if errors.Is(err, context.DeadlineExceeded) {
-			closeConnection(client, false)
+			closeConnection(user, false)
 		}
 		log.Printf("write error: %v", err)
 	}
@@ -72,8 +72,8 @@ func sendMessageCloseIfTimeout(client *Client, message *map[string]any) {
 func sendToAllMessageCloseIfTimeout(message *map[string]any) {
 	mu.RLock()
 	defer mu.RUnlock()
-	for _, client := range CacheClients {
-		sendMessageCloseIfTimeout(client, message)
+	for _, user := range CacheUsers {
+		sendMessageCloseIfTimeout(user, message)
 	}
 }
 
@@ -83,88 +83,88 @@ func WsSendToGroup(ctx context.Context, groupId uint32, senderId uint32, message
 		return errors.New("group invalid")
 	}
 
-	client, err := CacheGetClientById(senderId)
+	sender, err := CacheGetUserById(senderId)
 	if err != nil {
-		client = &Client{Id: senderId}
-		err = DbSetClientById(ctx, client)
+		sender = &User{Id: senderId}
+		err = DbSetUserById(ctx, sender)
 		if err != nil {
 			return errors.New("non existing sender")
 		}
 	}
 
-	for groupClientId := range group.Clients {
-		groupClient, err := CacheGetClientById(groupClientId)
-		if err != nil || groupClient.Id == client.Id {
+	for groupUserId := range group.Users {
+		groupUser, err := CacheGetUserById(groupUserId)
+		if err != nil || groupUser.Id == sender.Id {
 			continue
 		}
 
 		var msg = map[string]any{
 			"from":    "group",
 			"group":   group.Id,
-			"sender":  client.Name,
+			"sender":  sender.Name,
 			"content": message,
 		}
-		sendMessageCloseIfTimeout(groupClient, &msg)
+		sendMessageCloseIfTimeout(groupUser, &msg)
 	}
 	return nil
 }
 
-func handleAuthenticatedMessage(client *Client, clientMessage *map[string]any) bool {
-	sendMessageCloseIfTimeout(client, clientMessage)
+func handleAuthenticatedMessage(user *User, userMessage *map[string]any) bool {
+	sendMessageCloseIfTimeout(user, userMessage)
 	return true
 }
 
-func handleUnauthenticatedMessage(ctx context.Context, client *Client, clientMessage *map[string]any) bool {
-	token, ok := (*clientMessage)["token"].(string)
+func handleUnauthenticatedMessage(ctx context.Context, user *User, userMessage *map[string]any) bool {
+	token, ok := (*userMessage)["token"].(string)
 	if !ok {
 		var msg = map[string]any{
 			"from":  "server",
 			"error": "no token in message",
 		}
-		sendMessageCloseIfTimeout(client, &msg)
+		sendMessageCloseIfTimeout(user, &msg)
 		return false
 	}
 
-	clientId, err := TokenValidateGetId(token)
+	userId, err := TokenValidateGetId(token)
 	if err != nil {
 		var msg = map[string]any{
 			"from":  "server",
 			"error": "invalid token",
 		}
-		sendMessageCloseIfTimeout(client, &msg)
+		sendMessageCloseIfTimeout(user, &msg)
 		return false
 	}
 
-	clientFromCache, err := CacheGetClientById(clientId)
+	userFromCache, err := CacheGetUserById(userId)
 	if err != nil {
-		dbClient := &Client{Id: clientId}
-		err = DbSetClientByIdWithoutGroups(ctx, dbClient)
+		dbUser := &User{Id: userId}
+		err = DbSetUserByIdWithoutGroups(ctx, dbUser)
 		if err != nil {
 			var msg = map[string]any{
 				"from":  "server",
-				"error": "invalid client data",
+				"error": "invalid user data",
 			}
-			sendMessageCloseIfTimeout(client, &msg)
+			sendMessageCloseIfTimeout(user, &msg)
 			return false
 		}
-		err = DbSetClientGroups(ctx, dbClient)
+		err = DbSetUserGroups(ctx, dbUser)
 		if err != nil {
 			var msg = map[string]any{
 				"from":  "server",
-				"error": "invalid client data",
+				"error": "invalid user data",
 			}
-			sendMessageCloseIfTimeout(client, &msg)
+			sendMessageCloseIfTimeout(user, &msg)
 			return false
 		}
-		dbClient.WsConn = client.WsConn
-		CacheSaveClient(dbClient)
-		clientFromCache = dbClient
+		dbUser.WsConn = user.WsConn
+		CacheSaveUser(dbUser)
+		userFromCache = dbUser
 	}
 
-	clientFromCache.WsConn = client.WsConn
-	*client = *clientFromCache
+	userFromCache.WsConn = user.WsConn
+	*user = *userFromCache
 
-	for groupId, _ := range clientFromCache.Groups {
+	for groupId, _ := range userFromCache.Groups {
 		_, err = CacheGetGroup(groupId)
 		if err != nil {
 			dbGroup := &Group{Id: groupId}
@@ -173,9 +173,9 @@ func handleUnauthenticatedMessage(ctx context.Context, client *Client, clientMes
 			if err != nil {
 				var msg = map[string]any{
 					"from":  "server",
-					"error": "invalid client data",
+					"error": "invalid user data",
 				}
-				sendMessageCloseIfTimeout(client, &msg)
+				sendMessageCloseIfTimeout(user, &msg)
 				return false
 			}
 			CacheSaveGroup(dbGroup)
@@ -184,9 +184,9 @@ func handleUnauthenticatedMessage(ctx context.Context, client *Client, clientMes
 	return true
 }
 
-func closeConnection(client *Client, ignoreCache bool) {
+func closeConnection(user *User, ignoreCache bool) {
 	if !ignoreCache {
-		CacheDeleteClient(client.Id)
+		CacheDeleteUser(user.Id)
 	}
-	client.WsConn.CloseNow()
+	user.WsConn.CloseNow()
 }