perms-system-server/internal/model/user/sysUserModel_gen.go

// Code generated by goctl. DO NOT EDIT.
// versions:
//  goctl version: 1.10.0

package user

import (
	"context"
	"database/sql"
	"fmt"
	"strings"

	"github.com/zeromicro/go-zero/core/stores/builder"
	"github.com/zeromicro/go-zero/core/stores/cache"
	"github.com/zeromicro/go-zero/core/stores/sqlc"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"github.com/zeromicro/go-zero/core/stringx"
)

var (
	sysUserFieldNames          = builder.RawFieldNames(&SysUser{})
	sysUserRows                = strings.Join(sysUserFieldNames, ",")
	sysUserRowsExpectAutoSet   = strings.Join(stringx.Remove(sysUserFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), ",")
	sysUserRowsWithPlaceHolder = strings.Join(stringx.Remove(sysUserFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), "=?,") + "=?"

	cacheSysUserIdPrefix       = "cache:sysUser:id:"
	cacheSysUserUsernamePrefix = "cache:sysUser:username:"
)

type (
	sysUserModel interface {
		Insert(ctx context.Context, data *SysUser) (sql.Result, error)
		InsertWithTx(ctx context.Context, session sqlx.Session, data *SysUser) (sql.Result, error)
		BatchInsert(ctx context.Context, dataList []*SysUser) error
		BatchInsertWithTx(ctx context.Context, session sqlx.Session, dataList []*SysUser) error
		TransactCtx(ctx context.Context, fn func(context.Context, sqlx.Session) error) error
		FindOne(ctx context.Context, id int64) (*SysUser, error)
		FindOneWithTx(ctx context.Context, session sqlx.Session, id int64) (*SysUser, error)
		FindOneByUsername(ctx context.Context, username string) (*SysUser, error)
		FindOneByUsernameWithTx(ctx context.Context, session sqlx.Session, username string) (*SysUser, error)
		Update(ctx context.Context, data *SysUser) error
		UpdateWithTx(ctx context.Context, session sqlx.Session, data *SysUser) error
		BatchUpdate(ctx context.Context, dataList []*SysUser) error
		BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*SysUser) error
		Delete(ctx context.Context, id int64) error
		DeleteWithTx(ctx context.Context, session sqlx.Session, id int64) error
		BatchDelete(ctx context.Context, ids []int64) error
		BatchDeleteWithTx(ctx context.Context, session sqlx.Session, ids []int64) error
		TableName() string
	}

	defaultSysUserModel struct {
		sqlc.CachedConn
		table string
	}

	SysUser struct {
		Id                 int64          `db:"id"`
		Username           string         `db:"username"`           // 登录名
		Password           string         `db:"password"`           // 登录密码
		Nickname           string         `db:"nickname"`           // 昵称
		Avatar             sql.NullString `db:"avatar"`             // 头像
		Email              string         `db:"email"`              // 邮箱
		Phone              string         `db:"phone"`              // 手机号
		Remark             string         `db:"remark"`             // 备注
		DeptId             int64          `db:"deptId"`             // 所属部门ID
		IsSuperAdmin       int64          `db:"isSuperAdmin"`       // 是否为超级管理员 1是 2否
		MustChangePassword int64          `db:"mustChangePassword"` // 是否需要强制修改密码 1是 2否
		Status             int64          `db:"status"`             // 状态 1正常 2冻结
		CreateTime         int64          `db:"createTime"`         // 创建时间
		UpdateTime         int64          `db:"updateTime"`         // 修改时间
	}
)

func newSysUserModel(conn sqlx.SqlConn, c cache.CacheConf, cachePrefix string, opts ...cache.Option) *defaultSysUserModel {
	if cachePrefix != "" {
		cacheSysUserIdPrefix = cachePrefix + ":" + "cache:sysUser:id:"
		cacheSysUserUsernamePrefix = cachePrefix + ":" + "cache:sysUser:username:"

	}
	return &defaultSysUserModel{
		CachedConn: sqlc.NewConn(conn, c, opts...),
		table:      "`sys_user`",
	}
}

