kpt-pasture/module/backend/system_service.go

package backend

import (
	"context"
	"errors"
	"fmt"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"
	"strings"
	"time"

	"github.com/nicksnyder/go-i18n/v2/i18n"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	operationPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/operation"
	"gitee.com/xuyiping_admin/pkg/jwt"
	"gitee.com/xuyiping_admin/pkg/xerr"
	"gorm.io/gorm"
)

const (
	CurrentUserName = "userName"
	CurrentFarmId   = "FarmId"
	LanguageContent = "languageContent"
	Language        = "language"
)

// Login 用户登录
func (s *StoreEntry) Login(ctx context.Context, req *pasturePb.SearchUserRequest) (*pasturePb.SystemUserResponse, error) {
	i18nTemplate, err := s.GetI18nTemplate(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	systemUser := &model.SystemUser{}
	if err = s.DB.Model(new(model.SystemUser)).
		Where("name = ?", req.Name).
		First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.noUser",
			})
			return nil, xerr.Customf(messageId)
		} else {
			return nil, xerr.WithStack(err)
		}
	}

	if systemUser.Password != req.Password {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.wrongPassword",
		})
		return nil, xerr.Customf(messageId)
	}

	if systemUser.IsShow == pasturePb.IsShow_No {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userDisable",
		})
		return nil, xerr.Customf(messageId)
	}

	if systemUser.IsDelete == pasturePb.IsShow_No {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userDelete",
		})
		return nil, xerr.Customf(messageId)
	}

	if len(systemUser.PastureIds) <= 0 {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.unPasture",
		})
		return nil, xerr.Custom(messageId)
	}

	jwtToken := jwt.NewJWTTokenGen(s.Cfg.AppName, s.Cfg.JwtTokenKeyConfig.PrivateKey)
	token, err := jwtToken.GenerateToken(systemUser.Name, s.Cfg.JwtExpireTime)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	if token == "" {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.errorToken",
		})
		return nil, xerr.Custom(messageId)
	}

	expires := time.Now().Local().Add(time.Duration(s.Cfg.JwtExpireTime) * time.Second).Format(util.LayoutTime)
	farmList, err := s.FindPastureListByIds(ctx, systemUser.GetPastureIds())
	if err != nil || len(farmList) == 0 {
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.errorPasture",
		})
		return nil, xerr.Custom(messageId)
	}

	systemUserDepthRole, err := s.GetSystemUserDepthRole(ctx, farmList[0].Id, systemUser.Id)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemRoleList := make([]*model.SystemRole, 0)
	if err = s.DB.Model(new(model.SystemRole)).
		Where("is_show = ? and is_delete = ?", pasturePb.IsShow_Ok, pasturePb.IsShow_Ok).
		Where("id IN ?", systemUserDepthRole.GetRoleIds()).
		Find(&systemRoleList).Error; err != nil {
		zaplog.Error("Login", zap.Any("systemRole", err))
	}

	roleNameList := make([]string, 0)
	for _, role := range systemRoleList {
		roleNameList = append(roleNameList, role.Name)
	}

	return &pasturePb.SystemUserResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SystemUserData{
			AccessToken:  token,
			Expires:      expires,
			RefreshToken: token,
			Username:     systemUser.Name,
			Roles:        roleNameList,
			Avatar:       systemUser.Avatar,
			FarmId:       farmList[0].FarmId,
		},
	}, nil
}

