feat: v4Internal/notifications & better notification/order handling for map builder invites.

Notifications added to v4 internal. The create endpoint is removed (for now only created from service). It also is no longer a subpath of player since that was redundant everywhere but create.

Map builder invites now handle revoking invites if removed from a map before accepting, as well as weird acceptance/denial when not pending

Author: mworzala

api/mapsV3/intnl/openapi.yaml

@@ -456,6 +456,9 @@ paths:
         - name: playerId
           in: query
           schema: { type: string }
+        - name: notify
+          in: query
+          schema: { type: boolean }
       responses:
         '200':
           description: Leaderboard successfully deleted

api/mapsV3/intnl/server.gen.go

@@ -47,7 +47,7 @@ type server struct {
 
 	objectClient object.Client
 
-	notificationManager notification.Manager
+	notifications notification.Manager
 }
 
 func NewServer(params ServerParams) (StrictServerInterface, error) {
@@ -64,13 +64,13 @@ func NewServer(params ServerParams) (StrictServerInterface, error) {
 	}
 
 	return &server{
-		log:                 params.Log,
-		store:               params.Store,
-		playerStore:         params.PlayerStore,
-		redis:               params.Redis,
-		jetStream:           params.JetStream,
-		metrics:             params.Metrics,
-		objectClient:        params.Object,
-		notificationManager: params.NotificationManager,
+		log:           params.Log,
+		store:         params.Store,
+		playerStore:   params.PlayerStore,
+		redis:         params.Redis,
+		jetStream:     params.JetStream,
+		metrics:       params.Metrics,
+		objectClient:  params.Object,
+		notifications: params.NotificationManager,
 	}, nil
 }

api/mapsV3/intnl/server.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/hollow-cube/api-server/internal/pkg/common"
 	"github.com/hollow-cube/api-server/internal/pkg/model"
+	"github.com/hollow-cube/api-server/internal/pkg/notification"
 	"github.com/redis/rueidis"
 )
 
@@ -173,6 +174,17 @@ func (s *server) DeleteMapLeaderboard(ctx context.Context, request DeleteMapLead
 		if err != nil && !errors.Is(err, rueidis.Nil) {
 			return nil, fmt.Errorf("failed to delete player score: %w", err)
 		}
+
+		if request.Params.Notify != nil && *request.Params.Notify {
+			err = s.notifications.Create(ctx, *playerId, notification.CreateInput{
+				Key:           request.MapId,
+				Type:          "map_time_deleted",
+				ReplaceUnread: true,
+			})
+			if err != nil {
+				s.log.Warnw("failed to create notification", "playerId", *playerId, "error", err)
+			}
+		}
 	}
 
 	return DeleteMapLeaderboard200Response{}, nil

api/mapsV3/intnl/server_leaderboard.go

