Implemented network positions per user on client and server

2 files changed, 32 insertions, 4 deletions

diff --git a/internal/server/api/api.go b/internal/server/api/api.go
index 53ef76a..ec3adf9 100644
--- a/internal/server/api/api.go
+++ b/internal/server/api/api.go
@@ -220,3 +220,20 @@ func GetNetworksInfo(ctx context.Context, sess *session.Session) (packet.Payload
 
 	return networksInfo, nil
 }
+
+// FIXME: Deletion of a network is not handled! it needs to be shifted like how it works with frequencies!
+func SwapUserNetworks(ctx context.Context, sess *session.Session, request *packet.SwapUserNetworks) packet.Payload {
+	queries := data.New(db)
+	pos1, pos2 := int64(request.Pos1), int64(request.Pos2)
+	err := queries.SwapUserNetworks(ctx, data.SwapUserNetworksParams{
+		Pos1:   &pos1,
+		Pos2:   &pos2,
+		UserID: sess.ID(),
+	})
+	if err != nil {
+		log.Println("database error:", err)
+		return &internalError
+	}
+
+	return request
+}
diff --git a/internal/server/server.go b/internal/server/server.go
index 474be10..2ca0c2a 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -311,16 +311,27 @@ func processRequest(ctx context.Context, sess *session.Session, request packet.P
 
 	// TODO: add a way to measure the time each request/response took and log it
 	// Potentially even separate time for code vs DB operations
+	var response packet.Payload
 	switch request := request.(type) {
 	case *packet.CreateNetwork:
-		return timeout(20*time.Millisecond, api.CreateNetwork, ctx, sess, request)
+		response = timeout(20*time.Millisecond, api.CreateNetwork, ctx, sess, request)
+	case *packet.SwapUserNetworks:
+		response = timeout(5*time.Millisecond, api.SwapUserNetworks, ctx, sess, request)
+
 	case *packet.SendMessage:
-		return timeout(20*time.Millisecond, api.SendMessage, ctx, sess, request)
+		response = timeout(20*time.Millisecond, api.SendMessage, ctx, sess, request)
 	case *packet.RequestMessages:
-		return timeout(50*time.Millisecond, api.RequestMessages, ctx, sess, request)
+		response = timeout(50*time.Millisecond, api.RequestMessages, ctx, sess, request)
+
 	default:
-		return &packet.Error{Error: "use of disallowed packet type for request"}
+		response = &packet.Error{Error: "use of disallowed packet type for request"}
 	}
+
+	if response, ok := response.(*packet.Error); ok {
+		response.PktType = request.Type()
+	}
+
+	return response
 }
 
 func timeout[T packet.Payload](