kpt-pasture/module/backend/system_service.go

package backend

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

	"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"
)

// Login 用户登录
func (s *StoreEntry) Login(ctx context.Context, req *pasturePb.SearchUserRequest) (*pasturePb.SystemUserResponse, error) {
	systemUser := &model.SystemUser{}
	if err := s.DB.Where("name = ?", req.Name).
		First(systemUser).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	if systemUser.Password != req.Password {
		return nil, xerr.Customf("密码错误，来自用户:%s", req.Name)
	}

	if systemUser.IsShow == pasturePb.IsShow_No {
		return nil, xerr.Customf("该账号已被禁用，请联系管理员")
	}

	if systemUser.IsDelete == pasturePb.IsShow_No {
		return nil, xerr.Customf("该账号已被删除，请联系管理员")
	}

	systemRole := &model.SystemRole{Id: systemUser.RoleId}
	if err := s.DB.Where("is_show = ? and is_delete = ?", pasturePb.IsShow_Ok, pasturePb.IsShow_Ok).
		First(systemRole).Error; err != nil {
		zaplog.Error("Login", zap.Any("systemRole", err))
	}

	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 == "" {
		return nil, xerr.Custom("获取token错误")
	}

	expires := time.Now().Local().Add(time.Duration(s.Cfg.JwtExpireTime) * time.Second).Format(util.LayoutTime)
	farmList, err := s.FindPastureList(ctx, systemUser.PastureIds)
	if err != nil || len(farmList) == 0 {
		return nil, xerr.Custom("牧场信息错误")
	}

	return &pasturePb.SystemUserResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SystemUserData{
			AccessToken:  token,
			Expires:      expires,
			RefreshToken: token,
			Username:     systemUser.Name,
			Roles:        []string{systemRole.Name},
			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)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

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

	if req.DeptId > 0 {
		pref.Where("dept_id = ?", req.DeptId)
	}

	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).Debug().Error; err != nil {
		return nil, xerr.WithStack(err)
	}

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

	deptList, err := s.SearchSystemDeptListByIds(ctx, []int64{})
	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),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) SystemUserList(ctx context.Context) ([]*model.SystemUser, error) {
	systemUserList := make([]*model.SystemUser, 0)
	if err := s.DB.Where("is_delete = ?", pasturePb.IsShow_Ok).
		Where("is_show = ? ", pasturePb.IsShow_Ok).
		Find(&systemUserList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return systemUserList, nil
}

// DeleteSystemUser 删除系统用户
func (s *StoreEntry) DeleteSystemUser(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)
	}

	if err := s.DB.Model(systemUser).Update("is_delete", operationPb.IsShow_NO).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 {
	systemUser := &model.SystemUser{}
	if req.Id > 0 {
		systemUser.Id = int64(req.Id)
		if err := s.DB.First(systemUser).Error; err != nil {
			return xerr.WithStack(err)
		}
		req.Password = systemUser.Password
	} else {
		if err := s.DB.Where("name = ?", req.Name).First(systemUser).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		} else if systemUser.Id > 0 {
			return xerr.Custom("该用户名称已经存在")
		}
	}

	if err := s.DB.Model(&model.SystemUser{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":      req.Name,
		"nick_name": req.NickName,
		"mobile":    req.Mobile,
		"gender":    req.Gender,
		"password":  req.Password,
		"dept_id":   req.DeptId,
		"remarks":   req.Remarks,
		"is_delete": operationPb.IsShow_OK,
		"is_show":   req.IsShow,
	}).FirstOrCreate(&model.SystemUser{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// ResetPasswordSystemUser 重置系统用户密码
func (s *StoreEntry) ResetPasswordSystemUser(ctx context.Context, req *pasturePb.ResetUserPasswordRequest) error {
	systemUser := &model.SystemUser{
		Id: int64(req.Id),
	}
	if err := s.DB.First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该用户不存在")
		}
		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) {
	systemUser := &model.SystemUser{Id: userId}
	if err := s.DB.First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Custom("该用户不存在")
		}
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SystemUserRoleResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: int32(systemUser.RoleId),
	}, nil
}

func (s *StoreEntry) SystemUserRoleSave(ctx context.Context, req *pasturePb.SystemUserRoleRequest) error {
	systemUser := &model.SystemUser{Id: int64(req.UserId)}
	if err := s.DB.First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该用户不存在")
		}
		return xerr.WithStack(err)
	}

	systemRole := &model.SystemRole{Id: int64(req.RoleId)}
	if err := s.DB.First(systemRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该角色不存在")
		}
		return xerr.WithStack(err)
	}
	if err := s.DB.Model(systemUser).Update("role_id", systemRole.Id).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// GetSystemUserMenu 返回系统用户相关菜单权限