// SearchSystemUserList 查询系统用户
func (s *StoreEntry) SearchSystemUserList(ctx context.Context, req *pasturePb.SearchUserRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchUserResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUserList := make([]*model.SystemUser, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.SystemUser)).
		Where("is_delete = ?", operationPb.IsShow_OK).
		Where("FIND_IN_SET(?, pasture_ids) > ?", userModel.AppPasture.Id, 0).
		Where("name != ?", model.AdminUser)

	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if req.Mobile != "" {
		pref.Where("mobile = ?", req.Mobile)
	}

	if len(req.DepthId) > 0 {
		depthIds := ""
		for _, v := range req.DepthId {
			depthIds += fmt.Sprintf("%d,", v)
		}
		pref.Where("dept_ids = ?", strings.TrimRight(depthIds, ","))
	}

	if req.IsShow > 0 {
		pref.Where("is_show = ?", req.IsShow)
	}

	if err = pref.Order("is_show asc,id desc").
		Count(&count).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&systemUserList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	userIds := make([]int64, 0)
	for _, v := range systemUserList {
		userIds = append(userIds, v.Id)
	}

	systemUserDepthRoleList := make([]*model.SystemUserDepthRole, 0)
	if err = s.DB.Model(new(model.SystemUserDepthRole)).
		Where("user_id IN ?", userIds).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Find(&systemUserDepthRoleList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUserDepthRoleMap := make(map[int64]*model.SystemUserDepthRole)
	for _, v := range systemUserDepthRoleList {
		systemUserDepthRoleMap[v.UserId] = v
	}

	roleList, err := s.SearchSystemRoleListByIds(ctx, userModel.AppPasture.Id, []int64{})
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	deptList, err := s.SearchSystemDeptListByIds(ctx, userModel.AppPasture.Id, []int64{})
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	appPastureList, err := s.FindPastureList(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchUserResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchUserData{
			List:     model.SystemUserSlice(systemUserList).ToPB(deptList, roleList, appPastureList, systemUserDepthRoleMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

// DeleteSystemUser 删除系统用户
func (s *StoreEntry) DeleteSystemUser(ctx context.Context, userId int64) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	systemUser := &model.SystemUser{Id: userId}
	if err = s.DB.Model(new(model.SystemUser)).First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.noUser",
			})
			return xerr.Custom(messageId)
		}
		return xerr.WithStack(err)
	}

	pastureIds := systemUser.GetPastureIds()
	if len(pastureIds) == 1 {
		if err = s.DB.Model(systemUser).
			Update("is_delete", operationPb.IsShow_NO).Error; err != nil {
			return xerr.WithStack(err)
		}
	}
	if len(pastureIds) > 1 {
		newPastureIds := ""
		for _, v := range pastureIds {
			if int64(v) == userModel.AppPasture.Id {
				continue
			}
			newPastureIds += fmt.Sprintf("%d,", v)
		}
		if len(newPastureIds) > 0 {
			if err = s.DB.Model(systemUser).
				Update("pasture_ids", strings.TrimRight(newPastureIds, ",")).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
	}

	return nil
}

// IsShowSystemUser 用户是否启用
func (s *StoreEntry) IsShowSystemUser(ctx context.Context, userId int64) error {
	systemUser := &model.SystemUser{Id: userId}
	if err := s.DB.First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该用户不存在")
		}
		return xerr.WithStack(err)
	}
	isShow := pasturePb.IsShow_No
	if systemUser.IsShow == pasturePb.IsShow_No {
		isShow = pasturePb.IsShow_Ok
	}

	if err := s.DB.Model(systemUser).
		Update("is_show", isShow).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// SystemUserCreateOrUpdate 创建或者更新系统用户
