MiFaZhan
122 lines
3.4 KiB
Go
122 lines
3.4 KiB
Go
package common
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchimport"
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/rabbitmq"
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/xgorm/handler"
|
|
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
)
|
|
|
|
type AuthorizedRow interface {
|
|
GetIccid() string
|
|
SetAuthorized(bool)
|
|
}
|
|
|
|
type SubmitOptions struct {
|
|
Remark string
|
|
}
|
|
|
|
type BatchExecuteMessage struct {
|
|
BatchNo string `json:"batchNo"`
|
|
BatchType int `json:"batchType"`
|
|
}
|
|
|
|
type SubmitResult struct {
|
|
BatchNo string
|
|
BatchType int
|
|
BatchAsyncStatus int
|
|
Total int
|
|
}
|
|
|
|
func PrepareAuthorizedRows[T AuthorizedRow](
|
|
ctx context.Context,
|
|
rows []batchimport.Row,
|
|
rowFactory func(batchimport.Row) (T, error),
|
|
typeErrorMsg string,
|
|
) error {
|
|
cardRows := make([]T, 0, len(rows))
|
|
iccids := make([]string, 0, len(rows))
|
|
for _, item := range rows {
|
|
row, err := rowFactory(item)
|
|
if err != nil {
|
|
return gerror.New(typeErrorMsg)
|
|
}
|
|
cardRows = append(cardRows, row)
|
|
if id := row.GetIccid(); id != "" {
|
|
iccids = append(iccids, id)
|
|
}
|
|
}
|
|
if len(iccids) == 0 {
|
|
return nil
|
|
}
|
|
|
|
var visible []struct {
|
|
Iccid string `orm:"iccid"`
|
|
}
|
|
columns := dao.TSimCardInfo.Columns()
|
|
err := handler.Model(dao.TSimCardInfo.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
|
|
Fields(columns.Iccid, columns.TenantId, columns.DeptId, columns.CreatedDept, columns.CreatedBy).
|
|
WhereIn(columns.Iccid, iccids).
|
|
Scan(&visible)
|
|
if err != nil {
|
|
return gerror.Wrap(err, "计算SIM卡数据权限失败")
|
|
}
|
|
|
|
authorized := make(map[string]struct{}, len(visible))
|
|
for _, card := range visible {
|
|
authorized[strings.TrimSpace(card.Iccid)] = struct{}{}
|
|
}
|
|
for _, row := range cardRows {
|
|
_, ok := authorized[row.GetIccid()]
|
|
row.SetAuthorized(ok)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func PublishBatchMessage(ctx context.Context, result *batchimport.Result, queueName, logPrefix string) {
|
|
_ = PublishBatchMessageStrict(ctx, result, queueName, logPrefix)
|
|
}
|
|
|
|
func PublishBatchMessageStrict(ctx context.Context, result *batchimport.Result, queueName, logPrefix string) error {
|
|
if result == nil || strings.TrimSpace(result.BatchNo) == "" {
|
|
return nil
|
|
}
|
|
if err := rabbitmq.Publish(ctx, queueName, BatchExecuteMessage{
|
|
BatchNo: result.BatchNo,
|
|
BatchType: result.BatchType,
|
|
}); err != nil {
|
|
g.Log().Errorf(ctx, "%s batch async publish failed, batchNo=%s, batchType=%d, tenantId=%s, error=%+v",
|
|
logPrefix, result.BatchNo, result.BatchType, contexts.GetTenantId(ctx), err)
|
|
return gerror.Wrap(err, "publish batch async message")
|
|
}
|
|
g.Log().Infof(ctx, "%s batch async published, queue=%s, batchNo=%s, batchType=%d, tenantId=%s",
|
|
logPrefix, queueName, result.BatchNo, result.BatchType, contexts.GetTenantId(ctx))
|
|
return nil
|
|
}
|
|
|
|
func CurrentOperator(ctx context.Context) batchimport.OperatorContext {
|
|
return batchimport.OperatorContext{
|
|
TenantId: contexts.GetTenantId(ctx),
|
|
DeptId: contexts.GetDeptId(ctx),
|
|
UserId: contexts.GetUserId(ctx),
|
|
}
|
|
}
|
|
|
|
func PendingSubmitResult(result *batchimport.Result, status int) *SubmitResult {
|
|
res := &SubmitResult{BatchAsyncStatus: status}
|
|
if result == nil {
|
|
return res
|
|
}
|
|
res.BatchNo = result.BatchNo
|
|
res.BatchType = result.BatchType
|
|
res.Total = result.TotalRows
|
|
return res
|
|
}
|