func (s *StoreEntry) GetSystemUserMenu(ctx context.Context) (*pasturePb.SystemUserMenuTreeResponse, error) {
	// 根据用户token获取用户数据
	systemUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return nil, xerr.Custom("该用户数据不存在")
	}
	if systemUser.RoleId <= 0 {
		return nil, xerr.Custom("该用户没有角色")
	}
	// 获取用户角色数据
	systemRole := &model.SystemRole{}
	if err = s.DB.Where("id = ?", systemUser.RoleId).First(systemRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Custom("该用户角色不存在")
		}
		return nil, xerr.WithStack(err)
	}
	// 获取用户菜单
	systemMenuList := make([]*model.SystemMenu, 0)
	if err = s.DB.Table(fmt.Sprintf("%s as a", new(model.SystemRoleMenu).TableName())).
		Select("b.*").
		Joins("LEFT JOIN system_menu AS b ON a.menu_id = b.id").
		Where("a.role_id = ? and b.is_delete = ?", systemRole.Id, pasturePb.IsShow_Ok).
		Find(&systemMenuList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

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

// SystemRoleCreateOrUpdate 添加角色
func (s *StoreEntry) SystemRoleCreateOrUpdate(ctx context.Context, req *pasturePb.SearchRoleRequest) error {
	isShow := pasturePb.IsShow_Ok
	if req.Id > 0 {
		isShow = req.IsShow
	}

	if err := s.DB.Model(&model.SystemRole{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":      req.Name,
		"remarks":   req.Remarks,
		"is_delete": operationPb.IsShow_OK,
		"is_show":   isShow,
	}).FirstOrCreate(&model.SystemRole{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// DeleteSystemRole 删除系统角色
func (s *StoreEntry) DeleteSystemRole(ctx context.Context, roleId int64) error {
	systemRole := &model.SystemRole{
		Id: roleId,
	}
	if err := s.DB.First(systemRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该数据不存在")
		}
		return xerr.WithStack(err)
	}

	if err := s.DB.Model(systemRole).Update("is_delete", pasturePb.IsShow_No).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

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

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

// SearchSystemRoleList 查询系统角色
func (s *StoreEntry) SearchSystemRoleList(ctx context.Context, req *pasturePb.SearchRoleRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchRoleResponse, error) {
	systemRoleList := make([]*model.SystemRole, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.SystemRole)).Where("is_delete = ?", operationPb.IsShow_OK)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

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

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

	return &pasturePb.SearchRoleResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchRoleData{
			Page:     pagination.Page,
			Total:    int32(count),
			PageSize: pagination.PageSize,
			List:     model.SystemRoleSlice(systemRoleList).ToPB(),
		},
	}, nil
}

// SearchSystemRoleListByIds 根据id查询角色列表
func (s *StoreEntry) SearchSystemRoleListByIds(ctx context.Context, ids []int64) ([]*model.SystemRole, error) {
	systemRoleList := make([]*model.SystemRole, 0)
	if err := s.DB.Model(new(model.SystemRole)).
		Where("is_show = ?", operationPb.IsShow_OK).
		Find(&systemRoleList, ids).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return systemRoleList, nil
}

// GetRoleMenuList 查询系统角色对应的菜单数据
func (s *StoreEntry) GetRoleMenuList(ctx context.Context, roleId int64) (*pasturePb.SystemRoleMenuResponse, error) {
	systemRole := &model.SystemRole{
		Id: roleId,
	}
	if err := s.DB.First(systemRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Custom("该数据不存在")
		}
		return nil, xerr.WithStack(err)
	}

	if systemRole.IsDelete == pasturePb.IsShow_No {
		return nil, xerr.Custom("该数据已被删除")
	}

	menuList := make([]*model.SystemRoleMenu, 0)
	if err := s.DB.Where("role_id = ?", systemRole.Id).Find(&menuList).Error; err != nil {
		zaplog.Error("GetSystemRoleMenuList", zap.Any("Err", err))
	}
	return &pasturePb.SystemRoleMenuResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.SystemRoleMenuSlice(menuList).ToPB(),
	}, nil

}

