@robsun/create-keystone-app 0.2.15 → 0.4.0

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

@@ -2,41 +2,99 @@ package service
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/datatypes"
+
+	approvalmodels "github.com/robsuncn/keystone/domain/approval/models"
+	approvalsvc "github.com/robsuncn/keystone/domain/approval/service"
+	coremodels "github.com/robsuncn/keystone/domain/models"
+	coreservice "github.com/robsuncn/keystone/domain/service"
 
 	"__APP_NAME__/apps/server/internal/modules/example/domain/models"
 )
 
+const ApprovalBusinessType approvalmodels.BusinessType = "example_item"
+
 type ItemRepository interface {
-	List(ctx context.Context, tenantID uint) ([]models.ExampleItem, error)
+	List(ctx context.Context, tenantID uint, filter ItemListFilter) ([]models.ExampleItem, int64, error)
 	FindByID(tenantID, id uint) (*models.ExampleItem, error)
 	Create(ctx context.Context, item *models.ExampleItem) error
 	Update(ctx context.Context, item *models.ExampleItem) error
 	Delete(ctx context.Context, item *models.ExampleItem) error
 }
 
+type ApprovalService interface {
+	CreateInstance(ctx context.Context, req *approvalsvc.CreateInstanceRequest) (*approvalmodels.ApprovalInstance, error)
+	Cancel(ctx context.Context, tenantID, instanceID, actorID uint, req approvalsvc.CancelRequest) (*approvalmodels.ApprovalInstance, error)
+}
+
+type NotificationService interface {
+	Create(ctx context.Context, notification *coremodels.Notification) error
+}
+
 type ItemService struct {
-	items ItemRepository
+	items       ItemRepository
+	approvals   ApprovalService
+	flowMatcher approvalsvc.FlowMatcherInterface
+	notifier    NotificationService
+	clock       func() time.Time
+}
+
+type ItemListFilter struct {
+	Page           int
+	PageSize       int
+	Keyword        string
+	Status         *models.ItemStatus
+	ApprovalStatus *approvalmodels.InstanceStatus
+	Category       *models.ItemCategory
+	StartDate      *time.Time
+	EndDate        *time.Time
 }
 
 type ItemInput struct {
 	Title       string
 	Description string
+	Category    models.ItemCategory
+	Amount      float64
 	Status      models.ItemStatus
+	Attachment  datatypes.JSON
 }
 
 type ItemUpdateInput struct {
 	Title       *string
 	Description *string
+	Category    *models.ItemCategory
+	Amount      *float64
 	Status      *models.ItemStatus
+	Attachment  *datatypes.JSON
+}
+
+func NewItemService(
+	items ItemRepository,
+	approvals ApprovalService,
+	flowMatcher approvalsvc.FlowMatcherInterface,
+	notifier NotificationService,
+) *ItemService {
+	return &ItemService{
+		items:       items,
+		approvals:   approvals,
+		flowMatcher: flowMatcher,
+		notifier:    notifier,
+		clock:       time.Now,
+	}
 }
 
