472 lines
12 KiB
Go
472 lines
12 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"cmroubao/backend-api/internal/domain"
|
|
"cmroubao/backend-api/internal/transport/authcommon"
|
|
"cmroubao/backend-api/internal/usecase"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
const claimTokenHeader = "X-Claim-Token"
|
|
|
|
type DeviceServices struct {
|
|
Lifecycle *usecase.LifecycleService
|
|
Assets *usecase.AssetService
|
|
}
|
|
|
|
func (services DeviceServices) validate() error {
|
|
if services.Lifecycle == nil || services.Assets == nil {
|
|
return errors.New("device services are required")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type deviceHandlers struct {
|
|
services DeviceServices
|
|
}
|
|
|
|
func NewDeviceRouteRegistrar(
|
|
services DeviceServices,
|
|
) (RouteRegistrar, error) {
|
|
if err := services.validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
handler := &deviceHandlers{services: services}
|
|
return func(routes gin.IRoutes) error {
|
|
routes.POST(
|
|
"/api/v1/devices/heartbeat",
|
|
handler.heartbeatDevice,
|
|
)
|
|
routes.POST(
|
|
"/api/v1/tasks/claim-next",
|
|
handler.claimNext,
|
|
)
|
|
routes.POST(
|
|
"/api/v1/tasks/:id/start",
|
|
handler.startTask,
|
|
)
|
|
routes.POST(
|
|
"/api/v1/tasks/:id/heartbeat",
|
|
handler.heartbeatTask,
|
|
)
|
|
routes.GET(
|
|
"/api/v1/tasks/:id/reference-image",
|
|
handler.referenceImage,
|
|
)
|
|
routes.POST(
|
|
"/api/v1/tasks/:id/release",
|
|
handler.releaseTask,
|
|
)
|
|
routes.POST(
|
|
"/api/v1/tasks/:id/cancel-ack",
|
|
handler.acknowledgeCancellation,
|
|
)
|
|
return nil
|
|
}, nil
|
|
}
|
|
|
|
func (handler *deviceHandlers) referenceImage(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
generation, err := strconv.ParseInt(
|
|
strings.TrimSpace(ctx.Query("claim_generation")),
|
|
10,
|
|
64,
|
|
)
|
|
if err != nil || generation < 1 {
|
|
writePublicError(
|
|
ctx,
|
|
http.StatusUnprocessableEntity,
|
|
"TASK_REFERENCE_IMAGE_INVALID",
|
|
"task reference image request is invalid",
|
|
false,
|
|
fieldDetails("claim_generation", "must be a positive integer"),
|
|
)
|
|
return
|
|
}
|
|
task, err := handler.services.Lifecycle.AuthorizeReferenceImage(
|
|
ctx.Request.Context(),
|
|
usecase.ReferenceImageCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
TaskID: ctx.Param("id"),
|
|
ClaimGeneration: generation,
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
result, err := handler.services.Assets.OpenTaskReference(
|
|
ctx.Request.Context(),
|
|
localAdminSubject,
|
|
task.ImageAssetID,
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
defer result.Content.Close()
|
|
writeAssetContent(ctx, result)
|
|
}
|
|
|
|
func (handler *deviceHandlers) heartbeatDevice(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
DeviceID string `json:"device_id"`
|
|
AppVersion string `json:"app_version"`
|
|
AndroidVersion string `json:"android_version"`
|
|
PDDVersion string `json:"pdd_version"`
|
|
Readiness struct {
|
|
AccessibilityEnabled bool `json:"accessibility_enabled"`
|
|
PDDInstalled bool `json:"pdd_installed"`
|
|
ActiveTaskID *string `json:"active_task_id"`
|
|
} `json:"readiness"`
|
|
}
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(ctx, request.DeviceID, principal.DeviceID) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.HeartbeatDevice(
|
|
ctx.Request.Context(),
|
|
usecase.DeviceHeartbeatCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
AppVersion: request.AppVersion,
|
|
AndroidVersion: request.AndroidVersion,
|
|
PDDVersion: request.PDDVersion,
|
|
AccessibilityEnabled: request.Readiness.AccessibilityEnabled,
|
|
PDDInstalled: request.Readiness.PDDInstalled,
|
|
ClientActiveTaskID: request.Readiness.ActiveTaskID,
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"device_id": result.Device.ID,
|
|
"readiness": gin.H{
|
|
"reported_at": formatOptionalTime(result.Device.ReadinessAt),
|
|
"accessibility_enabled": result.Device.AccessibilityEnabled,
|
|
"pdd_installed": result.Device.PDDInstalled,
|
|
},
|
|
"active_task_id": result.ActiveTaskID,
|
|
"client_state_matches": result.ClientStateMatches,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
func (handler *deviceHandlers) claimNext(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
DeviceID string `json:"device_id"`
|
|
}
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(ctx, request.DeviceID, principal.DeviceID) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.ClaimNext(
|
|
ctx.Request.Context(),
|
|
usecase.ClaimNextCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
IdempotencyKey: ctx.GetHeader("Idempotency-Key"),
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
if result.Task == nil {
|
|
ctx.Status(http.StatusNoContent)
|
|
return
|
|
}
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"task": deviceTaskResponse(*result.Task),
|
|
"replayed": result.Replayed,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
func (handler *deviceHandlers) startTask(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request lifecycleTransitionRequest
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(ctx, request.DeviceID, principal.DeviceID) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.StartTask(
|
|
ctx.Request.Context(),
|
|
usecase.StartTaskCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
TaskID: ctx.Param("id"),
|
|
ClaimGeneration: request.ClaimGeneration,
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
ExpectedVersion: request.ExpectedVersion,
|
|
IdempotencyKey: ctx.GetHeader("Idempotency-Key"),
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"task": deviceTaskResponse(result.Task),
|
|
"execution": deviceExecutionResponse(
|
|
result.Execution,
|
|
result.Task.ClaimExpiresAt,
|
|
),
|
|
"replayed": result.Replayed,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
func (handler *deviceHandlers) heartbeatTask(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
DeviceID string `json:"device_id"`
|
|
ExecutionID string `json:"execution_id"`
|
|
ClaimGeneration int64 `json:"claim_generation"`
|
|
Step string `json:"step"`
|
|
}
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(ctx, request.DeviceID, principal.DeviceID) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.HeartbeatTask(
|
|
ctx.Request.Context(),
|
|
usecase.TaskHeartbeatCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
TaskID: ctx.Param("id"),
|
|
ExecutionID: request.ExecutionID,
|
|
ClaimGeneration: request.ClaimGeneration,
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
Step: request.Step,
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"task": deviceTaskResponse(result.Task),
|
|
"execution": deviceExecutionResponse(
|
|
result.Execution,
|
|
result.Task.ClaimExpiresAt,
|
|
),
|
|
"cancel_requested": result.CancelRequested,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
func (handler *deviceHandlers) releaseTask(ctx *gin.Context) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request lifecycleTransitionRequest
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(ctx, request.DeviceID, principal.DeviceID) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.ReleaseTask(
|
|
ctx.Request.Context(),
|
|
usecase.ReleaseTaskCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
TaskID: ctx.Param("id"),
|
|
ClaimGeneration: request.ClaimGeneration,
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
ExpectedVersion: request.ExpectedVersion,
|
|
IdempotencyKey: ctx.GetHeader("Idempotency-Key"),
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"task": deviceTaskResponse(result.Task),
|
|
"replayed": result.Replayed,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
func (handler *deviceHandlers) acknowledgeCancellation(
|
|
ctx *gin.Context,
|
|
) {
|
|
principal, ok := devicePrincipal(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
var request struct {
|
|
lifecycleTransitionRequest
|
|
ExecutionID string `json:"execution_id"`
|
|
}
|
|
if !decodeDeviceJSON(ctx, &request) ||
|
|
!deviceIDMatches(
|
|
ctx,
|
|
request.DeviceID,
|
|
principal.DeviceID,
|
|
) {
|
|
return
|
|
}
|
|
result, err := handler.services.Lifecycle.AcknowledgeCancellation(
|
|
ctx.Request.Context(),
|
|
usecase.AcknowledgeCancellationCommand{
|
|
UserID: principal.UserID,
|
|
DeviceID: principal.DeviceID,
|
|
TaskID: ctx.Param("id"),
|
|
ExecutionID: request.ExecutionID,
|
|
ClaimGeneration: request.ClaimGeneration,
|
|
ClaimToken: ctx.GetHeader(claimTokenHeader),
|
|
ExpectedVersion: request.ExpectedVersion,
|
|
IdempotencyKey: ctx.GetHeader("Idempotency-Key"),
|
|
},
|
|
)
|
|
if err != nil {
|
|
writeUsecaseError(ctx, err)
|
|
return
|
|
}
|
|
ctx.Header("Cache-Control", "no-store")
|
|
ctx.JSON(http.StatusOK, gin.H{
|
|
"task": deviceTaskResponse(result.Task),
|
|
"replayed": result.Replayed,
|
|
"server_time": formatTime(result.ServerTime),
|
|
})
|
|
}
|
|
|
|
type lifecycleTransitionRequest struct {
|
|
DeviceID string `json:"device_id"`
|
|
ClaimGeneration int64 `json:"claim_generation"`
|
|
ExpectedVersion int64 `json:"expected_version"`
|
|
}
|
|
|
|
func devicePrincipal(
|
|
ctx *gin.Context,
|
|
) (domain.AuthPrincipal, bool) {
|
|
principal, ok := authcommon.Principal(ctx.Request.Context())
|
|
if ok &&
|
|
principal.Role == domain.UserRoleBuyer &&
|
|
principal.UserID != "" &&
|
|
principal.DeviceID != "" {
|
|
return principal, true
|
|
}
|
|
writePublicError(
|
|
ctx,
|
|
http.StatusUnauthorized,
|
|
"DEVICE_ACCESS_REQUIRED",
|
|
"device access token required",
|
|
false,
|
|
gin.H{},
|
|
)
|
|
return domain.AuthPrincipal{}, false
|
|
}
|
|
|
|
func decodeDeviceJSON(ctx *gin.Context, target any) bool {
|
|
if !hasMediaType(ctx, "application/json") {
|
|
writePublicError(
|
|
ctx,
|
|
http.StatusUnsupportedMediaType,
|
|
"UNSUPPORTED_MEDIA_TYPE",
|
|
"application/json is required",
|
|
false,
|
|
gin.H{},
|
|
)
|
|
return false
|
|
}
|
|
if err := decodeJSON(ctx, target); err != nil {
|
|
writePublicError(
|
|
ctx,
|
|
http.StatusBadRequest,
|
|
"INVALID_JSON",
|
|
"request body must be valid JSON",
|
|
false,
|
|
gin.H{},
|
|
)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func deviceIDMatches(
|
|
ctx *gin.Context,
|
|
presented string,
|
|
authoritative string,
|
|
) bool {
|
|
if presented == "" || presented == authoritative {
|
|
return true
|
|
}
|
|
writePublicError(
|
|
ctx,
|
|
http.StatusForbidden,
|
|
"DEVICE_ID_MISMATCH",
|
|
"request device does not match access token",
|
|
false,
|
|
gin.H{},
|
|
)
|
|
return false
|
|
}
|
|
|
|
func deviceTaskResponse(task domain.PurchaseTask) gin.H {
|
|
referenceImageURL := "/api/v1/tasks/" + task.ID +
|
|
"/reference-image?claim_generation=" +
|
|
strconv.FormatInt(task.ClaimGeneration, 10)
|
|
return gin.H{
|
|
"id": task.ID,
|
|
"status": task.Status,
|
|
"version": task.Version,
|
|
"claim_generation": task.ClaimGeneration,
|
|
"claim_issued_at": formatOptionalTime(task.ClaimIssuedAt),
|
|
"claim_expires_at": formatOptionalTime(task.ClaimExpiresAt),
|
|
"title": task.Title,
|
|
"description": task.Description,
|
|
"sku": task.SKU,
|
|
"image_asset_id": task.ImageAssetID,
|
|
"reference_image_url": referenceImageURL,
|
|
"quantity": task.Quantity,
|
|
"max_budget": domain.FormatOptionalCNY(task.MaxBudgetCents),
|
|
"currency": task.Currency,
|
|
}
|
|
}
|
|
|
|
func deviceExecutionResponse(
|
|
execution domain.TaskExecution,
|
|
expiresAt *time.Time,
|
|
) gin.H {
|
|
response := executionResponse(execution)
|
|
response["execution_expires_at"] = formatOptionalTime(expiresAt)
|
|
return response
|
|
}
|