// RoleMenuSave 保存系统角色对应的菜单数据
func (s *StoreEntry) RoleMenuSave(ctx context.Context, res *pasturePb.SystemRoleMenuRequest) error {
	if len(res.MenuIds) <= 0 {
		return xerr.Custom("请选择菜单")
	}
	systemRole := &model.SystemRole{
		Id: int64(res.RoleId),
	}

	if err := s.DB.First(systemRole).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该数据不存在")
		}
		return xerr.WithStack(err)
	}

	if err := s.DB.Transaction(func(tx *gorm.DB) error {
		if err := tx.Model(new(model.SystemRoleMenu)).Where("role_id = ?", systemRole.Id).Delete(&model.SystemRoleMenu{}).Error; err != nil {
			return xerr.WithStack(err)
		}
		for _, menuId := range res.MenuIds {
			if err := tx.Create(&model.SystemRoleMenu{
				RoleId: systemRole.Id,
				MenuId: int64(menuId),
			}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SystemRoleList(ctx context.Context) (*pasturePb.GetRoleListResponse, error) {
	systemRoleList := make([]*model.SystemRole, 0)
	if err := s.DB.Model(new(model.SystemRole)).
		Where("is_delete = ? and is_show = ?", pasturePb.IsShow_Ok, pasturePb.IsShow_Ok).
		Find(&systemRoleList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.GetRoleListResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.SystemRoleSlice(systemRoleList).ToPB(),
	}, nil
}

// CreateOrUpdateSystemMenu 添加或者更新系统菜单权限
func (s *StoreEntry) CreateOrUpdateSystemMenu(ctx context.Context, req *pasturePb.SearchMenuRequest) error {
	if req.Id > 0 {
		systemMenu := &model.SystemMenu{Id: int64(req.Id)}
		if err := s.DB.Model(&model.SystemMenu{}).First(systemMenu).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.SystemMenu{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":             req.Name,
		"path":             req.Path,
		"title":            req.Title,
		"menu_type":        req.MenuType,
		"parent_id":        req.ParentId,
		"frame_src":        req.FrameSrc,
		"frame_loading":    model.BooleanToIsShow(req.FrameLoading),
		"keepalive":        model.BooleanToIsShow(req.Keepalive),
		"hidden_tag":       model.BooleanToIsShow(req.HiddenTag),
		"show_link":        model.BooleanToIsShow(req.ShowLink),
		"show_parent":      model.BooleanToIsShow(req.ShowParent),
		"icon":             req.Icon,
		"component":        req.Component,
		"redirect":         req.Redirect,
		"auths":            req.Auths,
		"rank":             req.Rank,
		"extra_icon":       req.ExtraIcon,
		"enter_transition": req.EnterTransition,
		"leave_transition": req.LeaveTransition,
		"active_path":      req.ActivePath,
		"is_delete":        pasturePb.IsShow_Ok,
		"is_show":          pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.SystemMenu{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SystemMenuTree(ctx context.Context) (*pasturePb.SystemMenuTreeResponse, error) {
	systemMenuList := make([]*model.SystemMenu, 0)
	if err := s.DB.Model(new(model.SystemMenu)).Where("is_delete = ?", pasturePb.IsShow_Ok).
		Where("is_show = ?", pasturePb.IsShow_Ok).Find(&systemMenuList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return &pasturePb.SystemMenuTreeResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.SystemMenuSlice(systemMenuList).ToPB(),
	}, nil
}

// SearchSystemMenuList 菜单列表查询
func (s *StoreEntry) SearchSystemMenuList(ctx context.Context, req *pasturePb.SearchMenuRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchMenuResponse, error) {
	systemMenuList := make([]*model.SystemMenu, 0)
	var count int64 = 0

	if err := s.DB.Model(new(model.SystemMenu)).
		Where("is_delete = ? ", operationPb.IsShow_OK).
		Order("parent_id").Count(&count).
		Find(&systemMenuList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchMenuResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchMenuData{
			Page:     pagination.Page,
			Total:    int32(count),
			PageSize: pagination.PageSize,
			List:     model.SystemMenuSlice(systemMenuList).ToPB(),
		},
	}, nil
}

// DeleteSystemMenu 删除系统菜单
func (s *StoreEntry) DeleteSystemMenu(ctx context.Context, menuId int64) error {
	systemMenu := &model.SystemMenu{Id: menuId}
	if err := s.DB.First(systemMenu).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该数据不存在")
		}
		return xerr.WithStack(err)
	}

	if err := s.DB.Model(systemMenu).Update("is_delete", pasturePb.IsShow_No).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchSystemDeptList(ctx context.Context, req *pasturePb.SearchDeptRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchDeptResponse, error) {
	deptList := make([]*model.SystemDept, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.SystemDept)).Where("is_delete = ?", operationPb.IsShow_OK)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

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

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

	systemUserList, _ := s.SystemUserList(ctx)

	return &pasturePb.SearchDeptResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.SystemDeptSlice(deptList).ToPB(systemUserList),
	}, nil
}

func (s *StoreEntry) SystemDepDelete(ctx context.Context, id int64) error {
	dept := &model.SystemDept{Id: id}
	if err := s.DB.First(dept).Error; err != nil {
		return xerr.WithStack(err)
	}

	if dept.IsShow == pasturePb.IsShow_No {
		return nil
	}
	if err := s.DB.Model(dept).Update("is_delete", operationPb.IsShow_NO).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SystemDeptCreateOrUpdate(ctx context.Context, req *pasturePb.SearchDeptRequest) error {
	if req.Id > 0 {
		barn := &model.SystemDept{Id: int64(req.Id)}
		if err := s.DB.Model(&model.SystemDept{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}
	if err := s.DB.Model(&model.SystemDept{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":      req.Name,
		"sort":      req.Sort,
		"parent_id": req.ParentId,
		"remarks":   req.Remarks,
		"is_delete": operationPb.IsShow_OK,
		"is_show":   req.IsShow,
		"dept_type": pasturePb.Depth_Department,
		"leader_id": req.LeaderId,
	}).FirstOrCreate(&model.SystemDept{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchUserPastureList(ctx context.Context) (*pasturePb.SystemUserPastureListResponse, error) {
	currentUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

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

	return &pasturePb.SystemUserPastureListResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.AppPastureListSlice(farmList).ToPB(),
	}, err
}