baize/convenient/domain/auth/user/api.go

package user

import (
	"git.sxidc.com/go-framework/baize/convenient/entity_crud"
	"git.sxidc.com/go-framework/baize/framework/binding"
	"git.sxidc.com/go-framework/baize/framework/core/api/response"
	"git.sxidc.com/go-framework/baize/framework/core/domain"
	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/sql"
	"git.sxidc.com/go-framework/baize/framework/core/tag/check"
	"git.sxidc.com/go-tools/utils/encoding"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
)

// Simple Bind参数
type Simple struct {
	// schema
	Schema string

	// AES加密用到的Key
	AESKey string

	// 鉴权中间件
	AuthMiddleware binding.Middleware
}

func (simple *Simple) Bind(binder *binding.Binder) {
	entity_crud.BindSimple(binder, &entity_crud.Simple[Info]{
		Entity:             &Entity{},
		Schema:             simple.Schema,
		CreateJsonBody:     &CreateUserJsonBody{},
		DeleteQueryParams:  &DeleteUserQueryParams{},
		UpdateJsonBody:     &UpdateUserJsonBody{},
		QueryQueryParams:   &GetUsersQueryParams{},
		GetByIDQueryParams: &GetUserQueryParams{},
	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
			Before: func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
				userEntity, err := domain.ToConcrete[*Entity](e)
				if err != nil {
					return err
				}

				encryptedPassword, err := encoding.AESEncrypt(userEntity.Password, simple.AESKey)
				if err != nil {
					return errors.New(err.Error())
				}

				userEntity.Password = encryptedPassword

				if strutils.IsStringEmpty(userEntity.Name) {
					userEntity.Name = "匿名-" + strutils.SimpleUUID()[0:8]
				}

				encryptedPhone, err := encoding.AESEncrypt(userEntity.Phone, simple.AESKey)
				if err != nil {
					return errors.New(err.Error())
				}

				userEntity.Phone = encryptedPhone

				encryptedEmail, err := encoding.AESEncrypt(userEntity.Email, simple.AESKey)
				if err != nil {
					return errors.New(err.Error())
				}

				userEntity.Email = encryptedEmail

				checkResult := check.Struct(userEntity, fieldMap)

				err = domain.CheckField(checkResult, userEntity.DomainCNName(), FieldPassword)
				if err != nil {
					return err
				}

				err = domain.CheckField(checkResult, userEntity.DomainCNName(), FieldName)
				if err != nil {
					return err
				}

				err = domain.CheckField(checkResult, userEntity.DomainCNName(), FieldPhone)
				if err != nil {
					return err
				}

				err = domain.CheckField(checkResult, userEntity.DomainCNName(), FieldEmail)
				if err != nil {
					return err
				}

				return nil
			},
		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
			Before: func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
				userEntity, err := domain.ToConcrete[*Entity](e)
				if err != nil {
					return err
				}

				if strutils.IsStringNotEmpty(userEntity.Password) {
					encryptedPassword, err := encoding.AESEncrypt(userEntity.Password, simple.AESKey)
					if err != nil {
						return errors.New(err.Error())
					}

					userEntity.Password = encryptedPassword
				}

				if strutils.IsStringEmpty(userEntity.Name) {
					userEntity.Name = "匿名-" + strutils.SimpleUUID()[0:8]
				}

				if strutils.IsStringNotEmpty(userEntity.Phone) {
					encryptedPhone, err := encoding.AESEncrypt(userEntity.Phone, simple.AESKey)
					if err != nil {
						return errors.New(err.Error())
					}

					userEntity.Phone = encryptedPhone
				}

				if strutils.IsStringNotEmpty(userEntity.Email) {
					encryptedEmail, err := encoding.AESEncrypt(userEntity.Email, simple.AESKey)
					if err != nil {
						return errors.New(err.Error())
					}

					userEntity.Email = encryptedEmail
				}

				checkResult := check.Struct(userEntity, fieldMap)

				if strutils.IsStringNotEmpty(userEntity.Password) {
					err := domain.CheckField(checkResult, e.DomainCNName(), FieldPassword)
					if err != nil {
						return err
					}
				}

				if strutils.IsStringNotEmpty(userEntity.Name) {
					err := domain.CheckField(checkResult, e.DomainCNName(), FieldName)
					if err != nil {
						return err
					}
				}

				if strutils.IsStringNotEmpty(userEntity.Phone) {
					err := domain.CheckField(checkResult, e.DomainCNName(), FieldPhone)
					if err != nil {
						return err
					}
				}

				if strutils.IsStringNotEmpty(userEntity.Email) {
					err := domain.CheckField(checkResult, e.DomainCNName(), FieldEmail)
					if err != nil {
						return err
					}
				}

				return nil
			},
		}), entity_crud.WithQueryConditionFieldCallback[Info](func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool, err error) {
			if value == nil {
				return true, nil
			}

			switch fieldName {
			case FieldUserName:
				userName, ok := value.(string)
				if !ok {
					return false, errors.New("用户名字段类型不是string")
				}

				if strutils.IsStringNotEmpty(userName) {
					conditions.Like(ColumnUserName, "%"+userName+"%")
				}

				return true, nil
			case FieldName:
				name, ok := value.(string)
				if !ok {
					return false, errors.New("姓名字段类型不是string")
				}

				if strutils.IsStringNotEmpty(name) {
					conditions.Like(ColumnName, "%"+name+"%")
				}

				return true, nil
			case FieldPhone:
				phone, ok := value.(string)
				if !ok {
					return false, errors.New("手机号字段类型不是string")
				}

				if strutils.IsStringNotEmpty(phone) {
					encryptedPhone, err := encoding.AESEncrypt(phone, simple.AESKey)
					if err != nil {
						return false, errors.New(err.Error())
					}

					conditions.Equal(ColumnPhone, encryptedPhone)
				}

				return true, nil
			case FieldEmail:
				email, ok := value.(string)
				if !ok {
					return false, errors.New("邮箱字段类型不是string")
				}

				if strutils.IsStringNotEmpty(email) {
					encryptedEmail, err := encoding.AESEncrypt(email, simple.AESKey)
					if err != nil {
						return false, errors.New(err.Error())
					}

					conditions.Equal(ColumnEmail, encryptedEmail)
				}

				return true, nil
			default:
				return false, nil
			}
		}), entity_crud.WithQueryCallbacks(&entity_crud.QueryCallbacks[Info]{
			OnSuccessReturn: func(e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[Info]) (response.InfosData[Info], error) {
				errResponse := response.InfosData[Info]{
					Infos: make([]Info, 0),
				}

				retInfos := make([]Info, len(output.Infos))
				infos := output.Infos

				for index, info := range infos {
					if strutils.IsStringNotEmpty(info.Phone) {
						decryptedPhone, err := encoding.AESDecrypt(info.Phone, simple.AESKey)
						if err != nil {
							return errResponse, errors.New(err.Error())
						}

						info.Phone = decryptedPhone
					}

					if strutils.IsStringNotEmpty(info.Email) {
						decryptedEmail, err := encoding.AESDecrypt(info.Email, simple.AESKey)
						if err != nil {
							return errResponse, errors.New(err.Error())
						}

						info.Email = decryptedEmail
					}

					retInfos[index] = info
				}

				return response.InfosData[Info]{
					Infos:      retInfos,
					TotalCount: output.TotalCount,
					PageNo:     output.PageNo,
				}, nil
			},
		}), entity_crud.WithGetByIDCallbacks(&entity_crud.GetByIDCallbacks[Info]{
			OnSuccessReturn: func(e entity.Entity, i *infrastructure.Infrastructure, output Info) (Info, error) {
				if strutils.IsStringNotEmpty(output.Name) {
					encryptedName, err := encoding.AESEncrypt(output.Name, simple.AESKey)
					if err != nil {
						return Info{}, errors.New(err.Error())
					}

					output.Name = encryptedName
				}

				if strutils.IsStringNotEmpty(output.Email) {
					encryptedEmail, err := encoding.AESEncrypt(output.Email, simple.AESKey)
					if err != nil {
						return Info{}, errors.New(err.Error())
					}

					output.Email = encryptedEmail
				}

				return output, nil
			},
		}))
}