Services

// PostService owns every database read and write for posts.
type PostService struct {
    DB *gorm.DB
}

// postListConfig is what a client may search, sort and filter posts
// by. Whitelisted, because each name ends up in SQL.
var postListConfig = paginate.Config{
    Searchable: []string{"title", "body"},
    Sortable:   map[string]bool{"id": true, "created_at": true, "title": true, "published": true},
    Filterable: map[string]bool{"id": true, "title": true, "published": true},
}

// writablePost is every column Patch and Bulk may write. id, the
// timestamps and the version are the framework's, and are dropped.
var writablePost = map[string]bool{
    "title":     true,
    "body":      true,
    "published": true,
}

// db binds the database to ctx, so whatever a middleware put there reaches
// GORM's callbacks: the multitenant plugin scopes by it.
func (s *PostService) db(ctx context.Context) *gorm.DB {
    return s.DB.WithContext(ctx)
}

List(ctx, p paginate.Params, archived string) (paginate.Result[models.Post], error)
Export(ctx, search string, each func(rows []models.Post) error) error
GetByID(ctx, id string) (*models.Post, error)
Create(ctx, item *models.Post) error
Update(ctx, id string, updates map[string]interface{}, pre *concurrency.Precondition) (*models.Post, error)
Patch(ctx, id string, body map[string]interface{}, pre *concurrency.Precondition) (*models.Post, map[string]interface{}, error)
Delete(ctx, id string) (*models.Post, error)
Bulk(ctx, action string, ids []string, patch map[string]interface{}) (PostBulkResult, error)

// In a handler. The generated ctx helper does exactly this.
ctx := authz.WithActor(c.Request.Context(), authz.ActorOf(c))

// In a job or a command, acting for the system: every row, like ADMIN.
ctx := authz.AsSystem(context.Background())

// Acting for one user, so owned rows are scoped to them.
ctx := authz.WithActor(context.Background(), authz.Actor{UserID: userID})

svc := &services.InvoiceService{DB: db}
ctx := authz.AsSystem(context.Background())

// nil precondition: no version check. A job is not editing a copy it read earlier.
if _, err := svc.Update(ctx, id, map[string]interface{}{"status": "overdue"}, nil); err != nil {
    return fmt.Errorf("marking invoice %s overdue: %w", id, err)
}

// MarkPaid records a payment. The rule lives here, so the route, the
// nightly reconciliation job and a test all get the same answer.
func (s *InvoiceService) MarkPaid(ctx context.Context, id string) (*models.Invoice, error) {
    item, err := s.load(ctx, id) // not found if the caller may not see it
    if err != nil {
        return nil, err
    }
    if item.PaidAt != nil {
        return nil, respond.Rule("invoice %s is already paid", item.Number) // 422
    }
    now := time.Now()
    if err := s.db(ctx).Model(item).Update("paid_at", now).Error; err != nil {
        return nil, fmt.Errorf("marking invoice paid: %w", err)
    }
    item.PaidAt = &now
    return item, nil
}

func (h *InvoiceHandler) MarkPaid(c *gin.Context) {
    item, err := h.service().MarkPaid(h.ctx(c), c.Param("id"))
    if err != nil {
        h.fail(c, err, "Failed to mark invoice paid")
        return
    }
    c.JSON(http.StatusOK, gin.H{"data": item, "message": "Invoice marked paid"})
}

// CreateOrder creates an order and decrements product stock atomically.
func (s *OrderService) CreateOrder(ctx context.Context, order *models.Order, items []models.OrderItem) error {
    return s.db(ctx).Transaction(func(tx *gorm.DB) error {
        if err := tx.Create(order).Error; err != nil {
            return fmt.Errorf("creating order: %w", err)
        }

        for i := range items {
            items[i].OrderID = order.ID
            if err := tx.Create(&items[i]).Error; err != nil {
                return fmt.Errorf("creating order item: %w", err)
            }

            result := tx.Model(&models.Product{}).
                Where("id = ? AND stock >= ?", items[i].ProductID, items[i].Quantity).
                Update("stock", gorm.Expr("stock - ?", items[i].Quantity))
            if result.Error != nil {
                return fmt.Errorf("updating stock: %w", result.Error)
            }
            if result.RowsAffected == 0 {
                return respond.Rule("not enough stock for product %s", items[i].ProductID)
            }
        }
        return nil // commit
    })
}