platforms/backend/api/internal/logic/platform/delivery/delivery.go

// 功能描述：提供平台配送点资源管理与受控候选筛选。
// 版本：v1.1.0
package delivery

import (
	"strconv"
	"strings"

	"git.apinb.com/bsm-sdk/core/errcode"
	"git.apinb.com/bsm-sdk/core/infra"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/impl"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/common"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
	"github.com/gin-gonic/gin"
)

// parseDeliveryStatusFilter 解析可选的配送点通用状态筛选，拒绝归档和未知状态。
func parseDeliveryStatusFilter(value string) (*int, bool) {
	value = strings.TrimSpace(value)
	if value == "" {
		return nil, true
	}
	status, err := strconv.Atoi(value)
	if err != nil || !common.IsGenericRecordStatus(status) || status == common.StatusArchived {
		return nil, false
	}
	return &status, true
}

// ListDeliveryBasic 查询配送点分页列表。
func ListDeliveryBasic(ctx *gin.Context) {
	page, size := common.PageSize(ctx)
	gasIdentities := strings.Split(strings.TrimSpace(ctx.Query("gas_basic_identities")), ",")
	if len(gasIdentities) == 1 && gasIdentities[0] == "" {
		gasIdentities = nil
	}
	if len(gasIdentities) > 100 {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	status, ok := parseDeliveryStatusFilter(ctx.Query("status"))
	if !ok {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	var list []models.DeliveryBasic
	var total int64
	query := common.ApplyKeywordFilter(ctx, common.ActiveRecords(impl.DBService.Model(&models.DeliveryBasic{})), &models.DeliveryBasic{})
	if len(gasIdentities) > 0 {
		query = query.Where(
			"gas_basic_id IN (SELECT id FROM gas_basic WHERE identity IN ? AND status <> ?)",
			gasIdentities,
			common.StatusArchived,
		)
	}
	if status != nil {
		query = query.Where("delivery_basic.status = ?", *status)
	}
	if err := query.Count(&total).Error; err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	if err := query.Order("created_at desc").Offset((page - 1) * size).Limit(size).Find(&list).Error; err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	response, err := common.PublicResourceResponse(list)
	if err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	// 配送点地址属于平台组织主数据；仅在本资源的受保护接口中按记录恢复，避免放宽全局敏感字段规则。
	protected := common.ProtectPreciseLocation(ctx, &models.DeliveryBasic{}, response)
	infra.Response.Success(ctx, gin.H{"total": total, "list": restoreDeliveryBasicAddresses(protected, list)})
}

// GetDeliveryBasic 查询一个配送点，并返回编辑表单需要的组织地址。
func GetDeliveryBasic(ctx *gin.Context) {
	var delivery models.DeliveryBasic
	if err := common.ActiveRecords(impl.DBService).Where("identity = ?", ctx.Param("identity")).First(&delivery).Error; err != nil {
		common.RespondRecordError(ctx, err)
		return
	}
	response, err := common.PublicResourceResponse(delivery)
	if err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	protected := common.ProtectPreciseLocation(ctx, &models.DeliveryBasic{}, response)
	infra.Response.Success(ctx, restoreDeliveryBasicAddresses(protected, []models.DeliveryBasic{delivery}))
}

// restoreDeliveryBasicAddresses 将已鉴权配送点记录的地址恢复到安全响应中。
func restoreDeliveryBasicAddresses(response any, deliveries []models.DeliveryBasic) any {
	switch data := response.(type) {
	case []any:
		for index, item := range data {
			if index >= len(deliveries) {
				break
			}
			if record, ok := item.(map[string]any); ok {
				record["address"] = deliveries[index].Address
			}
		}
	case map[string]any:
		if len(deliveries) > 0 {
			data["address"] = deliveries[0].Address
		}
	}
	return response
}

// CreateDeliveryBasic 创建配送点档案。
func CreateDeliveryBasic(ctx *gin.Context) {
	var request struct {
		DeliveryCode     string `json:"delivery_code"`
		GasBasicIdentity string `json:"gas_basic_identity"`
		Name             string `json:"name"`
		Principal        string `json:"principal"`
		Address          string `json:"address"`
	}
	if err := ctx.ShouldBindJSON(&request); err != nil || request.DeliveryCode == "" || request.Name == "" {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	gasBasicID, err := common.ResolveIdentityID(&models.GasBasic{}, request.GasBasicIdentity, false)
	if err != nil {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	delivery := models.DeliveryBasic{Entity: common.NewEntity(common.StatusDraft), DeliveryCode: request.DeliveryCode, GasBasicID: gasBasicID, Name: request.Name, Principal: request.Principal, Address: request.Address}
	if err := impl.DBService.Create(&delivery).Error; err != nil {
		infra.Response.Error(ctx, common.DeliveryCreateError(err))
		return
	}
	common.RespondCreatedResource(ctx, delivery)
}

// UpdateDeliveryBasic 更新配送点基础资料。
func UpdateDeliveryBasic(ctx *gin.Context) {
	var request struct {
		GasBasicIdentity string `json:"gas_basic_identity"`
		Name             string `json:"name" binding:"required,max=128"`
		Principal        string `json:"principal" binding:"max=64"`
		Address          string `json:"address" binding:"max=255"`
	}
	if err := ctx.ShouldBindJSON(&request); err != nil {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	gasBasicID, err := common.ResolveIdentityID(&models.GasBasic{}, request.GasBasicIdentity, false)
	if err != nil {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	common.UpdateAllowedByIdentity(ctx, &models.DeliveryBasic{}, gin.H{"gas_basic_id": gasBasicID, "name": request.Name, "principal": request.Principal, "address": request.Address}, []string{"gas_basic_id", "name", "principal", "address"})
}