feat: /@me/status public api (#21)

* feat: start public apis

* chore: dont omit if empty

Author: ThatGravyBoat

api/v1Public/model_player.go

@@ -0,0 +1,52 @@
+package v1Public
+
+import (
+	"github.com/hollow-cube/api-server/internal/db"
+)
+
+type PlayerActivityType string
+
+const (
+	PlayerActivityUnknown   PlayerActivityType = "unknown"
+	PlayerActivityHub       PlayerActivityType = "hub"
+	PlayerActivityPlaying   PlayerActivityType = "playing"
+	PlayerActivityVerifying PlayerActivityType = "verifying"
+	PlayerActivityBuilding  PlayerActivityType = "building"
+)
+
+type PlayerActivity struct {
+	Type PlayerActivityType `json:"type"`
+	Name *string            `json:"name"`
+	Id   *string            `json:"id"`
+	Code *string            `json:"code"`
+}
+
+type PlayerStatus struct {
+	Online   bool            `json:"online"`
+	Activity *PlayerActivity `json:"activity"`
+}
+
+func GetPlayerActivityTypeFromSession(session db.PlayerSession) PlayerActivityType {
+	if session.PType != nil {
+		switch *session.PType {
+		case "mapmaker:hub":
+			return PlayerActivityHub
+		case "mapmaker:map":
+			if session.PState != nil {
+				switch *session.PState {
+				case "editing":
+					fallthrough
+				case "testing":
+					return PlayerActivityBuilding
+				case "verifying":
+					return PlayerActivityVerifying
+				case "playing":
+					fallthrough
+				case "spectating":
+					return PlayerActivityPlaying
+				}
+			}
+		}
+	}
+	return PlayerActivityUnknown
+}

api/v1Public/openapi.yaml

@@ -0,0 +1,21 @@
+openapi: 3.0.3
+info:
+  title: Server API
+  version: "1.0"
+paths:
+  /@me/status:
+    get:
+      operationId: getPlayerStatus
+      parameters:
+        - name: x-auth-user
+          in: header
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object

api/v1Public/server.gen.go

@@ -0,0 +1,53 @@
+//go:generate go run ../../cmd/ox/main.go generate ./.Server
+
+package v1Public
+
+import (
+	sessiondb "github.com/hollow-cube/api-server/internal/db"
+	"github.com/hollow-cube/api-server/internal/interaction"
+	"github.com/hollow-cube/api-server/internal/mapdb"
+	"github.com/hollow-cube/api-server/internal/pkg/notification"
+	"github.com/hollow-cube/api-server/internal/playerdb"
+	"go.uber.org/fx"
+	"go.uber.org/zap"
+)
+
+type ServerParams struct {
+	fx.In
+
+	Log          *zap.SugaredLogger
+	PlayerStore  *playerdb.Store
+	MapStore     *mapdb.Store
+	SessionStore *sessiondb.Queries
+
+	Notifications notification.Manager
+	Interactions  *interaction.Handler
+}
+
+type Server struct {
+	log *zap.SugaredLogger
+
+	playerStore  *playerdb.Store
+	mapStore     *mapdb.Store
+	sessionStore *sessiondb.Queries
+
+	notifications notification.Manager
+	interactions  *interaction.Handler
+}
+
+type AuthenticatedRequest struct {
+	PlayerID string `header:"x-auth-user"`
+}
+
+func NewServer(p ServerParams) (*Server, error) {
+	s := &Server{
+		log:           p.Log,
+		playerStore:   p.PlayerStore,
+		mapStore:      p.MapStore,
+		sessionStore:  p.SessionStore,
+		notifications: p.Notifications,
+		interactions:  p.Interactions,
+	}
+
+	return s, nil
+}

api/v1Public/server.go

@@ -0,0 +1,49 @@
+package v1Public
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/hollow-cube/api-server/internal/mapdb"
+)
+
+// GET /@me/status
+func (s *Server) GetPlayerStatus(ctx context.Context, request AuthenticatedRequest) (*PlayerStatus, error) {
+	session, err := s.sessionStore.GetPlayerSession(ctx, request.PlayerID)
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+		return nil, err
+	}
+
+	if session == nil || session.Hidden || errors.Is(err, sql.ErrNoRows) {
+		return &PlayerStatus{Online: false, Activity: nil}, nil
+	} else {
+		var sessionType = GetPlayerActivityTypeFromSession(*session)
+		var sessionName *string = nil
+		var sessionId *string = nil
+		var sessionCode *string = nil
+
+		if sessionType == PlayerActivityPlaying && session.PMapID != nil {
+			mapData, err := s.mapStore.GetPublishedMapById(ctx, *session.PMapID)
+			if err != nil && !errors.Is(err, mapdb.ErrNoRows) {
+				return nil, err
+			} else if err == nil && mapData.OptName != nil && mapData.PublishedID != nil {
+				var code = fmt.Sprintf("%03d-%03d-%03d", *mapData.PublishedID/1000000, (*mapData.PublishedID/1000)%1000, *mapData.PublishedID%1000)
+
+				sessionName = mapData.OptName
+				sessionId = &mapData.ID
+				sessionCode = &code
+			}
+		}
+
+		return &PlayerStatus{
+			Online: true,
+			Activity: &PlayerActivity{
+				Type: sessionType,
+				Name: sessionName,
+				Id:   sessionId,
+				Code: sessionCode,
+			},
+		}, nil
+	}
+}