func (m *defaultSysUserModel) Delete(ctx context.Context, id int64) error {
	data, err := m.FindOne(ctx, id)
	if err != nil {
		return err
	}

	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("DELETE FROM %s WHERE `id` = ?", m.table)
		return conn.ExecCtx(ctx, query, id)
	}, sysUserIdKey, sysUserUsernameKey)
	return err
}

func (m *defaultSysUserModel) DeleteWithTx(ctx context.Context, session sqlx.Session, id int64) error {
	data, err := m.FindOne(ctx, id)
	if err != nil {
		return err
	}

	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("DELETE FROM %s WHERE `id` = ?", m.table)
		return session.ExecCtx(ctx, query, id)
	}, sysUserIdKey, sysUserUsernameKey)
	return err
}

func (m *defaultSysUserModel) BatchDelete(ctx context.Context, ids []int64) error {
	if len(ids) == 0 {
		return nil
	}

	primaryKeys := make([]interface{}, 0, len(ids))
	for _, key := range ids {
		primaryKeys = append(primaryKeys, key)
	}
	oldDataList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}

	keys := make([]string, 0)
	for _, data := range oldDataList {
		id := m.getPrimaryKeyValue(data)
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)
	}

	placeholders := make([]string, 0, len(ids))
	args := make([]interface{}, 0, len(ids))
	for _, id := range ids {
		placeholders = append(placeholders, "?")
		args = append(args, id)
	}

	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("DELETE FROM %s WHERE `id` IN (%s)", m.table, strings.Join(placeholders, ","))
		return conn.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}

func (m *defaultSysUserModel) BatchDeleteWithTx(ctx context.Context, session sqlx.Session, ids []int64) error {
	if len(ids) == 0 {
		return nil
	}

	primaryKeys := make([]interface{}, 0, len(ids))
	for _, key := range ids {
		primaryKeys = append(primaryKeys, key)
	}
	oldDataList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}

	keys := make([]string, 0)
	for _, data := range oldDataList {
		id := m.getPrimaryKeyValue(data)
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)
	}

	placeholders := make([]string, 0, len(ids))
	args := make([]interface{}, 0, len(ids))
	for _, id := range ids {
		placeholders = append(placeholders, "?")
		args = append(args, id)
	}

	query := fmt.Sprintf("DELETE FROM %s WHERE `id` IN (%s)", m.table, strings.Join(placeholders, ","))
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return session.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}

func (m *defaultSysUserModel) FindOne(ctx context.Context, id int64) (*SysUser, error) {
	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
	var resp SysUser
	err := m.QueryRowCtx(ctx, &resp, sysUserIdKey, func(ctx context.Context, conn sqlx.SqlConn, v any) error {
		query := fmt.Sprintf("SELECT %s FROM %s WHERE `id` = ? LIMIT 1", sysUserRows, m.table)
		return conn.QueryRowCtx(ctx, v, query, id)
	})
	switch err {
	case nil:
		return &resp, nil
	case sqlc.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultSysUserModel) FindOneWithTx(ctx context.Context, session sqlx.Session, id int64) (*SysUser, error) {
	var resp SysUser
	query := fmt.Sprintf("SELECT %s FROM %s WHERE `id` = ? LIMIT 1", sysUserRows, m.table)
	err := session.QueryRowCtx(ctx, &resp, query, id)
	switch err {
	case nil:
		return &resp, nil
	case sqlx.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultSysUserModel) FindOneByUsername(ctx context.Context, username string) (*SysUser, error) {
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, username)
	var resp SysUser
	err := m.QueryRowIndexCtx(ctx, &resp, sysUserUsernameKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v any) (i any, e error) {
		query := fmt.Sprintf("SELECT %s FROM %s WHERE `username` = ? LIMIT 1", sysUserRows, m.table)
		if err := conn.QueryRowCtx(ctx, &resp, query, username); err != nil {
			return nil, err
		}
		return resp.Id, nil
	}, m.queryPrimary)
	switch err {
	case nil:
		return &resp, nil
	case sqlc.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultSysUserModel) FindOneByUsernameWithTx(ctx context.Context, session sqlx.Session, username string) (*SysUser, error) {
	var resp SysUser
	query := fmt.Sprintf("SELECT %s FROM %s WHERE `username` = ? LIMIT 1", sysUserRows, m.table)
	err := session.QueryRowCtx(ctx, &resp, query, username)
	switch err {
	case nil:
		return &resp, nil
	case sqlx.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultSysUserModel) Insert(ctx context.Context, data *SysUser) (sql.Result, error) {
	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	ret, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, sysUserRowsExpectAutoSet)
		return conn.ExecCtx(ctx, query, data.Username, data.Password, data.Nickname, data.Avatar, data.Email, data.Phone, data.Remark, data.DeptId, data.IsSuperAdmin, data.MustChangePassword, data.Status, data.CreateTime, data.UpdateTime)
	}, sysUserIdKey, sysUserUsernameKey)
	return ret, err
}

