425 lines
15 KiB
Go
425 lines
15 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"electricity_bill_calc/config"
|
|
"electricity_bill_calc/global"
|
|
"electricity_bill_calc/logger"
|
|
"electricity_bill_calc/model"
|
|
"electricity_bill_calc/tools"
|
|
"electricity_bill_calc/types"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"github.com/doug-martin/goqu/v9"
|
|
_ "github.com/doug-martin/goqu/v9/dialect/postgres"
|
|
"github.com/fufuok/utils/xhash"
|
|
"github.com/georgysavva/scany/v2/pgxscan"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/samber/lo"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type _UserRepository struct {
|
|
log *zap.Logger
|
|
ds goqu.DialectWrapper
|
|
}
|
|
|
|
var UserRepository = _UserRepository{
|
|
log: logger.Named("Repository", "User"),
|
|
ds: goqu.Dialect("postgres"),
|
|
}
|
|
|
|
// 使用用户名查询指定用户的基本信息
|
|
func (ur _UserRepository) FindUserByUsername(username string) (*model.User, error) {
|
|
ur.log.Info("根据用户名查询指定用户的基本信息。", zap.String("username", username))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var user model.User
|
|
sql, params, _ := ur.ds.From("user").Where(goqu.Ex{"username": username}).Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(ctx, global.DB, &user, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户名的用户基本信息失败。", zap.String("username", username), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// 使用用户唯一编号查询指定用户的基本信息
|
|
func (ur _UserRepository) FindUserById(uid string) (*model.User, error) {
|
|
ur.log.Info("根据用户唯一编号查询指定用户的基本信息。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var user model.User
|
|
sql, params, _ := ur.ds.From("user").Where(goqu.Ex{"id": uid}).Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(ctx, global.DB, &user, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户唯一编号的用户基本信息失败。", zap.String("user id", uid), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// 使用用户的唯一编号获取用户的详细信息
|
|
func (ur _UserRepository) FindUserDetailById(uid string) (*model.UserDetail, error) {
|
|
ur.log.Info("根据用户唯一编号查询指定用户的详细信息。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var user model.UserDetail
|
|
sql, params, _ := ur.ds.From("user_detail").Where(goqu.Ex{"id": uid}).Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(ctx, global.DB, &user, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户唯一编号的用户详细信息失败。", zap.String("user id", uid), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// 使用用户唯一编号获取用户的综合详细信息
|
|
func (ur _UserRepository) FindUserInformation(uid string) (*model.UserWithDetail, error) {
|
|
ur.log.Info("根据用户唯一编号查询用户的综合详细信息", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var user model.UserWithDetail
|
|
sql, params, _ := ur.ds.
|
|
From("user").As("u").
|
|
Join(
|
|
goqu.T("user_detail").As("ud"),
|
|
goqu.On(goqu.Ex{
|
|
"ud.id": goqu.I("u.id"),
|
|
})).
|
|
Select(
|
|
"u.id", "u.username", "u.reset_needed", "u.type", "u.enabled",
|
|
"ud.name", "ud.abbr", "ud.region", "ud.address", "ud.contact", "ud.phone",
|
|
"ud.unit_service_fee", "ud.service_expiration",
|
|
"ud.created_at", "ud.created_by", "ud.last_modified_at", "ud.last_modified_by").
|
|
Where(goqu.Ex{"u.id": uid}).
|
|
Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(
|
|
ctx, global.DB, &user, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户唯一编号的用户详细信息失败。", zap.String("user id", uid), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return &user, nil
|
|
}
|
|
|
|
// 检查指定用户唯一编号是否存在对应的用户
|
|
func (ur _UserRepository) IsUserExists(uid string) (bool, error) {
|
|
ur.log.Info("检查指定用户唯一编号是否存在对应的用户。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var userCount int
|
|
sql, params, _ := ur.ds.From("user").Select(goqu.COUNT("*")).Where(goqu.Ex{"id": uid}).Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(ctx, global.DB, &userCount, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户唯一编号的用户基本信息失败。", zap.String("user id", uid), zap.Error(err))
|
|
return false, err
|
|
}
|
|
return userCount > 0, nil
|
|
}
|
|
|
|
// 检查指定用户名在数据库中是否已经存在
|
|
func (ur _UserRepository) IsUsernameExists(username string) (bool, error) {
|
|
ur.log.Info("检查指定用户名在数据库中是否已经存在。", zap.String("username", username))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var userCount int
|
|
sql, params, _ := ur.ds.From("user").Select(goqu.COUNT("*")).Where(goqu.Ex{"username": username}).Prepared(true).ToSQL()
|
|
if err := pgxscan.Get(ctx, global.DB, &userCount, sql, params...); err != nil {
|
|
ur.log.Error("从数据库查询指定用户名的用户基本信息失败。", zap.String("username", username), zap.Error(err))
|
|
return false, err
|
|
}
|
|
return userCount > 0, nil
|
|
}
|
|
|
|
// 创建一个新用户
|
|
func (ur _UserRepository) CreateUser(user model.User, detail model.UserDetail, operator *string) (bool, error) {
|
|
ur.log.Info("创建一个新用户。", zap.String("username", user.Username))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
tx, err := global.DB.Begin(ctx)
|
|
if err != nil {
|
|
ur.log.Error("启动数据库事务失败。", zap.Error(err))
|
|
return false, err
|
|
}
|
|
|
|
createdTime := types.Now()
|
|
userSql, userParams, _ := ur.ds.
|
|
Insert("user").
|
|
Rows(
|
|
goqu.Record{
|
|
"id": user.Id, "username": user.Username, "password": user.Password,
|
|
"reset_needed": user.ResetNeeded, "type": user.UserType, "enabled": user.Enabled,
|
|
"created_at": createdTime,
|
|
},
|
|
).
|
|
Prepared(true).ToSQL()
|
|
userResult, err := tx.Exec(ctx, userSql, userParams...)
|
|
if err != nil {
|
|
ur.log.Error("向数据库插入新用户基本信息失败。", zap.Error(err))
|
|
tx.Rollback(ctx)
|
|
return false, err
|
|
}
|
|
userDetailSql, userDetailParams, _ := ur.ds.
|
|
Insert("user_detail").
|
|
Rows(
|
|
goqu.Record{
|
|
"id": user.Id, "name": detail.Name, "abbr": tools.PinyinAbbr(*detail.Name), "region": detail.Region,
|
|
"address": detail.Address, "contact": detail.Contact, "phone": detail.Phone,
|
|
"unit_service_fee": detail.UnitServiceFee, "service_expiration": detail.ServiceExpiration,
|
|
"created_at": createdTime, "created_by": operator,
|
|
"last_modified_at": createdTime, "last_modified_by": operator,
|
|
},
|
|
).
|
|
Prepared(true).ToSQL()
|
|
detailResult, err := tx.Exec(ctx, userDetailSql, userDetailParams...)
|
|
if err != nil {
|
|
ur.log.Error("向数据库插入新用户详细信息失败。", zap.Error(err))
|
|
tx.Rollback(ctx)
|
|
return false, err
|
|
}
|
|
|
|
err = tx.Commit(ctx)
|
|
if err != nil {
|
|
ur.log.Error("提交数据库事务失败。", zap.Error(err))
|
|
tx.Rollback(ctx)
|
|
return false, err
|
|
}
|
|
return userResult.RowsAffected() > 0 && detailResult.RowsAffected() > 0, nil
|
|
}
|
|
|
|
// 根据给定的条件检索用户
|
|
func (ur _UserRepository) FindUser(keyword *string, userType int16, state *bool, page uint) ([]*model.UserWithDetail, int64, error) {
|
|
ur.log.Info("根据给定的条件检索用户。", zap.Uint("page", page), zap.Stringp("keyword", keyword), zap.Int16("user type", userType), zap.Boolp("state", state))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var (
|
|
userWithDetails []*model.UserWithDetail
|
|
userCount int64
|
|
)
|
|
userQuery := ur.ds.
|
|
From(goqu.T("user").As("u")).
|
|
Join(goqu.T("user_detail").As("ud"), goqu.On(goqu.Ex{"ud.id": goqu.I("u.id")})).
|
|
Select(
|
|
"u.id", "u.username", "u.reset_needed", "u.type", "u.enabled",
|
|
"ud.name", "ud.abbr", "ud.region", "ud.address", "ud.contact", "ud.phone",
|
|
"ud.unit_service_fee", "ud.service_expiration",
|
|
"ud.created_at", "ud.created_by", "ud.last_modified_at", "ud.last_modified_by",
|
|
)
|
|
countQuery := ur.ds.
|
|
From(goqu.T("user").As("u")).
|
|
Join(goqu.T("user_detail").As("ud"), goqu.On(goqu.Ex{"ud.id": goqu.I("u.id")})).
|
|
Select(goqu.COUNT("*"))
|
|
|
|
if keyword != nil && len(*keyword) > 0 {
|
|
pattern := fmt.Sprintf("%%%s%%", *keyword)
|
|
userQuery = userQuery.Where(
|
|
goqu.Or(
|
|
goqu.I("u.username").ILike(pattern),
|
|
goqu.I("ud.name").ILike(pattern),
|
|
goqu.I("ud.abbr").ILike(pattern),
|
|
),
|
|
)
|
|
countQuery = countQuery.Where(
|
|
goqu.Or(
|
|
goqu.I("u.username").ILike(pattern),
|
|
goqu.I("ud.name").ILike(pattern),
|
|
goqu.I("ud.abbr").ILike(pattern),
|
|
),
|
|
)
|
|
}
|
|
|
|
if userType != -1 {
|
|
userQuery = userQuery.Where(goqu.Ex{"u.type": userType})
|
|
countQuery = countQuery.Where(goqu.Ex{"u.type": userType})
|
|
}
|
|
|
|
if state != nil {
|
|
//userQuery = userQuery.Where(goqu.C("u.enabled").Eq(*state))
|
|
userQuery = userQuery.Where(goqu.Ex{"u.enabled": *state})
|
|
countQuery = countQuery.Where(goqu.Ex{"u.enabled": *state})
|
|
//countQuery = countQuery.Where(goqu.C("u.enabled").Eq(*state))
|
|
|
|
}
|
|
|
|
userQuery.Order(goqu.I("u.created_at").Desc())
|
|
|
|
currentPosition := (page - 1) * config.ServiceSettings.ItemsPageSize
|
|
userQuery = userQuery.Offset(currentPosition).Limit(config.ServiceSettings.ItemsPageSize)
|
|
|
|
userSql, userParams, _ := userQuery.Prepared(true).ToSQL()
|
|
countSql, countParams, _ := countQuery.Prepared(true).ToSQL()
|
|
log.Println(">>>>>>>>>>>", userSql)
|
|
if err := pgxscan.Select(ctx, global.DB, &userWithDetails, userSql, userParams...); err != nil {
|
|
ur.log.Error("从数据库查询用户列表失败。》》》》》》》》》》》》》》", zap.Error(err))
|
|
return make([]*model.UserWithDetail, 0), 0, err
|
|
}
|
|
if err := pgxscan.Get(ctx, global.DB, &userCount, countSql, countParams...); err != nil {
|
|
ur.log.Error("从数据库查询用户列表总数失败。", zap.Error(err))
|
|
return make([]*model.UserWithDetail, 0), 0, err
|
|
}
|
|
return userWithDetails, userCount, nil
|
|
}
|
|
|
|
// 更新指定用户的详细信息
|
|
func (ur _UserRepository) UpdateDetail(uid string, userDetail model.UserModificationForm, operator *string) (bool, error) {
|
|
ur.log.Info("更新指定用户的详细信息。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
updates := goqu.Record{
|
|
"name": userDetail.Name, "abbr": tools.PinyinAbbr(userDetail.Name), "region": userDetail.Region,
|
|
"address": userDetail.Address, "contact": userDetail.Contact, "phone": userDetail.Phone,
|
|
"last_modified_at": types.Now(), "last_modified_by": operator,
|
|
}
|
|
if userDetail.UnitServiceFee != nil {
|
|
updates = lo.Assign(updates, goqu.Record{"unit_service_fee": userDetail.UnitServiceFee})
|
|
}
|
|
|
|
userDetailUpdateQuery := ur.ds.
|
|
Update("user_detail").
|
|
Set(updates).
|
|
Where(goqu.Ex{"id": uid})
|
|
|
|
userDetailSql, userDetailParams, _ := userDetailUpdateQuery.
|
|
Prepared(true).ToSQL()
|
|
|
|
if res, err := global.DB.Exec(ctx, userDetailSql, userDetailParams...); err != nil {
|
|
ur.log.Error("向数据库更新指定用户的详细信息失败。", zap.String("user id", uid), zap.Error(err))
|
|
return false, err
|
|
} else {
|
|
return res.RowsAffected() > 0, nil
|
|
}
|
|
}
|
|
|
|
// 更新指定用户的登录凭据
|
|
func (ur _UserRepository) UpdatePassword(uid, newCredential string, needReset bool) (bool, error) {
|
|
ur.log.Info("更新指定用户的登录凭据。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
userUpdateQuery := ur.ds.
|
|
Update("user").
|
|
Set(goqu.Record{"password": xhash.Sha512Hex(newCredential), "reset_needed": needReset}).
|
|
Where(goqu.Ex{"id": uid})
|
|
|
|
userSql, userParams, _ := userUpdateQuery.
|
|
Prepared(true).ToSQL()
|
|
|
|
if res, err := global.DB.Exec(ctx, userSql, userParams...); err != nil {
|
|
ur.log.Error("向数据库更新指定用户的登录凭据失败。", zap.String("user id", uid), zap.Error(err))
|
|
return false, err
|
|
} else {
|
|
return res.RowsAffected() > 0, nil
|
|
}
|
|
}
|
|
|
|
// 更新指定用户的可用性状态
|
|
func (ur _UserRepository) ChangeState(uid string, state bool) (bool, error) {
|
|
ur.log.Info("更新指定用户的可用性状态。", zap.String("user id", uid))
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
userUpdateQuery := ur.ds.
|
|
Update("user").
|
|
Set(goqu.Record{"enabled": state}).
|
|
Where(goqu.Ex{"id": uid})
|
|
|
|
userSql, userParams, _ := userUpdateQuery.
|
|
Prepared(true).ToSQL()
|
|
|
|
if res, err := global.DB.Exec(ctx, userSql, userParams...); err != nil {
|
|
ur.log.Error("向数据库更新指定用户的可用性状态失败。", zap.String("user id", uid), zap.Error(err))
|
|
return false, err
|
|
} else {
|
|
return res.RowsAffected() > 0, nil
|
|
}
|
|
}
|
|
|
|
// 检索条目数量有限的用户详细信息
|
|
func (ur _UserRepository) SearchUsersWithLimit(userType *int16, keyword *string, limit uint) ([]*model.UserWithDetail, error) {
|
|
ur.log.Info("检索条目数量有限的用户详细信息。", zap.Int16p("user type", userType), zap.Uint("limit", limit), zap.Stringp("keyword", keyword))
|
|
actualUserType := tools.DefaultTo(userType, model.USER_TYPE_ENT)
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var users = make([]*model.UserWithDetail, 0)
|
|
userQuery := ur.ds.
|
|
From(goqu.T("user").As("u")).
|
|
Join(goqu.T("user_detail").As("ud"), goqu.On(goqu.Ex{"ud.id": goqu.I("u.id")})).
|
|
Select(
|
|
"u.id", "u.username", "u.reset_needed", "u.type", "u.enabled",
|
|
"ud.name", "ud.abbr", "ud.region", "ud.address", "ud.contact", "ud.phone",
|
|
"ud.unit_service_fee", "ud.service_expiration",
|
|
"ud.created_at", "ud.created_by", "ud.last_modified_at", "ud.last_modified_by",
|
|
)
|
|
|
|
if keyword != nil && len(*keyword) > 0 {
|
|
pattern := fmt.Sprintf("%%%s%%", *keyword)
|
|
userQuery = userQuery.Where(
|
|
goqu.Or(
|
|
goqu.I("u.username").ILike(pattern),
|
|
goqu.I("ud.name").ILike(pattern),
|
|
goqu.I("ud.abbr").ILike(pattern),
|
|
),
|
|
)
|
|
}
|
|
|
|
userQuery = userQuery.Where(goqu.Ex{"u.type": actualUserType})
|
|
|
|
userQuery.Order(goqu.I("u.created_at").Desc()).Limit(limit)
|
|
|
|
userSql, userParams, _ := userQuery.Prepared(true).ToSQL()
|
|
if err := pgxscan.Select(ctx, global.DB, &users, userSql, userParams...); err != nil {
|
|
ur.log.Error("从数据库查询用户列表失败。", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
// 更新指定用户的服务有效期限
|
|
func (ur _UserRepository) UpdateServiceExpiration(tx pgx.Tx, ctx context.Context, uid string, expiration time.Time) (bool, error) {
|
|
ur.log.Info("更新指定用户的服务有效期限。", zap.String("user id", uid))
|
|
|
|
userDetailUpdateQuery := ur.ds.
|
|
Update("user_detail").
|
|
Set(goqu.Record{"service_expiration": expiration}).
|
|
Where(goqu.Ex{"id": uid})
|
|
|
|
userDetailSql, userDetailParams, _ := userDetailUpdateQuery.
|
|
Prepared(true).ToSQL()
|
|
|
|
if res, err := tx.Exec(ctx, userDetailSql, userDetailParams...); err != nil {
|
|
ur.log.Error("向数据库更新指定用户的服务有效期限失败。", zap.String("user id", uid), zap.Error(err))
|
|
return false, err
|
|
} else {
|
|
return res.RowsAffected() > 0, nil
|
|
}
|
|
}
|
|
|
|
// 检索指定用户列表的详细信息
|
|
func (ur _UserRepository) RetrieveUsersDetail(uids []string) ([]*model.UserDetail, error) {
|
|
ur.log.Info("检索指定用户列表的详细信息。", zap.Strings("user ids", uids))
|
|
if len(uids) == 0 {
|
|
return make([]*model.UserDetail, 0), nil
|
|
}
|
|
ctx, cancel := global.TimeoutContext()
|
|
defer cancel()
|
|
|
|
var users []*model.UserDetail
|
|
userQuery := ur.ds.
|
|
From("user_detail").
|
|
Where(goqu.Ex{"id": uids})
|
|
|
|
userSql, userParams, _ := userQuery.Prepared(true).ToSQL()
|
|
if err := pgxscan.Select(ctx, global.DB, &users, userSql, userParams...); err != nil {
|
|
ur.log.Error("从数据库查询用户列表失败。", zap.Error(err))
|
|
return make([]*model.UserDetail, 0), err
|
|
}
|
|
return users, nil
|
|
}
|