-func NewItemService(items ItemRepository) *ItemService {
-	return &ItemService{items: items}
+func (s *ItemService) List(ctx context.Context, tenantID uint, filter ItemListFilter) ([]models.ExampleItem, int64, error) {
+	return s.items.List(ctx, tenantID, filter)
 }
 
-func (s *ItemService) List(ctx context.Context, tenantID uint) ([]models.ExampleItem, error) {
-	return s.items.List(ctx, tenantID)
+func (s *ItemService) Get(ctx context.Context, tenantID, id uint) (*models.ExampleItem, error) {
+	return s.items.FindByID(tenantID, id)
 }
 
 func (s *ItemService) Create(ctx context.Context, tenantID uint, input ItemInput) (*models.ExampleItem, error) {
@@ -45,24 +103,41 @@ func (s *ItemService) Create(ctx context.Context, tenantID uint, input ItemInput
 		return nil, ErrTitleRequired
 	}
 
+	category := input.Category
+	if category == "" {
+		category = models.CategoryGeneral
+	}
+	if !category.IsValid() {
+		return nil, ErrCategoryInvalid
+	}
+
 	status := input.Status
 	if status == "" {
-		status = models.StatusActive
+		status = models.StatusDraft
 	}
 	if !status.IsValid() {
 		return nil, ErrStatusInvalid
 	}
 
+	if input.Amount < 0 {
+		return nil, ErrAmountInvalid
+	}
+
 	item := &models.ExampleItem{
+		Number:      s.buildNumber(),
 		Title:       title,
 		Description: strings.TrimSpace(input.Description),
+		Category:    category,
+		Amount:      input.Amount,
 		Status:      status,
+		Attachment:  input.Attachment,
 	}
 	item.TenantID = tenantID
 
 	if err := s.items.Create(ctx, item); err != nil {
 		return nil, err
 	}
+	s.notify(ctx, tenantID, item, "created", coremodels.NotificationTypeSuccess)
 	return item, nil
 }
 
@@ -75,6 +150,9 @@ func (s *ItemService) Update(
 	if err != nil {
 		return nil, err
 	}
+	if !isEditableStatus(item.Status) {
+		return nil, ErrItemLocked
+	}
 
 	if input.Title != nil {
 		title := strings.TrimSpace(*input.Title)
@@ -88,6 +166,20 @@ func (s *ItemService) Update(
 		item.Description = strings.TrimSpace(*input.Description)
 	}
 
+	if input.Category != nil {
+		if !input.Category.IsValid() {
+			return nil, ErrCategoryInvalid
+		}
+		item.Category = *input.Category
+	}
+
+	if input.Amount != nil {
+		if *input.Amount < 0 {
+			return nil, ErrAmountInvalid
+		}
+		item.Amount = *input.Amount
+	}
+
 	if input.Status != nil {
 		if !input.Status.IsValid() {
 			return nil, ErrStatusInvalid
@@ -95,9 +187,14 @@ func (s *ItemService) Update(
 		item.Status = *input.Status
 	}
 
+	if input.Attachment != nil {
+		item.Attachment = normalizeAttachment(*input.Attachment)
+	}
+
 	if err := s.items.Update(ctx, item); err != nil {
 		return nil, err
 	}
+	s.notify(ctx, tenantID, item, "updated", coremodels.NotificationTypeInfo)
 	return item, nil
 }
 
@@ -106,5 +203,168 @@ func (s *ItemService) Delete(ctx context.Context, tenantID, id uint) error {
 	if err != nil {
 		return err
 	}
+	if item.Status == models.StatusPending {
+		return ErrItemLocked
+	}
 	return s.items.Delete(ctx, item)
 }
+
+func (s *ItemService) Submit(ctx context.Context, tenantID, id uint) (*models.ExampleItem, error) {
+	item, err := s.items.FindByID(tenantID, id)
+	if err != nil {
+		return nil, err
+	}
+	if !isSubmittableStatus(item.Status) {
+		return nil, ErrApprovalNotReady
+	}
+	actor, ok := coreservice.ActorFromContext(ctx)
+	if !ok || actor.UserID == 0 {
+		return nil, ErrSubmitterRequired
+	}
+	if s.approvals == nil || s.flowMatcher == nil {
+		return nil, ErrApprovalNotReady
+	}
+
+	contextMap := map[string]interface{}{
+		"number":   item.Number,
+		"title":    item.Title,
+		"amount":   item.Amount,
+		"category": item.Category,
+	}
+	rawContext, _ := json.Marshal(contextMap)
+
+	match, err := s.flowMatcher.Match(ctx, tenantID, ApprovalBusinessType, contextMap)
+	if err != nil {
+		return nil, err
+	}
+	if match.Blocked {
+		return nil, ErrApprovalNotReady
+	}
+	if !match.RequiresApproval || match.Flow == nil {
+		item.Status = models.StatusApproved
+		item.ApprovalStatus = approvalmodels.InstanceStatusApproved
+		item.ApprovalInstanceID = nil
+		item.RejectReason = ""
+		if err := s.items.Update(ctx, item); err != nil {
+			return nil, err
+		}
+		s.notify(ctx, tenantID, item, "auto-approved", coremodels.NotificationTypeSuccess)
+		return item, nil
+	}
+
+	instance, err := s.approvals.CreateInstance(ctx, &approvalsvc.CreateInstanceRequest{
+		TenantID:       tenantID,
+		BusinessType:   ApprovalBusinessType,
+		BusinessID:     item.ID,
+		BusinessNumber: item.Number,
+		FlowID:         match.Flow.ID,
+		FlowCode:       match.Flow.Code,
+		Context:        rawContext,
+		TriggerReason:  match.TriggerReason,
+		BlockReason:    match.BlockReason,
+		SubmitterID:    actor.UserID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	item.ApprovalInstanceID = &instance.ID
+	item.ApprovalStatus = instance.Status
+	item.RejectReason = ""
+	if instance.Status == approvalmodels.InstanceStatusApproved {
+		item.Status = models.StatusApproved
+	} else {
+		item.Status = models.StatusPending
+	}
+	if err := s.items.Update(ctx, item); err != nil {
+		return nil, err
+	}
+	s.notify(ctx, tenantID, item, "submitted", coremodels.NotificationTypeInfo)
+	return item, nil
+}
+
+func (s *ItemService) Cancel(ctx context.Context, tenantID, id uint, reason string) (*models.ExampleItem, error) {
+	item, err := s.items.FindByID(tenantID, id)
+	if err != nil {
+		return nil, err
+	}
+	if item.Status != models.StatusPending {
+		return nil, ErrApprovalNotPending
+	}
+	if item.ApprovalInstanceID == nil {
+		return nil, ErrApprovalInstanceNil
+	}
+	actor, ok := coreservice.ActorFromContext(ctx)
+	if !ok || actor.UserID == 0 {
+		return nil, ErrSubmitterRequired
+	}
+	if s.approvals == nil {
+		return nil, ErrApprovalNotReady
+	}
+
+	instance, err := s.approvals.Cancel(ctx, tenantID, *item.ApprovalInstanceID, actor.UserID, approvalsvc.CancelRequest{
+		Reason: reason,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	item.Status = models.StatusCancelled
+	item.ApprovalStatus = instance.Status
+	item.RejectReason = strings.TrimSpace(reason)
+	if err := s.items.Update(ctx, item); err != nil {
+		return nil, err
+	}
+	s.notify(ctx, tenantID, item, "cancelled", coremodels.NotificationTypeInfo)
+	return item, nil
+}
+
+func (s *ItemService) buildNumber() string {
+	now := s.clock()
+	return fmt.Sprintf("EX-%s-%s", now.Format("20060102"), strings.ToUpper(uuid.NewString()[:8]))
+}
+
+func (s *ItemService) notify(
+	ctx context.Context,
+	tenantID uint,
+	item *models.ExampleItem,
+	action string,
+	noticeType coremodels.NotificationType,
+) {
+	if s == nil || s.notifier == nil || item == nil {
+		return
+	}
+	actor, ok := coreservice.ActorFromContext(ctx)
+	if !ok || actor.UserID == 0 {
+		return
+	}
+	title := fmt.Sprintf("Example item %s", action)
+	content := fmt.Sprintf("%s (%s)", item.Title, item.Number)
+	notification := &coremodels.Notification{
+		BaseModel: coremodels.BaseModel{TenantID: tenantID},
+		UserID:    actor.UserID,
+		Title:     title,
+		Content:   content,
+		Type:      noticeType,
+		Read:      false,
+	}
+	_ = s.notifier.Create(ctx, notification)
+}
+
+func isEditableStatus(status models.ItemStatus) bool {
+	return status == models.StatusDraft || status == models.StatusRejected || status == models.StatusCancelled
+}
+
+func isSubmittableStatus(status models.ItemStatus) bool {
+	return status == models.StatusDraft || status == models.StatusRejected || status == models.StatusCancelled
+}
+
+func normalizeAttachment(raw datatypes.JSON) datatypes.JSON {
+	if len(raw) == 0 {
+		return nil
+	}
+	if string(raw) == "null" {
+		return nil
+	}
+	return raw
+}

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

@@ -0,0 +1,281 @@
+package service
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	approvalmodels "github.com/robsuncn/keystone/domain/approval/models"
+	approvalsvc "github.com/robsuncn/keystone/domain/approval/service"
+	coremodels "github.com/robsuncn/keystone/domain/models"
+	coreservice "github.com/robsuncn/keystone/domain/service"
+	"gorm.io/datatypes"
+
+	"__APP_NAME__/apps/server/internal/modules/example/domain/models"
+)
+
+type itemRepoStub struct {
+	items  map[uint]*models.ExampleItem
+	nextID uint
+}
+
+func newItemRepoStub() *itemRepoStub {
+	return &itemRepoStub{
+		items:  make(map[uint]*models.ExampleItem),
+		nextID: 1,
+	}
+}
+
+func (r *itemRepoStub) List(_ context.Context, _ uint, _ ItemListFilter) ([]models.ExampleItem, int64, error) {
+	items := make([]models.ExampleItem, 0, len(r.items))
+	for _, item := range r.items {
+		items = append(items, *item)
+	}
+	return items, int64(len(items)), nil
+}
+
+func (r *itemRepoStub) FindByID(tenantID, id uint) (*models.ExampleItem, error) {
+	item, ok := r.items[id]
+	if !ok || item.TenantID != tenantID {
+		return nil, ErrItemNotFound
+	}
+	return item, nil
+}
+
+func (r *itemRepoStub) Create(_ context.Context, item *models.ExampleItem) error {
+	if item.ID == 0 {
+		item.ID = r.nextID
+		r.nextID++
+	}
+	r.items[item.ID] = item
+	return nil
+}
+
+func (r *itemRepoStub) Update(_ context.Context, item *models.ExampleItem) error {
+	if _, ok := r.items[item.ID]; !ok {
+		return ErrItemNotFound
+	}
+	r.items[item.ID] = item
+	return nil
+}
+
+func (r *itemRepoStub) Delete(_ context.Context, item *models.ExampleItem) error {
+	delete(r.items, item.ID)
+	return nil
+}
+
+type approvalServiceStub struct {
+	createCalled bool
+	cancelCalled bool
+	createReq    *approvalsvc.CreateInstanceRequest
+	cancelReq    *approvalsvc.CancelRequest
+	createFn     func(context.Context, *approvalsvc.CreateInstanceRequest) (*approvalmodels.ApprovalInstance, error)
+	cancelFn     func(context.Context, uint, uint, uint, approvalsvc.CancelRequest) (*approvalmodels.ApprovalInstance, error)
+}
+
+func (s *approvalServiceStub) CreateInstance(ctx context.Context, req *approvalsvc.CreateInstanceRequest) (*approvalmodels.ApprovalInstance, error) {
+	s.createCalled = true
+	s.createReq = req
+	if s.createFn != nil {
+		return s.createFn(ctx, req)
+	}
+	return &approvalmodels.ApprovalInstance{
+		BaseModel: coremodels.BaseModel{ID: 100},
+		Status:    approvalmodels.InstanceStatusPending,
+	}, nil
+}
+
+func (s *approvalServiceStub) Cancel(ctx context.Context, tenantID, instanceID, actorID uint, req approvalsvc.CancelRequest) (*approvalmodels.ApprovalInstance, error) {
+	s.cancelCalled = true
+	s.cancelReq = &req
+	if s.cancelFn != nil {
+		return s.cancelFn(ctx, tenantID, instanceID, actorID, req)
+	}
+	return &approvalmodels.ApprovalInstance{
+		BaseModel: coremodels.BaseModel{ID: instanceID},
+		Status:    approvalmodels.InstanceStatusCancelled,
+	}, nil
+}
+
+type flowMatcherStub struct {
+	match *approvalsvc.MatchResult
+	err   error
+}
+
+func (f *flowMatcherStub) Match(_ context.Context, _ uint, _ approvalmodels.BusinessType, _ map[string]interface{}) (*approvalsvc.MatchResult, error) {
+	return f.match, f.err
+}
+
+func (f *flowMatcherStub) DefaultFlow(_ context.Context, _ uint, _ approvalmodels.BusinessType) (*approvalmodels.ApprovalFlow, error) {
+	return nil, nil
+}
+
+type notificationStub struct {
+	created []*coremodels.Notification
+}
+
+func (n *notificationStub) Create(_ context.Context, notification *coremodels.Notification) error {
+	n.created = append(n.created, notification)
+	return nil
+}
+
+func TestItemService_Create_Defaults(t *testing.T) {
+	repo := newItemRepoStub()
+	svc := NewItemService(repo, nil, nil, &notificationStub{})
+	svc.clock = func() time.Time {
+		return time.Date(2024, time.January, 2, 12, 0, 0, 0, time.UTC)
+	}
+
+	item, err := svc.Create(context.Background(), 1, ItemInput{
+		Title:       "  Demo ",
+		Description: " Example ",
+		Amount:      42,
+		Attachment:  datatypes.JSON(`{"name":"demo.txt"}`),
+	})
+	if err != nil {
+		t.Fatalf("create failed: %v", err)
+	}
+	if item.Status != models.StatusDraft {
+		t.Fatalf("expected status draft, got %s", item.Status)
+	}
+	if item.Category != models.CategoryGeneral {
+		t.Fatalf("expected category general, got %s", item.Category)
+	}
+	if item.TenantID != 1 {
+		t.Fatalf("expected tenant 1, got %d", item.TenantID)
+	}
+	if !strings.HasPrefix(item.Number, "EX-20240102-") {
+		t.Fatalf("unexpected number format: %s", item.Number)
+	}
+}
+
+func TestItemService_Submit_WithApproval(t *testing.T) {
+	repo := newItemRepoStub()
+	item := &models.ExampleItem{
+		BaseModel: coremodels.BaseModel{ID: 1, TenantID: 1},
+		Number:    "EX-0001",
+		Title:     "Approval Item",
+		Category:  models.CategoryFinance,
+		Status:    models.StatusDraft,
+	}
+	repo.items[item.ID] = item
+
+	approvals := &approvalServiceStub{
+		createFn: func(_ context.Context, req *approvalsvc.CreateInstanceRequest) (*approvalmodels.ApprovalInstance, error) {
+			if req.BusinessID != item.ID {
+				t.Fatalf("unexpected business id: %d", req.BusinessID)
+			}
+			return &approvalmodels.ApprovalInstance{
+				BaseModel: coremodels.BaseModel{ID: 77},
+				Status:    approvalmodels.InstanceStatusPending,
+			}, nil
+		},
+	}
+	matcher := &flowMatcherStub{
+		match: &approvalsvc.MatchResult{
+			RequiresApproval: true,
+			Flow: &approvalmodels.ApprovalFlow{
+				BaseModel: coremodels.BaseModel{ID: 10},
+				Code:      "EXAMPLE_ITEM",
+			},
+		},
+	}
+
+	svc := NewItemService(repo, approvals, matcher, &notificationStub{})
+	ctx := coreservice.WithActor(context.Background(), coreservice.ActorSnapshot{UserID: 9})
+
+	updated, err := svc.Submit(ctx, 1, item.ID)
+	if err != nil {
+		t.Fatalf("submit failed: %v", err)
+	}
+	if updated.Status != models.StatusPending {
+		t.Fatalf("expected pending status, got %s", updated.Status)
+	}
+	if updated.ApprovalInstanceID == nil || *updated.ApprovalInstanceID != 77 {
+		t.Fatalf("expected approval instance 77, got %v", updated.ApprovalInstanceID)
+	}
+	if updated.ApprovalStatus != approvalmodels.InstanceStatusPending {
+		t.Fatalf("expected approval status pending, got %s", updated.ApprovalStatus)
+	}
+}
+
+func TestItemService_Submit_AutoApprove(t *testing.T) {
+	repo := newItemRepoStub()
+	item := &models.ExampleItem{
+		BaseModel: coremodels.BaseModel{ID: 2, TenantID: 1},
+		Number:    "EX-0002",
+		Title:     "Auto Approval",
+		Category:  models.CategoryGeneral,
+		Status:    models.StatusDraft,
+	}
+	repo.items[item.ID] = item
+
+	approvals := &approvalServiceStub{}
+	matcher := &flowMatcherStub{
+		match: &approvalsvc.MatchResult{RequiresApproval: false},
+	}
+
+	svc := NewItemService(repo, approvals, matcher, &notificationStub{})
+	ctx := coreservice.WithActor(context.Background(), coreservice.ActorSnapshot{UserID: 5})
+
+	updated, err := svc.Submit(ctx, 1, item.ID)
+	if err != nil {
+		t.Fatalf("submit failed: %v", err)
+	}
+	if updated.Status != models.StatusApproved {
+		t.Fatalf("expected approved status, got %s", updated.Status)
+	}
+	if updated.ApprovalStatus != approvalmodels.InstanceStatusApproved {
+		t.Fatalf("expected approval status approved, got %s", updated.ApprovalStatus)
+	}
+	if approvals.createCalled {
+		t.Fatalf("expected no approval instance creation")
+	}
+}
+
+func TestItemService_Cancel(t *testing.T) {
+	repo := newItemRepoStub()
+	instanceID := uint(55)
+	item := &models.ExampleItem{
+		BaseModel:          coremodels.BaseModel{ID: 3, TenantID: 1},
+		Number:             "EX-0003",
+		Title:              "Cancel Item",
+		Category:           models.CategoryOperations,
+		Status:             models.StatusPending,
+		ApprovalInstanceID: &instanceID,
+		ApprovalStatus:     approvalmodels.InstanceStatusPending,
+		RejectReason:       "",
+		Attachment:         datatypes.JSON(`{"name":"proof.pdf"}`),
+	}
+	repo.items[item.ID] = item
+
+	approvals := &approvalServiceStub{
+		cancelFn: func(_ context.Context, tenantID, instanceID, actorID uint, req approvalsvc.CancelRequest) (*approvalmodels.ApprovalInstance, error) {
+			if req.Reason != "need change" {
+				t.Fatalf("unexpected cancel reason: %s", req.Reason)
+			}
+			return &approvalmodels.ApprovalInstance{
+				BaseModel: coremodels.BaseModel{ID: instanceID},
+				Status:    approvalmodels.InstanceStatusCancelled,
+			}, nil
+		},
+	}
+
+	svc := NewItemService(repo, approvals, nil, &notificationStub{})
+	ctx := coreservice.WithActor(context.Background(), coreservice.ActorSnapshot{UserID: 5})
+
+	updated, err := svc.Cancel(ctx, 1, item.ID, "need change")
+	if err != nil {
+		t.Fatalf("cancel failed: %v", err)
+	}
+	if updated.Status != models.StatusCancelled {
+		t.Fatalf("expected cancelled status, got %s", updated.Status)
+	}
+	if updated.ApprovalStatus != approvalmodels.InstanceStatusCancelled {
+		t.Fatalf("expected approval status cancelled, got %s", updated.ApprovalStatus)
+	}
+	if updated.RejectReason != "need change" {
+		t.Fatalf("expected reject reason to be set")
+	}
+}

package/template/apps/server/internal/modules/example/i18n/keys.go

@@ -1,23 +1,35 @@
 package examplei18n
 
 // Example module i18n message keys
-const (
-	// Item messages
-	MsgItemCreated      = "example.item.created"
-	MsgItemUpdated      = "example.item.updated"
-	MsgItemDeleted      = "example.item.deleted"
-	MsgItemNotFound     = "example.item.notFound"
-	MsgItemLoadFailed   = "example.item.loadFailed"
-	MsgItemCreateFailed = "example.item.createFailed"
-	MsgItemUpdateFailed = "example.item.updateFailed"
-	MsgItemDeleteFailed = "example.item.deleteFailed"
-
-	// Validation messages
-	MsgTitleRequired = "example.validation.titleRequired"
-	MsgStatusInvalid = "example.validation.statusInvalid"
-	MsgInvalidID     = "example.validation.invalidId"
-	MsgInvalidPayload = "example.validation.invalidPayload"
-
-	// Service messages
-	MsgServiceUnavailable = "example.service.unavailable"
-)
+const (
+	// Item messages
+	MsgItemCreated      = "example.item.created"
+	MsgItemUpdated      = "example.item.updated"
+	MsgItemDeleted      = "example.item.deleted"
+	MsgItemSubmitted    = "example.item.submitted"
+	MsgItemCancelled    = "example.item.cancelled"
+	MsgItemNotFound     = "example.item.notFound"
+	MsgItemLoadFailed   = "example.item.loadFailed"
+	MsgItemCreateFailed = "example.item.createFailed"
+	MsgItemUpdateFailed = "example.item.updateFailed"
+	MsgItemDeleteFailed = "example.item.deleteFailed"
+	MsgItemSubmitFailed = "example.item.submitFailed"
+	MsgItemCancelFailed = "example.item.cancelFailed"
+	MsgItemExportFailed = "example.item.exportFailed"
+
+	// Validation messages
+	MsgTitleRequired          = "example.validation.titleRequired"
+	MsgStatusInvalid          = "example.validation.statusInvalid"
+	MsgCategoryInvalid        = "example.validation.categoryInvalid"
+	MsgAmountInvalid          = "example.validation.amountInvalid"
+	MsgItemLocked             = "example.validation.itemLocked"
+	MsgSubmitterRequired      = "example.validation.submitterRequired"
+	MsgApprovalNotReady       = "example.validation.approvalNotReady"
+	MsgApprovalNotPending     = "example.validation.approvalNotPending"
+	MsgApprovalInstanceMissing = "example.validation.approvalInstanceMissing"
+	MsgInvalidID              = "example.validation.invalidId"
+	MsgInvalidPayload         = "example.validation.invalidPayload"
+
+	// Service messages
+	MsgServiceUnavailable = "example.service.unavailable"
+)