func (s *StoreEntry) SystemUserCreateOrUpdate(ctx context.Context, req *pasturePb.SearchUserRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	pastureIds, deptIds := "", ""
	deptIdsMap := make(map[int64]string)
	for _, pasture := range req.PastureDepthList {
		appPasture, err := s.GetAppPastureListByFarmId(ctx, pasture.FarmId)
		if err != nil {
			return xerr.WithStack(err)
		}
		pastureIds += fmt.Sprintf("%d,", appPasture.Id)
		if len(pasture.DepthList) > 0 {
			for _, dept := range pasture.DepthList {
				deptIds += fmt.Sprintf("%d,", dept.Id)
			}
		}
		if len(pastureIds) > 0 {
			pastureIds = strings.TrimSuffix(pastureIds, ",")
		}

		if len(deptIds) > 0 {
			deptIds = strings.TrimSuffix(deptIds, ",")
			deptIdsMap[appPasture.Id] = deptIds
		}
	}

	systemUser := &model.SystemUser{}
	if req.Id > 0 {
		systemUser.Id = int64(req.Id)
		if err = s.DB.Model(new(model.SystemUser)).
			First(systemUser).Error; err != nil {
			return xerr.WithStack(err)
		}

		systemUser.UserUpdate(req, pastureIds)
		if err = s.DB.Transaction(func(tx *gorm.DB) error {
			if err = tx.Model(new(model.SystemUser)).
				Select("name", "nick_name", "mobile", "gender", "pasture_ids", "remarks", "is_show").
				Where("id = ?", systemUser.Id).
				Updates(systemUser).Error; err != nil {
				return xerr.WithStack(err)
			}

			// 删除重新创建新数据
			if err = tx.Model(new(model.SystemUserDepthRole)).
				Where("user_id = ?", systemUser.Id).
				Delete(new(model.SystemUserDepthRole)).Error; err != nil {
				return xerr.WithStack(err)
			}

			newSystemUserDepthRoleList := model.NewSystemUserDepthRoleList(systemUser.Id, deptIdsMap)
			if err = tx.Model(new(model.SystemUserDepthRole)).
				Create(newSystemUserDepthRoleList).Error; err != nil {
				return xerr.WithStack(err)
			}

			return nil
		}); err != nil {
			return xerr.WithStack(err)
		}
	} else {
		var count int64
		if err = s.DB.Model(new(model.SystemUser)).
			Where("name = ?", req.Name).
			Where("mobile = ?", req.Mobile).
			Where("is_show = ?", pasturePb.IsShow_Ok).
			Count(&count).Error; err != nil {
			return xerr.WithStack(err)
		}

		if count > 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.userNameExist",
			})
			return xerr.Customf(messageId)
		}

		newSystemUser := model.NewSystemUser(req, pastureIds, req.PastureDepthList)
		if err = s.DB.Transaction(func(tx *gorm.DB) error {
			if err = tx.Model(new(model.SystemUser)).
				Create(newSystemUser).Error; err != nil {
				return xerr.WithStack(err)
			}

			if len(deptIdsMap) > 0 {
				newSystemUserDepthRoleList := model.NewSystemUserDepthRoleList(newSystemUser.Id, deptIdsMap)
				if err = tx.Model(new(model.SystemUserDepthRole)).
					Create(newSystemUserDepthRoleList).Error; err != nil {
					return xerr.WithStack(err)
				}
			}
			return nil
		}); err != nil {
			return xerr.WithStack(err)
		}
	}
	return nil
}

// GetSystemUserMenu 返回系统用户相关菜单权限
func (s *StoreEntry) GetSystemUserMenu(ctx context.Context) (*pasturePb.SystemUserMenuTreeResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUserDepthRole, err := s.GetSystemUserDepthRole(ctx, userModel.AppPasture.Id, userModel.SystemUser.Id)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	// 获取用户角色数据
	systemRoleList := make([]*model.SystemRole, 0)
	if err = s.DB.Model(new(model.SystemRole)).
		Where("id IN ?", systemUserDepthRole.GetRoleIds()).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("is_delete = ?", pasturePb.IsShow_Ok).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&systemRoleList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	if len(systemRoleList) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userRoleNotExist",
		})
		return nil, xerr.Custom(messageId)
	}

	systemRoleMenuList := make([]*model.SystemRoleMenu, 0)
	if err = s.DB.Model(new(model.SystemRoleMenu)).
		Where("role_id IN ?", systemUserDepthRole.GetRoleIds()).
		Find(&systemRoleMenuList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	if len(systemRoleMenuList) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.noMenuPermission",
		})
		return nil, xerr.Custom(messageId)
	}

	// 菜单Id
	menuIds := make([]int64, 0)
	for _, roleMenu := range systemRoleMenuList {
		menuIds = append(menuIds, roleMenu.MenuId)
	}

	// 获取用户菜单
	systemMenuList, err := s.GetMenusWithParents(ctx, userModel.AppPasture.Id, menuIds)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	// 获取菜单权限
	return &pasturePb.SystemUserMenuTreeResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.SystemMenuSlice(systemMenuList).ToTree(),
	}, nil
}

