daShangDao_psiServer/controllers/employee.go

package controllers

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	"net/http"
	"psi/constant"
	"psi/models"
	systemReq "psi/models/request"
	systemRes "psi/models/response"
	"psi/service"
	"psi/utils"
)

type EmployeeApi struct{}

var employeeService = service.EmployeeService{}

// Login 登录
// @param type: 255-admin, 128-employee
func (r *EmployeeApi) Login(c *gin.Context) {
	userType := c.Param("type")

	var req systemReq.LoginRequest
	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "登录请求异常", "参数错误: "+err.Error(), c, err)
		return
	}

	response, err := employeeService.Login(req, userType, c)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "登录异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithDetailed(response, "登录成功", c)
}

// GetCurrentUser 获取当前用户信息
func (r *EmployeeApi) GetCurrentUser(c *gin.Context) {
	employee, exists := c.Get("employee")
	if !exists {
		systemRes.NoAuth("未登录", c)
		return
	}

	currentEmployee := employee.(models.Employee)

	employeeInfo, err := employeeService.GetCurrentUser(currentEmployee.ID)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "获取当前用户信息异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithDetailed(gin.H{
		"type":            "admin",
		"id":              employeeInfo.ID,
		"employee_id_str": employeeInfo.EmployeeIDStr,
		"username":        employeeInfo.Username,
		"name":            employeeInfo.Name,
		"role":            employeeInfo.Role,
		"points":          employeeInfo.Score,
		"status":          employeeInfo.Status,
	}, "获取成功", c)
}

// Logout 退出登录
func (r *EmployeeApi) Logout(c *gin.Context) {
	systemRes.OkWithMessage("退出成功", c)
}

// GetEmployeeList 员工列表
func (r *EmployeeApi) GetEmployeeList(c *gin.Context) {
	var req systemReq.GetEmployeeListRequest

	if err := c.ShouldBindQuery(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "员工列表请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	userInfo := utils.GetUserInfo(c)
	result, err := employeeService.GetEmployeeList(req, userInfo.ID, userInfo.AboutID)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "员工列表异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": result,
	})
}

// AddEmployee 添加员工/租户注册
func (r *EmployeeApi) AddEmployee(c *gin.Context) {
	var req systemReq.AddEmployeeRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "添加员工请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	result, err := employeeService.AddEmployee(req)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "添加员工异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "添加成功",
		"data":    result,
	})
}

// UpdatePasswordEmployee 修改员工密码
func (r *EmployeeApi) UpdatePasswordEmployee(c *gin.Context) {
	var req systemReq.UpdatePasswordEmployeeRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "修改员工密码请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	err := employeeService.UpdatePasswordEmployee(req)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "修改员工密码异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithMessage("修改成功", c)
}

// UpdateExpireTimeEmployee 修改员工过期时间
func (r *EmployeeApi) UpdateExpireTimeEmployee(c *gin.Context) {
	var req systemReq.UpdateExpireTimeEmployeeRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "修改员工过期时间请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	err := employeeService.UpdateExpireTimeEmployee(req)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "修改员工过期时间异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithMessage("修改成功", c)
}

// CheckExpireTimeEmployee 校验员工过期时间
func (r *EmployeeApi) CheckExpireTimeEmployee(c *gin.Context) {
	userInfo := utils.GetUserInfo(c)
	err := employeeService.CheckExpireTimeEmployee(userInfo.ID)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "校验员工过期时间异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithMessage("操作成功", c)
}

// CheckCodeEmployee 校验员工机械码
func (r *EmployeeApi) CheckCodeEmployee(c *gin.Context) {
	var req systemReq.CheckCodeEmployeeRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "校验员工机械码请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}
	code, err := employeeService.CheckCodeEmployee(req)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "校验员工机械码异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithDetailed(map[string]interface{}{
		"code": code,
	}, "查询成功", c)
}

// ClearCodeEmployee 清除员工机械码
func (r *EmployeeApi) ClearCodeEmployee(c *gin.Context) {
	var req systemReq.ClearCodeEmployeeRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "清除员工机械码请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	err := employeeService.ClearCodeEmployee(req)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "清除员工机械码异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithMessage("修改成功", c)
}

// GetLevelConfigList 获取员工等级配置列表
func (r *EmployeeApi) GetLevelConfigList(c *gin.Context) {
	levelStr := c.Query("level")

	var levelInt int8
	if levelStr != "" {
		fmt.Sscanf(levelStr, "%d", &levelInt)
	}

	result := service.GetLevelConfig(levelInt)
	if result == nil {
		systemRes.FailWithMessage("无效的等级配置", c)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": result,
	})
}

// SetEmployeeLevel 设置员工等级
func (r *EmployeeApi) SetEmployeeLevel(c *gin.Context) {
	var req systemReq.SetEmployeeLevelRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "设置员工等级请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}

	userInfo := utils.GetUserInfo(c)
	err := employeeService.SetEmployeeLevel(req, userInfo.ID, userInfo.Username)
	if err != nil {
		utils.ErrorLog(constant.LoggerChannelWork, logrus.Fields{
			"source":  "设置员工等级异常",
			"err_msg": err.Error(),
		})
		systemRes.FailWithMessage(err.Error(), c)
		return
	}

	systemRes.OkWithMessage("操作成功", c)
}

// GetEmployeeSettings 获取员工设置
func (r *EmployeeApi) GetEmployeeSettings(c *gin.Context) {
	var req systemReq.GetEmployeeSettingsRequest

	if err := c.ShouldBindQuery(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "获取员工设置请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}
	result := employeeService.GetEmployeeSettings(req)
	systemRes.OkWithDetailed(result, "查询成功", c)
}

// SaveEmployeeSettings 保存员工设置
func (r *EmployeeApi) SaveEmployeeSettings(c *gin.Context) {
	var req systemReq.SaveEmployeeSettingsRequest

	if err := c.ShouldBind(&req); err != nil {
		ValidAndFail(constant.LoggerChannelRequest, "保存员工设置请求参数异常", "参数错误: "+err.Error(), c, err)
		return
	}
	err := employeeService.SaveEmployeeSettings(req)
	if err != nil {
		utils.FailWithRequestLog(constant.LoggerChannelWork, "保存员工设置异常", err, c, req)
		return
	}

	systemRes.OkWithMessage("保存成功", c)
}