api/v1Public/server_player.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/hollow-cube/api-server/api/v1Public"
 	"net"
 	"net/http"
 
@@ -152,6 +153,7 @@ func main() {
 		fx.Provide(newDynamicExporter),
 		tracefx.Module,
 		fx.Provide(
+			v1Public.NewServer,
 			v4Internal.NewServer,
 
 			v2Public.NewServer,
@@ -189,6 +191,7 @@ func newKubernetesClient(conf *config.Config) (*kubernetes.Clientset, error) {
 }
 
 type routeHandlerImpl struct {
+	v1p *v1Public.Server
 	v4i *v4Internal.Server
 
 	public   v2Public.StrictServerInterface
@@ -214,6 +217,13 @@ func (v *routeHandlerImpl) Apply(r chi.Router) {
 	})
 	r.Handle("/v4/internal/*", v4mux)
 
+	v1Mux := http.NewServeMux()
+	v1Public.RegisterRoutes(v.v1p, v1Public.RegisterParams{
+		Mux:     v1Mux,
+		BaseURL: "/v1",
+	})
+	r.Handle("/v1/*", v1Mux)
+
 	r.Handle("/v2/players/*", v2Public.HandlerFromMuxWithBaseURL(v2Public.NewStrictHandler(v.public, nil), nil, "/v2/players"))
 	r.Handle("/v2/internal/*", v2Internal.HandlerFromMuxWithBaseURL(v2Internal.NewStrictHandler(v.internal, nil), nil, "/v2/internal"))
 	r.Handle("/v2/payments/*", v2Payments.HandlerFromMuxWithBaseURL(v.payments, nil, "/v2/payments"))
@@ -241,6 +251,7 @@ func (v *routeHandlerImpl) Apply(r chi.Router) {
 func makeV2RouteHandler(p struct {
 	fx.In
 
+	V1P          *v1Public.Server
 	V4I          *v4Internal.Server
 	Public       v2Public.StrictServerInterface
 	Internal     v2Internal.StrictServerInterface
@@ -253,6 +264,7 @@ func makeV2RouteHandler(p struct {
 	Discord      *discord.Handler
 }) httpTransport.RouteProvider {
 	return &routeHandlerImpl{
+		v1p:          p.V1P,
 		v4i:          p.V4I,
 		public:       p.Public,
 		internal:     p.Internal,