start minIO, refactored files into packages

2026-04-13 20:22:38 +02:00
parent 6435206683
commit c90c13b468
22 changed files with 311 additions and 218 deletions
@@ -0,0 +1,33 @@
+package http
+
+import (
+	"context"
+
+	"go-socket/packages/cache"
+	"go-socket/packages/postgresql"
+	"go-socket/packages/tokens"
+	"go-socket/packages/types"
+
+	"github.com/google/uuid"
+)
+
+func GetUserById(ctx context.Context, userId uuid.UUID) (*types.User, error) {
+	user, err := cache.CacheGetUserById(userId)
+	if err != nil {
+		user = &types.User{Id: userId}
+		err = postgresql.PgGetWholeUser(ctx, user)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return user, nil
+}
+
+func GetUserByToken(ctx context.Context, token string) (*types.User, error) {
+	userId, err := tokens.TokenValidateGetId(token)
+	if err != nil {
+		return nil, err
+	}
+	return GetUserById(ctx, userId)
+}
@@ -0,0 +1,13 @@
+package http
+
+import (
+	"net/http"
+)
+
+func methodAllowed(response *http.ResponseWriter, request *http.Request) bool {
+	if request.Method != http.MethodPost {
+		http.Error(*response, "POST only", http.StatusMethodNotAllowed)
+		return false
+	}
+	return true
+}
@@ -0,0 +1,373 @@
+package http
+
+import (
+	json2 "encoding/json"
+	"maps"
+	"net/http"
+	"slices"
+	"time"
+
+	"go-socket/packages/Enums/ConnectionState"
+	"go-socket/packages/Enums/WsEventType"
+	"go-socket/packages/cache"
+	"go-socket/packages/convertions"
+	"go-socket/packages/globals"
+	"go-socket/packages/postgresql"
+	"go-socket/packages/types"
+	"go-socket/packages/wsServer"
+
+	"github.com/google/uuid"
+)
+
+func HandleDm(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	targetConnection, err := convertions.ConvertStringUuid(request.FormValue("connectionid"))
+	if err != nil {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+	conn, ok := cache.CacheGetConnection(user, targetConnection)
+	if !ok {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	msgContent := request.FormValue("msgContent")
+	if msgContent == "" {
+		http.Error(response, "empty msgContent", http.StatusBadRequest)
+		return
+	}
+
+	var target *types.User
+
+	if user.Id == conn.RequestorId {
+		target, err = GetUserById(ctx, conn.RecipientId)
+	} else if user.Id == conn.RecipientId {
+		target, err = GetUserById(ctx, conn.RequestorId)
+	} else {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+	message := &types.Message{
+		Id:        uuid.New(),
+		Content:   msgContent,
+		CreatedAt: time.Now(),
+		Sender:    user.Id,
+		Receiver:  conn.Id,
+	}
+
+	wsServer.WsSendMessageCloseIfTimeout(target, types.WsEventMessage{
+		Type:  WsEventType.DirectMessage,
+		Event: message,
+	})
+
+	err = postgresql.PgConnectionMessageSave(ctx, message)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	response.WriteHeader(http.StatusAccepted)
+}
+
+func HandleUserGetConnectionMessages(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	connectionId, err := convertions.ConvertStringUuid(request.FormValue("connectionid"))
+	if err != nil {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	before, err := convertions.ConvertStringTimestamp(request.FormValue("before"))
+	if err != nil {
+		before = time.Now()
+	}
+
+	messagesCap, err := convertions.ConvertStringUint32(request.FormValue("messages"))
+	if err != nil {
+		messagesCap = globals.MaxDirectMsgCache
+	}
+
+	conn, ok := cache.CacheGetConnection(user, connectionId)
+	if !ok {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	buffer, bufferSize := conn.GetSortedMessagesBuff()
+
+	var validBufCount uint32
+	for validBufCount < bufferSize && buffer[validBufCount].CreatedAt.Before(before) {
+		validBufCount++
+	}
+
+	var messages []*types.Message
+
+	if validBufCount >= messagesCap {
+		start := validBufCount - messagesCap
+		messages = make([]*types.Message, messagesCap)
+		for i := uint32(0); i < messagesCap; i++ {
+			messages[i] = buffer[start+i]
+		}
+	} else {
+		remaining := messagesCap - validBufCount
+		cutoff := before
+		if validBufCount > 0 {
+			cutoff = buffer[0].CreatedAt
+		}
+		dbMessages, err := postgresql.PgConnectionGetMessagesBefore(ctx, cutoff, connectionId, remaining)
+		if err != nil {
+			http.Error(response, "internal server error", http.StatusInternalServerError)
+			return
+		}
+		messages = make([]*types.Message, 0, uint32(len(dbMessages))+validBufCount)
+		messages = append(messages, dbMessages...)
+		for i := uint32(0); i < validBufCount; i++ {
+			messages = append(messages, buffer[i])
+		}
+	}
+
+	json, err := json2.Marshal(messages)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+	response.Write(json)
+}
+
+func HandleUserNewConnection(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+	requestor, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+	recipientId, err := convertions.ConvertStringUuid(request.FormValue("recipient"))
+	if err != nil {
+		http.Error(response, "no such user", http.StatusUnauthorized)
+		return
+	}
+	recipient, err := GetUserById(ctx, recipientId)
+	if err != nil {
+		http.Error(response, "no such user", http.StatusUnauthorized)
+		return
+	}
+
+	if requestor.Id == recipient.Id {
+		http.Error(response, "cannot connect to yourself", http.StatusBadRequest)
+		return
+	}
+
+	requestor.Mu.RLock()
+	for _, connection := range requestor.Connections {
+		if (connection.RequestorId == requestor.Id && connection.RecipientId == recipient.Id) ||
+			(connection.RecipientId == requestor.Id && connection.RequestorId == recipient.Id) {
+			requestor.Mu.RUnlock()
+			http.Error(response, "connection already exists", http.StatusBadRequest)
+			return
+		}
+	}
+	requestor.Mu.RUnlock()
+
+	connection := &types.Connection{
+		CreatedAt:   time.Now(),
+		RequestorId: requestor.Id,
+		RecipientId: recipient.Id,
+		State:       ConnectionState.Stranger,
+	}
+	err = postgresql.PgConnectionSave(ctx, connection)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+	cache.CacheAddConnection(requestor, recipient, connection)
+
+	wsServer.WsSendMessageCloseIfTimeout(recipient, types.WsEventMessage{
+		Type:  WsEventType.ConnectionCreated,
+		Event: connection,
+	})
+
+	response.WriteHeader(http.StatusCreated)
+	return
+}
+
+func HandleUserDeleteConnection(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	connectionId, err := convertions.ConvertStringUuid(request.FormValue("connectionid"))
+	if err != nil {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	conn, ok := cache.CacheGetConnection(user, connectionId)
+	if !ok {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	var user2 *types.User
+	if conn.RequestorId == user.Id {
+		recipient, err := GetUserById(ctx, conn.RecipientId)
+		if err != nil {
+			http.Error(response, "internal server error", http.StatusInternalServerError)
+			return
+		}
+		user2 = recipient
+	} else if conn.RecipientId == user.Id {
+		requestor, err := GetUserById(ctx, conn.RequestorId)
+		if err != nil {
+			http.Error(response, "internal server error", http.StatusInternalServerError)
+			return
+		}
+		user2 = requestor
+	} else {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	err = postgresql.PgConnectionDelete(ctx, conn)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	cache.CacheDeleteConnection(user, user2, connectionId)
+	wsServer.WsSendMessageCloseIfTimeout(user2, types.WsEventMessage{
+		Type:  WsEventType.ConnectionDeleted,
+		Event: connectionId,
+	})
+
+	response.WriteHeader(http.StatusAccepted)
+}
+
+func HandleUserElevateConnection(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+	connectionId, err := convertions.ConvertStringUuid(request.FormValue("connectionid"))
+	if err != nil {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+	conn, ok := cache.CacheGetConnection(user, connectionId)
+	if !ok {
+		http.Error(response, "invalid connectionid", http.StatusBadRequest)
+		return
+	}
+
+	response.WriteHeader(http.StatusAccepted)
+
+	if conn.UserWantingToElevate != (uuid.UUID{}) && conn.UserWantingToElevate != user.Id {
+		switch conn.State {
+		case ConnectionState.Stranger:
+			conn.State = ConnectionState.Friend
+			break
+		case ConnectionState.GroupFellow:
+			conn.State = ConnectionState.Stranger
+			break
+		default:
+			http.Error(response, "cannot elevate further", http.StatusBadRequest)
+			return
+		}
+
+		err = postgresql.PgConnectionUpdateState(ctx, conn)
+		if err != nil {
+			http.Error(response, "internal server error", http.StatusInternalServerError)
+			return
+		}
+		response.Write([]byte("elevated"))
+
+		var user2 *types.User
+		if conn.RequestorId == user.Id {
+			user2, err = GetUserById(ctx, conn.RecipientId)
+		} else {
+			user2, err = GetUserById(ctx, conn.RequestorId)
+		}
+		if err != nil {
+			http.Error(response, "internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		wsServer.WsSendMessageCloseIfTimeout(user2, types.WsEventMessage{
+			Type: WsEventType.ConnectionElevated,
+			Event: types.ConnectionElevationData{
+				Id:       connectionId,
+				NewState: conn.State,
+			},
+		})
+
+		return
+	}
+
+	conn.UserWantingToElevate = user.Id
+	response.Write([]byte("waiting for second user to elevate"))
+}
+
+func HandleUserGetConnections(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	user.Mu.RLock()
+	connections := slices.Collect(maps.Values(user.Connections))
+	user.Mu.RUnlock()
+	json, err := json2.Marshal(connections)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+	response.Write(json)
+}
@@ -0,0 +1,193 @@
+package http
+
+import (
+	json2 "encoding/json"
+	"net/http"
+	"time"
+
+	"go-socket/packages/cache"
+	"go-socket/packages/convertions"
+	"go-socket/packages/passwords"
+	"go-socket/packages/postgresql"
+	"go-socket/packages/tokens"
+	"go-socket/packages/types"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+func HandleUserNewToken(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+
+	username := request.FormValue("username")
+	if len(username) < 4 {
+		http.Error(response, "no or short username", http.StatusBadRequest)
+		return
+	}
+
+	password := request.FormValue("passwords")
+
+	if len(password) < 8 {
+		http.Error(response, "no or short passwords", http.StatusBadRequest)
+		return
+	}
+
+	var (
+		user *types.User
+		err  error
+		ctx  = request.Context()
+	)
+
+	user, err = cache.CacheGetUserByName(username)
+	if err != nil {
+		user = &types.User{Name: username}
+		if err = postgresql.PgUserGetStandardInfoByName(ctx, user); err != nil {
+			http.Error(response, "bad login", http.StatusUnauthorized)
+			return
+		}
+		if err = postgresql.PgGetWholeUser(ctx, user); err != nil {
+			http.Error(response, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	err = bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password))
+	if err != nil {
+		http.Error(response, "bad login", http.StatusUnauthorized)
+		return
+	}
+
+	token, err := tokens.TokenCreate(user.Id)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	json, err := json2.Marshal(types.LoginReturn{Token: token, UserId: user.Id})
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	response.WriteHeader(http.StatusCreated)
+	response.Write(json)
+}
+
+func HandleUserNew(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+
+	username := request.FormValue("username")
+	if len(username) < 4 {
+		http.Error(response, "no or short username", http.StatusBadRequest)
+		return
+	}
+
+	password := request.FormValue("passwords")
+	if len(password) < 8 {
+		http.Error(response, "no or short passwords", http.StatusBadRequest)
+		return
+	}
+
+	hashedPassword, err := passwords.PasswordHash(password)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	newUser := &types.User{
+		Name:         username,
+		PasswordHash: hashedPassword,
+		Color:        types.Rgba{}.GetRandom(),
+		CreatedAt:    time.Now(),
+	}
+
+	ctx := request.Context()
+
+	err = postgresql.PgUserSave(ctx, newUser)
+	if err != nil {
+		http.Error(response, "name taken", http.StatusUnauthorized)
+		return
+	}
+
+	response.WriteHeader(http.StatusCreated)
+}
+
+func HandleUserDelete(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+	ctx := request.Context()
+
+	userId, err := tokens.TokenValidateGetId(request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	err = postgresql.PgUserDelete(ctx, userId)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	cache.CacheDeleteUser(userId)
+	response.WriteHeader(http.StatusAccepted)
+}
+
+// HandleUserModifyAppearance currently just color
+func HandleUserModifyAppearance(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	color, err := convertions.ConvertStringToRgba(request.FormValue("color"))
+	if err != nil {
+		http.Error(response, "invalid color", http.StatusBadRequest)
+		return
+	}
+	user.Color = color
+	err = postgresql.PgUserSetColor(ctx, user)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+	response.WriteHeader(http.StatusAccepted)
+}
+
+// HandleUserModifyAbout currently just pronouns
+func HandleUserModifyAbout(response http.ResponseWriter, request *http.Request) {
+	if !methodAllowed(&response, request) {
+		return
+	}
+
+	ctx := request.Context()
+	user, err := GetUserByToken(ctx, request.FormValue("token"))
+	if err != nil {
+		http.Error(response, "invalid token", http.StatusUnauthorized)
+		return
+	}
+
+	pronouns := request.FormValue("pronouns")
+	if len(pronouns) > 25 || len(pronouns) < 2 {
+		http.Error(response, "invalid pronouns", http.StatusBadRequest)
+		return
+	}
+
+	user.Pronouns = pronouns
+	err = postgresql.PgUserSetPronouns(ctx, user)
+	if err != nil {
+		http.Error(response, "internal server error", http.StatusInternalServerError)
+		return
+	}
+	response.WriteHeader(http.StatusAccepted)
+}