@@ -93,25 +93,25 @@ func NewServer(p ServerParams) (StrictServerInterface, error) {
 	}
 
 	return &Server{
-		log:                 p.Log.With("handler", "internal"),
-		metrics:             p.Metrics,
-		store:               p.Store,
-		jetStream:           p.JetStream,
-		tbHeadless:          p.TBHeadless,
-		notificationManager: p.NotificationManager,
-		punishmentLadders:   p.PunishmentLadders,
-		punishmentAliases:   punishmentAliases,
+		log:               p.Log.With("handler", "internal"),
+		metrics:           p.Metrics,
+		store:             p.Store,
+		jetStream:         p.JetStream,
+		tbHeadless:        p.TBHeadless,
+		notifications:     p.NotificationManager,
+		punishmentLadders: p.PunishmentLadders,
+		punishmentAliases: punishmentAliases,
 	}, nil
 }
 
 type Server struct {
 	log     *zap.SugaredLogger
 	metrics metric.Writer
 
-	store               *playerdb.Store
-	jetStream           *natsutil.JetStreamWrapper
-	tbHeadless          *tebex.HeadlessClient
-	notificationManager notification.Manager
+	store         *playerdb.Store
+	jetStream     *natsutil.JetStreamWrapper
+	tbHeadless    *tebex.HeadlessClient
+	notifications notification.Manager
 
 	punishmentLadders map[string]*model.PunishmentLadder
 	punishmentAliases map[model.PunishmentType]map[string]*model.PunishmentLadder
@@ -300,6 +300,7 @@ func (s *Server) GetPlayerAlts(ctx context.Context, request GetPlayerAltsRequest
 	return GetPlayerAlts200JSONResponse{Results: results}, nil
 }
 
+// v4
 func (s *Server) CyclePlayerApiKey(ctx context.Context, request CyclePlayerApiKeyRequestObject) (CyclePlayerApiKeyResponseObject, error) {
 	res, err := playerdb.Tx(ctx, s.store, func(ctx context.Context, txStore *playerdb.Store) (*CyclePlayerApiKey200JSONResponse, error) {
 		_, err := txStore.GetPlayerData(ctx, request.PlayerId)
@@ -343,6 +344,7 @@ func (s *Server) GetPlayerId(ctx context.Context, request GetPlayerIdRequestObje
 	return GetPlayerId200TextResponse(pid), nil
 }
 
+// v4
 func (s *Server) PerformTabComplete(ctx context.Context, request PerformTabCompleteRequestObject) (PerformTabCompleteResponseObject, error) {
 	if request.Body.Query == "" {
 		return PerformTabComplete200JSONResponse{Result: []TabCompleteEntry{}}, nil

api/v2/intnl/server.go

@@ -5,12 +5,13 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/hollow-cube/api-server/internal/pkg/model"
 	"github.com/hollow-cube/api-server/internal/pkg/notification"
+	"github.com/hollow-cube/api-server/internal/playerdb"
 )
 
+// v4
 func (s *Server) DeletePlayerNotification(ctx context.Context, request DeletePlayerNotificationRequestObject) (DeletePlayerNotificationResponseObject, error) {
-	if err := s.notificationManager.DeleteNotification(ctx, request.NotificationId, request.PlayerId); err != nil {
+	if err := s.notifications.Delete(ctx, request.NotificationId); err != nil {
 		if errors.Is(err, notification.ErrNotFound) {
 			return DeletePlayerNotification404Response{}, nil
 		}
@@ -19,6 +20,7 @@ func (s *Server) DeletePlayerNotification(ctx context.Context, request DeletePla
 	return DeletePlayerNotification200Response{}, nil
 }
 
+// v4
 func (s *Server) GetPlayerNotifications(ctx context.Context, request GetPlayerNotificationsRequestObject) (GetPlayerNotificationsResponseObject, error) {
 	var unreadOnly = request.Params.Unread != nil && *request.Params.Unread
 
@@ -30,26 +32,29 @@ func (s *Server) GetPlayerNotifications(ctx context.Context, request GetPlayerNo
 		return GetPlayerNotifications400JSONResponse{Message: "page must be non-negative"}, nil
 	}
 
-	result, err := s.notificationManager.GetNotifications(ctx, request.PlayerId, page, unreadOnly)
+	offset := int32(page * 21)
+	limit := int32(21)
+
+	result, count, err := s.notifications.List(ctx, request.PlayerId, unreadOnly, offset, limit)
 	if err != nil {
 		return nil, err
 	}
 
-	results := make([]PlayerNotification, len(result.Results))
-	for i, notif := range result.Results {
+	results := make([]PlayerNotification, len(result))
+	for i, notif := range result {
 		results[i] = notificationToApi(notif)
 	}
 
 	return GetPlayerNotifications200JSONResponse{
-		Page:      result.Page,
-		PageCount: result.PageCount,
+		Page:      int32(page),
+		PageCount: int32(count/21) + 1,
 		Results:   results,
 	}, nil
 }
 
-func notificationToApi(n notification.Notification) PlayerNotification {
+func notificationToApi(n playerdb.PlayerNotification) PlayerNotification {
 	return PlayerNotification{
-		Id:        n.Id,
+		Id:        n.ID,
 		Type:      n.Type,
 		Key:       n.Key,
 		Data:      n.Data,
@@ -59,8 +64,9 @@ func notificationToApi(n notification.Notification) PlayerNotification {
 	}
 }
 
+// v4
 func (s *Server) UpdatePlayerNotification(ctx context.Context, request UpdatePlayerNotificationRequestObject) (UpdatePlayerNotificationResponseObject, error) {
-	if err := s.notificationManager.UpdateNotification(ctx, request.NotificationId, request.PlayerId, request.Body.Read); err != nil {
+	if err := s.notifications.SetReadState(ctx, request.NotificationId, request.Body.Read); err != nil {
 		if errors.Is(err, notification.ErrNotFound) {
 			return UpdatePlayerNotification404Response{}, nil
 		}
@@ -69,6 +75,7 @@ func (s *Server) UpdatePlayerNotification(ctx context.Context, request UpdatePla
 	return UpdatePlayerNotification200Response{}, nil
 }
 
+// v4 removed
 func (s *Server) CreatePlayerNotification(ctx context.Context, request CreatePlayerNotificationRequestObject) (CreatePlayerNotificationResponseObject, error) {
 	replaceUnread := false
 	if request.Params.ReplaceUnread != nil {
@@ -79,23 +86,23 @@ func (s *Server) CreatePlayerNotification(ctx context.Context, request CreatePla
 		Key:           request.Body.Key,
 		Type:          request.Body.Type,
 		ExpiresIn:     request.Body.ExpiresIn,
-		Data:          request.Body.Data,
+		Data:          *request.Body.Data,
 		ReplaceUnread: replaceUnread,
 	}
-	if err := s.notificationManager.Create(ctx, request.PlayerId, input); err != nil {
+	if err := s.notifications.Create(ctx, request.PlayerId, input); err != nil {
 		return nil, err
 	}
 
 	return CreatePlayerNotification201Response{}, nil
 }
 
 func (s *Server) sendNotificationMessage(ctx context.Context, request CreatePlayerNotificationRequestObject) error {
-	msg := model.NotificationUpdateMessage{
-		Action:   model.NotificationCreateAction,
+	msg := notification.UpdateMessage{
+		Action:   notification.CreateAction,
 		PlayerId: request.PlayerId,
 		Type:     request.Body.Type,
 		Key:      request.Body.Key,
-		Data:     request.Body.Data,
+		Data:     *request.Body.Data,
 	}
 	if err := s.jetStream.PublishJSONAsync(ctx, msg); err != nil {
 		return fmt.Errorf("failed to publish notification message: %w", err)

api/v2/intnl/server_notifications.go

@@ -338,12 +338,12 @@ func (s *Server) SendFriendRequest(ctx context.Context, request SendFriendReques
 			ReplaceUnread: false,
 		}
 		// Send notification of friend request (to both players)
-		if err := s.notificationManager.Create(ctx, request.TargetId, notifInput); err != nil {
+		if err := s.notifications.Create(ctx, request.TargetId, notifInput); err != nil {
 			s.log.Warnw("failed to send friendship notification - continuing", "playerId", request.PlayerId, "targetId", request.TargetId, "err", err)
 		}
 
 		notifInput.Key = request.TargetId
-		if err := s.notificationManager.Create(ctx, request.PlayerId, notifInput); err != nil {
+		if err := s.notifications.Create(ctx, request.PlayerId, notifInput); err != nil {
 			s.log.Warnw("failed to send friendship notification - continuing", "playerId", request.PlayerId, "targetId", request.TargetId, "err", err)
 		}
 		return SendFriendRequest201JSONResponse{IsRequest: false}, nil
@@ -388,7 +388,7 @@ func (s *Server) SendFriendRequest(ctx context.Context, request SendFriendReques
 	}
 
 	// Send notification of friend request
-	if err := s.notificationManager.Create(ctx, request.TargetId, notification.CreateInput{
+	if err := s.notifications.Create(ctx, request.TargetId, notification.CreateInput{
 		Key:           request.PlayerId, // Use the player ID as the key for a friend_request type
 		Type:          "friend_request",
 		ReplaceUnread: true,

api/v2/intnl/server_relationships.go

@@ -150,6 +150,66 @@ paths:
             responses:
                 "200":
                     description: Successful response
+    /notifications:
+        get:
+            operationId: getNotifications
+            parameters:
+                - name: playerId
+                  in: query
+                  required: true
+                  schema:
+                    type: string
+                - name: page
+                  in: query
+                  required: true
+                  schema:
+                    type: integer
+                - name: pageSize
+                  in: query
+                  required: true
+                  schema:
+                    type: integer
+                - name: unreadOnly
+                  in: query
+                  required: true
+                  schema:
+                    type: boolean
+            responses:
+                "200":
+                    description: Successful response
+                    content:
+                        application/json:
+                            schema:
+                                type: object
+    /notifications/{notificationId}:
+        delete:
+            operationId: deleteNotification
+            parameters:
+                - name: notificationId
+                  in: path
+                  required: true
+                  schema:
+                    type: string
+            responses:
+                "204":
+                    description: Successful response
+        patch:
+            operationId: updateNotification
+            parameters:
+                - name: notificationId
+                  in: path
+                  required: true
+                  schema:
+                    type: string
+            requestBody:
+                required: true
+                content:
+                    application/json:
+                        schema:
+                            type: object
+            responses:
+                "200":
+                    description: Successful response
     /players:
         post:
             operationId: createPlayerData