func (m *defaultSysUserModel) InsertWithTx(ctx context.Context, session sqlx.Session, data *SysUser) (sql.Result, error) {
	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	ret, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, sysUserRowsExpectAutoSet)
		return session.ExecCtx(ctx, query, data.Username, data.Password, data.Nickname, data.Avatar, data.Email, data.Phone, data.Remark, data.DeptId, data.IsSuperAdmin, data.MustChangePassword, data.Status, data.CreateTime, data.UpdateTime)
	}, sysUserIdKey, sysUserUsernameKey)
	return ret, err
}

func (m *defaultSysUserModel) BatchInsert(ctx context.Context, dataList []*SysUser) error {
	if len(dataList) == 0 {
		return nil
	}
	keys := make([]string, 0, len(dataList))
	valueSets := make([]string, 0, len(dataList))
	args := make([]interface{}, 0)
	for _, data := range dataList {
		valueSets = append(valueSets, "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
		args = append(args, data.Username, data.Password, data.Nickname, data.Avatar, data.Email, data.Phone, data.Remark, data.DeptId, data.IsSuperAdmin, data.MustChangePassword, data.Status, data.CreateTime, data.UpdateTime)
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)

	}
	query := fmt.Sprintf("INSERT INTO %s (%s) VALUES %s", m.table, sysUserRowsExpectAutoSet, strings.Join(valueSets, ","))
	_, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return conn.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}

func (m *defaultSysUserModel) BatchInsertWithTx(ctx context.Context, session sqlx.Session, dataList []*SysUser) error {
	if len(dataList) == 0 {
		return nil
	}
	keys := make([]string, 0, len(dataList))
	valueSets := make([]string, 0, len(dataList))
	args := make([]interface{}, 0)
	for _, data := range dataList {
		valueSets = append(valueSets, "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
		args = append(args, data.Username, data.Password, data.Nickname, data.Avatar, data.Email, data.Phone, data.Remark, data.DeptId, data.IsSuperAdmin, data.MustChangePassword, data.Status, data.CreateTime, data.UpdateTime)
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)

	}
	query := fmt.Sprintf("INSERT INTO %s (%s) VALUES %s", m.table, sysUserRowsExpectAutoSet, strings.Join(valueSets, ","))
	_, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return session.ExecCtx(ctx, query, args...)
	}, keys...)
	return err
}

func (m *defaultSysUserModel) Update(ctx context.Context, newData *SysUser) error {
	data, err := m.FindOne(ctx, newData.Id)
	if err != nil {
		return err
	}

	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("UPDATE %s SET %s WHERE `id` = ?", m.table, sysUserRowsWithPlaceHolder)
		return conn.ExecCtx(ctx, query, newData.Username, newData.Password, newData.Nickname, newData.Avatar, newData.Email, newData.Phone, newData.Remark, newData.DeptId, newData.IsSuperAdmin, newData.MustChangePassword, newData.Status, newData.CreateTime, newData.UpdateTime, newData.Id)
	}, sysUserIdKey, sysUserUsernameKey)
	return err
}

func (m *defaultSysUserModel) UpdateWithTx(ctx context.Context, session sqlx.Session, newData *SysUser) error {
	data, err := m.FindOne(ctx, newData.Id)
	if err != nil {
		return err
	}

	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("UPDATE %s SET %s WHERE `id` = ?", m.table, sysUserRowsWithPlaceHolder)
		return session.ExecCtx(ctx, query, newData.Username, newData.Password, newData.Nickname, newData.Avatar, newData.Email, newData.Phone, newData.Remark, newData.DeptId, newData.IsSuperAdmin, newData.MustChangePassword, newData.Status, newData.CreateTime, newData.UpdateTime, newData.Id)
	}, sysUserIdKey, sysUserUsernameKey)
	return err
}