// ResetPasswordSystemUser 重置系统用户密码
func (s *StoreEntry) ResetPasswordSystemUser(ctx context.Context, req *pasturePb.ResetUserPasswordRequest) error {
	i18nTemplate, err := s.GetI18nTemplate(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	systemUser := &model.SystemUser{}
	if err = s.DB.Model(new(model.SystemUser)).
		Where("id = ?", req.Id).
		First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.noUser",
			})
			return xerr.Custom(messageId)
		}
		return xerr.WithStack(err)
	}

	if err = s.DB.Model(systemUser).
		Update("password", req.Password).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SystemUserRole(ctx context.Context, userId int64) (*pasturePb.SystemUserRoleResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUser := &model.SystemUser{Id: userId}
	if err = s.DB.Model(new(model.SystemUser)).
		Where("is_delete = ?", pasturePb.IsShow_Ok).
		First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.noUser",
			})
			return nil, xerr.Custom(messageId)
		}
		return nil, xerr.WithStack(err)
	}

	if systemUser.IsShow == pasturePb.IsShow_No {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userDisable",
		})
		return nil, xerr.Custom(messageId)
	}

	systemUserDepthRole := &model.SystemUserDepthRole{}
	if err = s.DB.Model(new(model.SystemUserDepthRole)).
		Where("user_id = ?", systemUser.Id).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		First(systemUserDepthRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.userRoleNotExist",
			})
			return nil, xerr.Custom(messageId)
		}
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SystemUserRoleResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.UserRoleData{
			RoleIds: systemUserDepthRole.GetRoleIds(),
		},
	}, nil
}

func (s *StoreEntry) SystemUserRoleSave(ctx context.Context, req *pasturePb.SystemUserRoleRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	systemUser := &model.SystemUser{Id: int64(req.UserId)}
	if err = s.DB.Model(new(model.SystemUser)).
		First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.noUser",
			})
			return xerr.Custom(messageId)
		}
		return xerr.WithStack(err)
	}

	if systemUser.IsDelete == pasturePb.IsShow_No {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userDelete",
		})
		return xerr.Custom(messageId)
	}

	if systemUser.IsShow == pasturePb.IsShow_No {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userDisable",
		})
		return xerr.Custom(messageId)
	}

	systemRoleList := make([]*model.SystemRole, 0)
	if err = s.DB.Model(new(model.SystemRole)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("is_delete = ?", pasturePb.IsShow_Ok).
		Where("id IN ?", req.RoleIds).
		Find(&systemRoleList).Error; err != nil {
		return xerr.WithStack(err)
	}

	if len(systemRoleList) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.userRoleNotExist",
		})
		return xerr.Custom(messageId)
	}

	roleIdsStr := ""
	for _, systemRole := range systemRoleList {
		roleIdsStr += fmt.Sprintf("%d,", systemRole.Id)
	}

	if len(roleIdsStr) > 0 {
		roleIdsStr = strings.TrimRight(roleIdsStr, ",")
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		var systemUserDepthRoleCount int64
		if err = tx.Model(new(model.SystemUserDepthRole)).
			Where("user_id = ?", systemUser.Id).
			Where("pasture_id = ?", userModel.AppPasture.Id).
			Count(&systemUserDepthRoleCount).Error; err != nil {
			return xerr.WithStack(err)
		}

		if systemUserDepthRoleCount > 0 {
			if err = tx.Model(new(model.SystemUserDepthRole)).
				Where("user_id = ?", systemUser.Id).
				Where("pasture_id = ?", userModel.AppPasture.Id).
				Update("role_ids", roleIdsStr).Error; err != nil {
				return xerr.WithStack(err)
			}
		} else {

			newSystemUserDepthRole := model.NewSystemUserDepthRole(userModel.AppPasture.Id, systemUser.Id, "", roleIdsStr)
			if err = tx.Model(new(model.SystemUserDepthRole)).
				Create(newSystemUserDepthRole).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) GetMenusWithParents(ctx context.Context, pastureId int64, menuIds []int64) ([]*model.SystemMenu, error) {
	if len(menuIds) <= 0 {
		i18nTemplate, err := s.GetI18nTemplate(ctx)
		if err != nil {
			return nil, xerr.Customf("菜单id不能为空")
		}
		messageId, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.menuIdNotEmpty",
		})
		return nil, xerr.Customf(messageId)
	}

	menuIds = util.DeduplicateInt64(menuIds)
	userMenuList := make([]*model.SystemMenu, 0)
	if err := s.DB.Table(fmt.Sprintf("%s as a", new(model.SystemMenu).TableName())).
		Select("a.*").
		Joins("LEFT JOIN system_role_menu as b ON a.id = b.menu_id").
		Joins("LEFT JOIN system_pasture_menu as c ON a.id = c.menu_id").
		Where("a.id IN ?", menuIds).
		Where("c.pasture_id = ?", pastureId).
		Group("a.id").
		Find(&userMenuList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return userMenuList, nil
}