@robsun/create-keystone-app 0.2.15 → 0.4.1

package/template/apps/server/internal/modules/example/bootstrap/seeds/item.go

@@ -1,11 +1,27 @@
 package seeds
 
 import (
+	"context"
+	"encoding/json"
+	"errors"
 	"log"
+	"time"
 
 	"gorm.io/gorm"
 
-	"__APP_NAME__/apps/server/internal/modules/example/domain/models"
+	approvalmodels "github.com/robsuncn/keystone/domain/approval/models"
+	approvalRepo "github.com/robsuncn/keystone/domain/approval/repository"
+	approvalSvc "github.com/robsuncn/keystone/domain/approval/service"
+	"github.com/robsuncn/keystone/domain/service"
+	"github.com/robsuncn/keystone/infra/repository"
+
+	examplemodels "__APP_NAME__/apps/server/internal/modules/example/domain/models"
+	exampleservice "__APP_NAME__/apps/server/internal/modules/example/domain/service"
+)
+
+const (
+	defaultTenantID = 1
+	defaultUserID   = 1
 )
 
 func Seed(db *gorm.DB) error {
@@ -13,8 +29,13 @@ func Seed(db *gorm.DB) error {
 		return nil
 	}
 
+	flow, err := seedApprovalFlow(db)
+	if err != nil {
+		return err
+	}
+
 	var count int64
-	if err := db.Model(&models.ExampleItem{}).Count(&count).Error; err != nil {
+	if err := db.Model(&examplemodels.ExampleItem{}).Count(&count).Error; err != nil {
 		return err
 	}
 	if count > 0 {
@@ -22,12 +43,200 @@ func Seed(db *gorm.DB) error {
 	}
 
 	log.Println("[example] Seeding initial data...")
-	items := []models.ExampleItem{
-		{Title: "First example item", Description: "A seeded record to explore CRUD.", Status: models.StatusActive},
-		{Title: "Inactive example item", Description: "Use status to drive UI state.", Status: models.StatusInactive},
+	items := []examplemodels.ExampleItem{
+		{
+			Number:      "EX-20240101-0001",
+			Title:       "Launch Plan",
+			Description: "Sample record to demonstrate approval and import/export flows.",
+			Category:    examplemodels.CategoryOperations,
+			Amount:      1200,
+			Status:      examplemodels.StatusDraft,
+		},
+		{
+			Number:      "EX-20240101-0002",
+			Title:       "Budget Request",
+			Description: "Draft item with finance category.",
+			Category:    examplemodels.CategoryFinance,
+			Amount:      5600,
+			Status:      examplemodels.StatusDraft,
+		},
+		{
+			Number:      "EX-20240101-0003",
+			Title:       "Growth Campaign",
+			Description: "Draft item for marketing.",
+			Category:    examplemodels.CategoryGrowth,
+			Amount:      3200,
+			Status:      examplemodels.StatusDraft,
+		},
+		{
+			Number:      "EX-20240101-0004",
+			Title:       "Ops Checklist",
+			Description: "Draft item for operations runbook.",
+			Category:    examplemodels.CategoryOperations,
+			Amount:      0,
+			Status:      examplemodels.StatusDraft,
+		},
+	}
+        var userID uint = defaultUserID
+        for i := range items {
+                items[i].TenantID = defaultTenantID
+                items[i].CreatedBy = &userID
+                items[i].UpdatedBy = &userID
+        }
+	if err := db.Create(&items).Error; err != nil {
+		return err
+	}
+
+	if flow != nil && len(items) > 0 {
+		if err := seedPendingInstance(db, flow, &items[0]); err != nil {
+			log.Printf("[example] seed approval instance failed: %v", err)
+		}
+	}
+	return nil
+}
+
+func seedApprovalFlow(db *gorm.DB) (*approvalmodels.ApprovalFlow, error) {
+	ctx := context.Background()
+	flowRepo := approvalRepo.NewFlowRepository(db)
+	nodeRepo := approvalRepo.NewNodeRepository(db)
+
+	existing, err := flowRepo.FindByCode(ctx, defaultTenantID, "EXAMPLE_ITEM")
+	if err == nil && existing != nil {
+		return existing, nil
 	}
-	for i := range items {
-		items[i].TenantID = 1
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, err
+	}
+
+	flow := &approvalmodels.ApprovalFlow{
+		Code:         "EXAMPLE_ITEM",
+		Name:         "Example Item Approval",
+		Description:  "Default approval flow for example items.",
+		BusinessType: approvalmodels.BusinessType(exampleservice.ApprovalBusinessType),
+		Priority:     0,
+		Enabled:      true,
+	}
+	flow.TenantID = defaultTenantID
+	_ = flow.Publish(defaultUserID)
+
+	if err := flowRepo.Create(ctx, flow); err != nil {
+		return nil, err
 	}
-	return db.Create(&items).Error
+
+	conditions := approvalmodels.ConditionConfig{
+		Branches: []approvalmodels.ConditionBranch{
+			{
+				Name: "High Amount",
+				Expr: approvalmodels.SingleCondition{
+					Field: "amount",
+					Op:    string(approvalmodels.OpGte),
+					Value: 3000,
+				},
+				Goto: "approve",
+			},
+			{
+				Name: "Finance Category",
+				Expr: approvalmodels.SingleCondition{
+					Field: "category",
+					Op:    string(approvalmodels.OpEq),
+					Value: string(examplemodels.CategoryFinance),
+				},
+				Goto: "approve",
+			},
+		},
+		DefaultGoto: "end",
+	}
+	conditionPayload, err := json.Marshal(conditions)
+	if err != nil {
+		return nil, err
+	}
+
+	nodes := []approvalmodels.ApprovalFlowNode{
+		{
+			FlowID:     flow.ID,
+			NodeID:     "start",
+			NodeType:   approvalmodels.NodeTypeStart,
+			Name:       "Start",
+			NextNodeID: "condition",
+			Enabled:    true,
+		},
+		{
+			FlowID:     flow.ID,
+			NodeID:     "condition",
+			NodeType:   approvalmodels.NodeTypeCondition,
+			Name:       "Condition Gate",
+			Conditions: conditionPayload,
+			Enabled:    true,
+		},
+		{
+			FlowID:              flow.ID,
+			NodeID:              "approve",
+			NodeType:            approvalmodels.NodeTypeApproval,
+			Name:                "Manager Approval",
+			ApproverType:        approvalmodels.ApproverTypeRole,
+			ApproverRole:        "admin",
+			ActionType:          approvalmodels.ActionTypeApprove,
+			RejectRequireReason: true,
+			OnApprove:           "end",
+			OnReject:            "end",
+			Enabled:             true,
+		},
+		{
+			FlowID:   flow.ID,
+			NodeID:   "end",
+			NodeType: approvalmodels.NodeTypeEnd,
+			Name:     "End",
+			Enabled:  true,
+		},
+	}
+	for i := range nodes {
+		nodes[i].TenantID = defaultTenantID
+		if err := nodeRepo.Create(ctx, &nodes[i]); err != nil {
+			return nil, err
+		}
+	}
+	return flow, nil
+}
+
+func seedPendingInstance(db *gorm.DB, flow *approvalmodels.ApprovalFlow, item *examplemodels.ExampleItem) error {
+	if db == nil || flow == nil || item == nil {
+		return nil
+	}
+	userRepo := repository.NewUserRepository(db)
+	permRepo := repository.NewPermissionRepository(db)
+	permSvc := service.NewPermissionService(permRepo, userRepo)
+
+	flowRepo := approvalRepo.NewFlowRepository(db)
+	nodeRepo := approvalRepo.NewNodeRepository(db)
+	instanceRepo := approvalRepo.NewInstanceRepository(db)
+	recordRepo := approvalRepo.NewRecordRepository(db)
+	approvalService := approvalSvc.NewService(db, instanceRepo, flowRepo, nodeRepo, recordRepo, userRepo, permSvc, approvalSvc.DefaultCallbackRegistry)
+
+	contextMap := map[string]interface{}{
+		"number":   item.Number,
+		"title":    item.Title,
+		"amount":   item.Amount,
+		"category": item.Category,
+	}
+	rawContext, _ := json.Marshal(contextMap)
+
+	instance, err := approvalService.CreateInstance(context.Background(), &approvalSvc.CreateInstanceRequest{
+		TenantID:       item.TenantID,
+		BusinessType:   approvalmodels.BusinessType(exampleservice.ApprovalBusinessType),
+		BusinessID:     item.ID,
+		BusinessNumber: item.Number,
+		FlowID:         flow.ID,
+		FlowCode:       flow.Code,
+		Context:        rawContext,
+		SubmitterID:    defaultUserID,
+	})
+	if err != nil {
+		return err
+	}
+
+	item.Status = examplemodels.StatusPending
+	item.ApprovalInstanceID = &instance.ID
+	item.ApprovalStatus = instance.Status
+	item.UpdatedAt = time.Now().UTC()
+	return db.Save(item).Error
 }

package/template/apps/server/internal/modules/example/domain/models/item.go

@@ -1,17 +1,43 @@
 package models
 
-import "github.com/robsuncn/keystone/domain/models"
+import (
+	"gorm.io/datatypes"
+
+	approval "github.com/robsuncn/keystone/domain/approval/models"
+	"github.com/robsuncn/keystone/domain/models"
+)
 
 type ItemStatus string
 
 const (
-	StatusActive   ItemStatus = "active"
-	StatusInactive ItemStatus = "inactive"
+	StatusDraft     ItemStatus = "draft"
+	StatusPending   ItemStatus = "pending"
+	StatusApproved  ItemStatus = "approved"
+	StatusRejected  ItemStatus = "rejected"
+	StatusCancelled ItemStatus = "cancelled"
 )
 
 func (s ItemStatus) IsValid() bool {
 	switch s {
-	case StatusActive, StatusInactive:
+	case StatusDraft, StatusPending, StatusApproved, StatusRejected, StatusCancelled:
+		return true
+	default:
+		return false
+	}
+}
+
+type ItemCategory string
+
+const (
+	CategoryGeneral    ItemCategory = "general"
+	CategoryOperations ItemCategory = "operations"
+	CategoryFinance    ItemCategory = "finance"
+	CategoryGrowth     ItemCategory = "growth"
+)
+
+func (c ItemCategory) IsValid() bool {
+	switch c {
+	case CategoryGeneral, CategoryOperations, CategoryFinance, CategoryGrowth:
 		return true
 	default:
 		return false
@@ -20,9 +46,16 @@ func (s ItemStatus) IsValid() bool {
 
 type ExampleItem struct {
 	models.BaseModel
-	Title       string     `gorm:"size:200;not null" json:"title"`
-	Description string     `gorm:"size:1000" json:"description"`
-	Status      ItemStatus `gorm:"size:20;not null;default:'active'" json:"status"`
+	Number             string                  `gorm:"size:50;not null;uniqueIndex" json:"number"`
+	Title              string                  `gorm:"size:200;not null" json:"title"`
+	Description        string                  `gorm:"size:1000" json:"description"`
+	Category           ItemCategory            `gorm:"size:30;not null;default:'general'" json:"category"`
+	Amount             float64                 `gorm:"type:decimal(18,2);not null;default:0" json:"amount"`
+	Status             ItemStatus              `gorm:"size:20;not null;default:'draft'" json:"status"`
+	ApprovalInstanceID *uint                   `gorm:"index" json:"approval_instance_id,omitempty"`
+	ApprovalStatus     approval.InstanceStatus `gorm:"size:20" json:"approval_status,omitempty"`
+	RejectReason       string                  `gorm:"size:500" json:"reject_reason,omitempty"`
+	Attachment         datatypes.JSON          `gorm:"type:json" json:"attachment,omitempty"`
 }
 
 func (ExampleItem) TableName() string {

package/template/apps/server/internal/modules/example/domain/service/approval_callback.go

@@ -0,0 +1,68 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	approvalmodels "github.com/robsuncn/keystone/domain/approval/models"
+	coremodels "github.com/robsuncn/keystone/domain/models"
+
+	"__APP_NAME__/apps/server/internal/modules/example/domain/models"
+)
+
+type ApprovalCallback struct {
+	repo     ItemRepository
+	notifier NotificationService
+}
+
+func NewApprovalCallback(repo ItemRepository, notifier NotificationService) *ApprovalCallback {
+	return &ApprovalCallback{repo: repo, notifier: notifier}
+}
+
+func (c *ApprovalCallback) OnApproved(ctx context.Context, tenantID, businessID, approverID uint) error {
+	item, err := c.repo.FindByID(tenantID, businessID)
+	if err != nil {
+		return err
+	}
+	item.Status = models.StatusApproved
+	item.ApprovalStatus = approvalmodels.InstanceStatusApproved
+	item.RejectReason = ""
+	if err := c.repo.Update(ctx, item); err != nil {
+		return err
+	}
+	c.notify(ctx, tenantID, item, "approved")
+	return nil
+}
+
+func (c *ApprovalCallback) OnRejected(ctx context.Context, tenantID, businessID, approverID uint, reason string) error {
+	item, err := c.repo.FindByID(tenantID, businessID)
+	if err != nil {
+		return err
+	}
+	item.Status = models.StatusRejected
+	item.ApprovalStatus = approvalmodels.InstanceStatusRejected
+	item.RejectReason = reason
+	if err := c.repo.Update(ctx, item); err != nil {
+		return err
+	}
+	c.notify(ctx, tenantID, item, "rejected")
+	return nil
+}
+
+func (c *ApprovalCallback) notify(ctx context.Context, tenantID uint, item *models.ExampleItem, action string) {
+	if c == nil || c.notifier == nil || item == nil {
+		return
+	}
+	if item.CreatedBy == nil || *item.CreatedBy == 0 {
+		return
+	}
+	notification := &coremodels.Notification{
+		BaseModel: coremodels.BaseModel{TenantID: tenantID},
+		UserID:    *item.CreatedBy,
+		Title:     fmt.Sprintf("Example item %s", action),
+		Content:   fmt.Sprintf("%s (%s)", item.Title, item.Number),
+		Type:      coremodels.NotificationTypeSuccess,
+		Read:      false,
+	}
+	_ = c.notifier.Create(ctx, notification)
+}

package/template/apps/server/internal/modules/example/domain/service/approval_schema.go

@@ -0,0 +1,41 @@
+package service
+
+import (
+	approvalmodels "github.com/robsuncn/keystone/domain/approval/models"
+	approvalsvc "github.com/robsuncn/keystone/domain/approval/service"
+
+	examplemodels "__APP_NAME__/apps/server/internal/modules/example/domain/models"
+)
+
+var exampleCategoryOptions = []approvalmodels.EnumOption{
+	{Label: "通用", Value: string(examplemodels.CategoryGeneral)},
+	{Label: "运营", Value: string(examplemodels.CategoryOperations)},
+	{Label: "财务", Value: string(examplemodels.CategoryFinance)},
+	{Label: "增长", Value: string(examplemodels.CategoryGrowth)},
+}
+
+func init() {
+	if _, exists := approvalsvc.GetSchema(string(ApprovalBusinessType)); exists {
+		return
+	}
+
+	err := approvalsvc.Register(approvalmodels.FormSchema{
+		Code:        string(ApprovalBusinessType),
+		Name:        "示例事项",
+		Description: "示例事项审批条件字段",
+		Fields: []approvalmodels.FieldDef{
+			{Name: "number", Label: "编号", Type: approvalmodels.FieldTypeString},
+			{Name: "title", Label: "标题", Type: approvalmodels.FieldTypeString},
+			{Name: "amount", Label: "金额", Type: approvalmodels.FieldTypeNumber},
+			{
+				Name:    "category",
+				Label:   "类别",
+				Type:    approvalmodels.FieldTypeEnum,
+				Options: exampleCategoryOptions,
+			},
+		},
+	})
+	if err != nil {
+		panic(err)
+	}
+}

package/template/apps/server/internal/modules/example/domain/service/errors.go

@@ -1,22 +1,20 @@
-package service
-
-import "errors"
-
-var (
-	ErrItemNotFound  = errors.New("item not found")
-	ErrTitleRequired = errors.New("title is required")
-	ErrStatusInvalid = errors.New("status is invalid")
-)
-
-// I18n version (uncomment when using keystone with i18n support):
-//
-// import (
-// 	"github.com/robsuncn/keystone/infra/i18n"
-// 	examplei18n "your-app/apps/server/internal/modules/example/i18n"
-// )
-//
-// var (
-// 	ErrItemNotFound  = &i18n.I18nError{Key: examplei18n.MsgItemNotFound}
-// 	ErrTitleRequired = &i18n.I18nError{Key: examplei18n.MsgTitleRequired}
-// 	ErrStatusInvalid = &i18n.I18nError{Key: examplei18n.MsgStatusInvalid}
-// )
+package service
+
+import (
+	"github.com/robsuncn/keystone/infra/i18n"
+
+	examplei18n "__APP_NAME__/apps/server/internal/modules/example/i18n"
+)
+
+var (
+	ErrItemNotFound        = &i18n.I18nError{Key: examplei18n.MsgItemNotFound}
+	ErrTitleRequired       = &i18n.I18nError{Key: examplei18n.MsgTitleRequired}
+	ErrStatusInvalid       = &i18n.I18nError{Key: examplei18n.MsgStatusInvalid}
+	ErrCategoryInvalid     = &i18n.I18nError{Key: examplei18n.MsgCategoryInvalid}
+	ErrAmountInvalid       = &i18n.I18nError{Key: examplei18n.MsgAmountInvalid}
+	ErrItemLocked          = &i18n.I18nError{Key: examplei18n.MsgItemLocked}
+	ErrSubmitterRequired   = &i18n.I18nError{Key: examplei18n.MsgSubmitterRequired}
+	ErrApprovalNotReady    = &i18n.I18nError{Key: examplei18n.MsgApprovalNotReady}
+	ErrApprovalNotPending  = &i18n.I18nError{Key: examplei18n.MsgApprovalNotPending}
+	ErrApprovalInstanceNil = &i18n.I18nError{Key: examplei18n.MsgApprovalInstanceMissing}
+)