ArmedPolice/app/controller/user/instance.go

package user

import (
	model2 "ArmedPolice/app/common/model"
	"ArmedPolice/app/controller/basic"
	"ArmedPolice/app/model"
	"ArmedPolice/app/service"
	"errors"
	"time"
)

type Instance struct{ *service.Session }

type InstanceHandle func(session *service.Session) *Instance

type (
	// InstanceBasic 基本信息
	InstanceBasic struct {
		Name   string `json:"name"`
		Avatar string `json:"avatar"`
	}
	// InstanceInfo 用户信息
	InstanceInfo struct {
		ID string `json:"id"`
		*model.SysUserInfo
	}
	// InstanceParams 参数信息
	InstanceParams struct {
		ID                                              uint64
		Account, Name, Avatar, Mobile, Password, Remark string
		Gender                                          int
	}
)

// Info 基本信息
func (c *Instance) Info() *InstanceBasic {
	return &InstanceBasic{Name: c.Name, Avatar: c.Avatar}
}

// List 列表信息
func (c *Instance) List(name, mobile string, tenantID uint64, page, pageSize int) (*basic.PageDataResponse, error) {
	mSysUser := model.NewSysUser()

	where := make([]*model2.ModelWhere, 0)

	if name != "" {
		where = append(where, model2.NewWhereLike("u.name", name))
	}
	if mobile != "" {
		where = append(where, model2.NewWhereLike("u.mobile", mobile))
	}
	if tenantID > 0 {
		where = append(where, model2.NewWhere("u.tenant_id", tenantID))
	}
	var count int64

	out, err := mSysUser.Users(page, pageSize, &count)

	if err != nil {
		return nil, err
	}

	list := make([]*InstanceInfo, 0)

	for _, v := range out {
		list = append(list, &InstanceInfo{ID: v.GetEncodeID(), SysUserInfo: v})
	}
	return &basic.PageDataResponse{Data: list, Count: count}, nil
}

// Form 数据操作
func (c *Instance) Form(params *InstanceParams) error {
	mSysUser := model.NewSysUser()

	if params.ID > 0 {
		mSysUser.ID = params.ID

		isExist, err := model2.FirstField(mSysUser.SysUser, []string{"id", "name", "mobile"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，用户信息不存在或已被删除")
		}
		if mSysUser.Mobile != params.Mobile {
			var count int64

			if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
				return err
			} else if count > 0 {
				return errors.New("操作错误，该手机号已被注册")
			}
		}
		return model2.Updates(mSysUser.SysUser, map[string]interface{}{
			"name": params.Name, "mobile": params.Mobile, "avatar": params.Avatar, "gender": params.Gender,
			"remark": params.Remark, "updated_at": time.Now(),
		})
	}
	if params.Password == "" {
		return errors.New("操作错误，密码不可为空")
	}
	var count int64

	err := model2.Count(mSysUser.SysUser, &count, model2.NewWhere("account", params.Account))

	if err != nil {
		return err
	} else if count > 0 {
		return errors.New("操作错误，该账户名已被注册")
	}
	if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
		return err
	} else if count > 0 {
		return errors.New("操作错误，该手机号已被注册")
	}
	mSysUser.Account = params.Account
	mSysUser.Name = params.Name
	mSysUser.Mobile = params.Mobile
	mSysUser.Avatar = params.Avatar
	mSysUser.Password = params.Password
	mSysUser.Gender.Gender = model2.GenderKind(params.Gender)
	mSysUser.Remark = params.Remark

	return model2.Create(mSysUser.SysUser)
}

// Delete 删除信息
func (c *Instance) Delete(id uint64) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id
	return model2.Delete(mSysUser.SysUser)
}

// PasswordQuick 快速设置密码
func (c *Instance) PasswordQuick(id uint64, password string) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id
	mSysUser.Password = password
	mSysUser.Pass()

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

// PasswordTradition 传统设置密码
func (c *Instance) PasswordTradition(id uint64, originalPwd, password, repeatPwd string) error {
	if password != repeatPwd {
		return errors.New("操作错误，密码输入不正确")
	}
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

	isExist, err := model2.FirstField(mSysUser.SysUser, []string{"id", "password", "salt"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，用户信息不存在或已被删除")
	}
	if !mSysUser.ValidatePassword(originalPwd) {
		return errors.New("操作错误，旧密码不正确")
	}
	mSysUser.Password = password
	mSysUser.Pass()

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

// Status 状态处理
func (c *Instance) Status(id uint64, status model2.SysUserStatus) error {
	mSysUser := model.NewSysUser()
	mSysUser.ID = id

	if err := model2.Updates(mSysUser.SysUser, map[string]interface{}{
		"status": status, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	return nil
}

func NewInstance() InstanceHandle {
	return func(session *service.Session) *Instance {
		return &Instance{session}
	}
}