break
c64f3d8b80
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 8m31s
172 lines
8.4 KiB
Go
172 lines
8.4 KiB
Go
package asset
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"strconv"
|
|
|
|
infraAudit "github.com/break/junhong_cmp_fiber/internal/infrastructure/audit"
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
assetAuditSvc "github.com/break/junhong_cmp_fiber/internal/service/asset_audit"
|
|
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
|
"github.com/break/junhong_cmp_fiber/pkg/auditcontext"
|
|
"github.com/break/junhong_cmp_fiber/pkg/auditfailure"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var deactivatableAssetStatuses = []int{constants.AssetStatusInStock, constants.AssetStatusSold}
|
|
|
|
// LifecycleService 资产生命周期服务。
|
|
type LifecycleService struct {
|
|
db *gorm.DB
|
|
iotCardStore *postgres.IotCardStore
|
|
deviceStore *postgres.DeviceStore
|
|
auditWriter *infraAudit.Writer
|
|
}
|
|
|
|
// NewLifecycleService 创建资产生命周期服务。
|
|
func NewLifecycleService(db *gorm.DB, iotCardStore *postgres.IotCardStore, deviceStore *postgres.DeviceStore, auditWriter *infraAudit.Writer) *LifecycleService {
|
|
return &LifecycleService{db: db, iotCardStore: iotCardStore, deviceStore: deviceStore, auditWriter: auditWriter}
|
|
}
|
|
|
|
// DeactivateIotCard 手动停用 IoT 卡。
|
|
func (s *LifecycleService) DeactivateIotCard(ctx context.Context, id uint) error {
|
|
card, err := s.iotCardStore.GetByID(ctx, id)
|
|
if err != nil {
|
|
appErr := errors.Wrap(errors.CodeDatabaseError, err, "查询IoT卡失败")
|
|
if stderrors.Is(err, gorm.ErrRecordNotFound) {
|
|
appErr = errors.New(errors.CodeIotCardNotFound)
|
|
}
|
|
result := constants.AuditResultFailed
|
|
if stderrors.Is(err, gorm.ErrRecordNotFound) {
|
|
result = constants.AuditResultDenied
|
|
}
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionIotCardDeactivated, "停用 IoT 卡失败", result, cardResourceStub(id), nil, appErr)
|
|
return appErr
|
|
}
|
|
beforeData := map[string]any{"asset_status": card.AssetStatus}
|
|
if !canDeactivateAsset(card.AssetStatus) {
|
|
appErr := errors.New(errors.CodeForbidden, "当前状态不允许停用")
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionIotCardDeactivated, "停用 IoT 卡被拒绝", constants.AuditResultDenied, card, beforeData, appErr)
|
|
return appErr
|
|
}
|
|
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
result := tx.Model(&model.IotCard{}).Where("id = ? AND asset_status IN ?", id, deactivatableAssetStatuses).Update("asset_status", constants.AssetStatusDeactivated)
|
|
if result.Error != nil {
|
|
return errors.Wrap(errors.CodeDatabaseError, result.Error, "停用IoT卡失败")
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return errors.New(errors.CodeConflict, "状态已变更，请刷新后重试")
|
|
}
|
|
return s.appendCardDeactivationAudit(ctx, tx, card, beforeData, map[string]any{"asset_status": constants.AssetStatusDeactivated}, constants.AuditResultSuccess, nil)
|
|
})
|
|
if err != nil {
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionIotCardDeactivated, "停用 IoT 卡失败", constants.AuditResultFailed, card, beforeData, err)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// DeactivateDevice 手动停用设备。
|
|
func (s *LifecycleService) DeactivateDevice(ctx context.Context, id uint) error {
|
|
device, err := s.deviceStore.GetByID(ctx, id)
|
|
if err != nil {
|
|
appErr := errors.Wrap(errors.CodeDatabaseError, err, "查询设备失败")
|
|
if stderrors.Is(err, gorm.ErrRecordNotFound) {
|
|
appErr = errors.New(errors.CodeNotFound, "设备不存在")
|
|
}
|
|
result := constants.AuditResultFailed
|
|
if stderrors.Is(err, gorm.ErrRecordNotFound) {
|
|
result = constants.AuditResultDenied
|
|
}
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionDeviceDeactivated, "停用设备失败", result, deviceResourceStub(id), nil, appErr)
|
|
return appErr
|
|
}
|
|
beforeData := map[string]any{"asset_status": device.AssetStatus}
|
|
if !canDeactivateAsset(device.AssetStatus) {
|
|
appErr := errors.New(errors.CodeForbidden, "当前状态不允许停用")
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionDeviceDeactivated, "停用设备被拒绝", constants.AuditResultDenied, device, beforeData, appErr)
|
|
return appErr
|
|
}
|
|
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
result := tx.Model(&model.Device{}).Where("id = ? AND asset_status IN ?", id, deactivatableAssetStatuses).Update("asset_status", constants.AssetStatusDeactivated)
|
|
if result.Error != nil {
|
|
return errors.Wrap(errors.CodeDatabaseError, result.Error, "停用设备失败")
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return errors.New(errors.CodeConflict, "状态已变更，请刷新后重试")
|
|
}
|
|
return s.appendDeviceDeactivationAudit(ctx, tx, device, beforeData, map[string]any{"asset_status": constants.AssetStatusDeactivated}, constants.AuditResultSuccess, nil)
|
|
})
|
|
if err != nil {
|
|
s.recordLifecycleFailure(ctx, constants.AuditActionDeviceDeactivated, "停用设备失败", constants.AuditResultFailed, device, beforeData, err)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s *LifecycleService) appendCardDeactivationAudit(ctx context.Context, tx *gorm.DB, card *model.IotCard, beforeData, afterData map[string]any, result string, businessErr error) error {
|
|
if s.auditWriter == nil || card == nil || card.ID == 0 {
|
|
return errors.New(errors.CodeInvalidStatus, "IoT 卡资产统一审计接缝未配置或资源不完整")
|
|
}
|
|
id := strconv.FormatUint(uint64(card.ID), 10)
|
|
errorCode, errorSummary := assetAuditSvc.BuildErrorInfo(businessErr)
|
|
return s.auditWriter.Append(ctx, tx, infraAudit.AppendInput{
|
|
ActionCode: constants.AuditActionIotCardDeactivated, Summary: "停用 IoT 卡资产", Result: result,
|
|
ErrorCode: errorCode, ErrorSummary: errorSummary, ScopeType: constants.AuditScopePlatform,
|
|
Resources: []infraAudit.ResourceInput{{
|
|
Type: constants.AuditResourceIotCard, ID: &id, Key: infraAudit.IotCardResourceKey(card), DisplayName: card.ICCID,
|
|
Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRoleIotCardTarget,
|
|
IdentitySnapshot: infraAudit.IotCardIdentitySnapshot(card), BeforeData: beforeData, AfterData: afterData,
|
|
SubjectVisibility: constants.AuditSubjectResult, SubjectSummary: "IoT 卡资产已停用",
|
|
}},
|
|
})
|
|
}
|
|
|
|
func (s *LifecycleService) appendDeviceDeactivationAudit(ctx context.Context, tx *gorm.DB, device *model.Device, beforeData, afterData map[string]any, result string, businessErr error) error {
|
|
if s.auditWriter == nil || device == nil || device.ID == 0 {
|
|
return errors.New(errors.CodeInvalidStatus, "设备资产统一审计接缝未配置或资源不完整")
|
|
}
|
|
id := strconv.FormatUint(uint64(device.ID), 10)
|
|
errorCode, errorSummary := assetAuditSvc.BuildErrorInfo(businessErr)
|
|
return s.auditWriter.Append(ctx, tx, infraAudit.AppendInput{
|
|
ActionCode: constants.AuditActionDeviceDeactivated, Summary: "停用设备资产", Result: result,
|
|
ErrorCode: errorCode, ErrorSummary: errorSummary, ScopeType: constants.AuditScopePlatform,
|
|
Resources: []infraAudit.ResourceInput{{
|
|
Type: constants.AuditResourceDevice, ID: &id, Key: infraAudit.DeviceResourceKey(device), DisplayName: device.VirtualNo,
|
|
Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRoleDeviceTarget,
|
|
IdentitySnapshot: infraAudit.DeviceIdentitySnapshot(device), BeforeData: beforeData, AfterData: afterData,
|
|
SubjectVisibility: constants.AuditSubjectResult, SubjectSummary: "设备资产已停用",
|
|
}},
|
|
})
|
|
}
|
|
|
|
func (s *LifecycleService) recordLifecycleFailure(ctx context.Context, actionCode, summary, result string, resource any, beforeData map[string]any, businessErr error) {
|
|
if s == nil || s.db == nil || s.auditWriter == nil {
|
|
return
|
|
}
|
|
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
switch value := resource.(type) {
|
|
case *model.IotCard:
|
|
return s.appendCardDeactivationAudit(ctx, tx, value, beforeData, nil, result, businessErr)
|
|
case *model.Device:
|
|
return s.appendDeviceDeactivationAudit(ctx, tx, value, beforeData, nil, result, businessErr)
|
|
default:
|
|
return errors.New(errors.CodeInvalidStatus, "资产审计资源类型无效")
|
|
}
|
|
})
|
|
if err == nil {
|
|
return
|
|
}
|
|
linkage := auditcontext.From(ctx)
|
|
errorCode, _ := assetAuditSvc.BuildErrorInfo(businessErr)
|
|
auditfailure.RecordSecondaryWriteFailure(actionCode, summary, linkage.RequestID, linkage.CorrelationID, errorCode, err)
|
|
}
|
|
|
|
func cardResourceStub(id uint) *model.IotCard { return &model.IotCard{Model: gorm.Model{ID: id}} }
|
|
func deviceResourceStub(id uint) *model.Device { return &model.Device{Model: gorm.Model{ID: id}} }
|
|
|
|
func canDeactivateAsset(assetStatus int) bool {
|
|
return assetStatus == constants.AssetStatusInStock || assetStatus == constants.AssetStatusSold
|
|
}
|