func (m *defaultSysUserModel) BatchUpdate(ctx context.Context, dataList []*SysUser) error {
	if len(dataList) == 0 {
		return nil
	}

	keys := make([]string, 0)
	primaryKeys := make([]interface{}, 0, len(dataList))
	for _, item := range dataList {
		primaryKeys = append(primaryKeys, item.Id)
	}
	oldList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}

	for _, data := range oldList {
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)
	}

	query, vals := m.buildBatchUpdateQuery(dataList)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return conn.ExecCtx(ctx, query, vals...)
	}, keys...)

	return err
}

func (m *defaultSysUserModel) BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*SysUser) error {
	if len(dataList) == 0 {
		return nil
	}

	keys := make([]string, 0)
	primaryKeys := make([]interface{}, 0, len(dataList))
	for _, item := range dataList {
		primaryKeys = append(primaryKeys, item.Id)
	}
	oldList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}

	for _, data := range oldList {
		sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, data.Id)
		sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
		keys = append(keys, sysUserIdKey, sysUserUsernameKey)
	}

	query, vals := m.buildBatchUpdateQuery(dataList)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return session.ExecCtx(ctx, query, vals...)
	}, keys...)

	return err
}

func (m *defaultSysUserModel) buildBatchUpdateQuery(dataList []*SysUser) (string, []interface{}) {
	fields := strings.Split(strings.ReplaceAll(sysUserRowsWithPlaceHolder, "=?", ""), ",")

	listValues := make([][]interface{}, 0, len(dataList))
	for _, newData := range dataList {
		values := make([]interface{}, 0, len(fields)+1)
		values = append(values, newData.Username, newData.Password, newData.Nickname, newData.Avatar, newData.Email, newData.Phone, newData.Remark, newData.DeptId, newData.IsSuperAdmin, newData.MustChangePassword, newData.Status, newData.CreateTime, newData.UpdateTime, newData.Id)
		listValues = append(listValues, values)
	}

	vals := make([]interface{}, 0, len(dataList)*(len(fields)*2+1))
	setClauses := make([]string, len(fields))

	for i, field := range fields {
		caseClauses := make([]string, len(dataList))
		for j, item := range dataList {
			caseClauses[j] = "WHEN `id` = ? THEN ?"
			vals = append(vals, item.Id, listValues[j][i])
		}
		setClauses[i] = fmt.Sprintf("%s = CASE %s ELSE %s END", field, strings.Join(caseClauses, " "), field)
	}

	wherePlaceholders := make([]string, len(dataList))
	for i, item := range dataList {
		wherePlaceholders[i] = "?"
		vals = append(vals, item.Id)
	}

	query := fmt.Sprintf("UPDATE %s SET %s WHERE `id` IN (%s)", m.table, strings.Join(setClauses, ", "), strings.Join(wherePlaceholders, ","))
	return query, vals
}

func (m *defaultSysUserModel) formatPrimary(primary any) string {
	return fmt.Sprintf("%s%v", cacheSysUserIdPrefix, primary)
}

func (m *defaultSysUserModel) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary any) error {
	query := fmt.Sprintf("SELECT %s FROM %s WHERE `id` = ? LIMIT 1", sysUserRows, m.table)
	return conn.QueryRowCtx(ctx, v, query, primary)
}

func (m *defaultSysUserModel) TableName() string {
	return m.table
}

func (m *defaultSysUserModel) findListByPrimaryKeys(ctx context.Context, ids []interface{}) ([]*SysUser, error) {
	if len(ids) == 0 {
		return []*SysUser{}, nil
	}

	placeholders := make([]string, len(ids))
	args := make([]interface{}, len(ids))
	for i, id := range ids {
		placeholders[i] = "?"
		args[i] = id
	}

	var resp []*SysUser
	query := fmt.Sprintf("SELECT %s FROM %s WHERE `id` IN (%s)", sysUserRows, m.table, strings.Join(placeholders, ","))
	err := m.QueryRowsNoCacheCtx(ctx, &resp, query, args...)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

func (m *defaultSysUserModel) getPrimaryKeyValue(data *SysUser) interface{} {
	return data.Id
}