2990 lines
73 KiB
Go
2990 lines
73 KiB
Go
package account
|
||
|
||
import (
|
||
"context"
|
||
"dubbo.apache.org/dubbo-go/v3/common/logger"
|
||
"encoding/base64"
|
||
"errors"
|
||
"fmt"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/account"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/department"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/e_card"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/employee"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/position"
|
||
"github.com/fonchain_enterprise/fonchain-main/api/rule"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/config"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/e"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/dto"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/query"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/request"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/union"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo/turnstile"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/service"
|
||
"github.com/fonchain_enterprise/fonchain-main/pkg/utils/secret"
|
||
"github.com/fonchain_enterprise/utils/objstorage"
|
||
"github.com/fonchain_enterprise/utils/utils"
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/gin-gonic/gin/binding"
|
||
uuid "github.com/satori/go.uuid"
|
||
"net/http"
|
||
"net/url"
|
||
"strconv"
|
||
"time"
|
||
)
|
||
|
||
// UserRegister 用户注册操作
|
||
func UserRegister(c *gin.Context) {
|
||
var req union.User
|
||
var res *account.RequestStatus
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err, res := UserRegisters(c, req)
|
||
if err != nil && err.Error() == "账号已存在" && req.Source == "exam" {
|
||
handleExistingAccountForExam(c, req)
|
||
service.Success(c, &res)
|
||
return
|
||
}
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
func handleExistingAccountForExam(c *gin.Context, req union.User) {
|
||
var Tel account.UsersByTelRequest
|
||
var res account.RequestStatus
|
||
// 初始化 Tels 切片
|
||
Tel.Tels = make([]string, 1)
|
||
// 赋值
|
||
Tel.Tels[0] = req.TelNum
|
||
|
||
// 查询用户信息
|
||
telRes, _ := service.AccountProvider.UsersByTel(c, &Tel)
|
||
|
||
// 更新 res 对象
|
||
res.ID = telRes.Data[0].ID
|
||
res.Status = "success"
|
||
|
||
// 返回成功响应
|
||
service.Success(c, &res)
|
||
return
|
||
}
|
||
|
||
func UserRegisters(c *gin.Context, req union.User) (err error, res *account.RequestStatus) {
|
||
if req.Avatar == "" {
|
||
req.Avatar = "https://dci-file-new.bj.bcebos.com/fonchain-main/test/runtime/image/avatar/40/b8ed6fea-6662-416d-8bb3-1fd8a8197061.jpg"
|
||
}
|
||
if req.Source == "exam" {
|
||
req.PositionUsers = []*position.PositionUser{
|
||
{
|
||
DepartmentName: "考试管理",
|
||
PositionName: "学员",
|
||
},
|
||
}
|
||
req.Password = e.DEFAULT_PWD
|
||
}
|
||
//账号服务
|
||
registRequest := account.RegistRequest{
|
||
Domain: req.Domain,
|
||
NickName: req.NickName,
|
||
TelNum: req.TelNum,
|
||
Password: req.Password,
|
||
JobNum: req.JobNum,
|
||
Status: req.Status,
|
||
Avatar: req.Avatar,
|
||
EnterDate: req.EnterDate,
|
||
Extend: &account.Extend{JumpTo: req.JumpTo},
|
||
RecentImg: req.RecentImg,
|
||
Source: req.Source,
|
||
}
|
||
|
||
if req.Operator != nil {
|
||
registRequest.Operator = req.Operator
|
||
}
|
||
|
||
res, err = service.AccountProvider.Register(c, ®istRequest)
|
||
if err != nil {
|
||
return err, res
|
||
}
|
||
if len(req.PositionUsers) <= 0 {
|
||
return nil, res
|
||
}
|
||
//岗位服务 绑定岗位
|
||
positionReq := &position.BindUserRequest{
|
||
Domain: req.Domain,
|
||
UserID: res.ID,
|
||
UserName: req.NickName,
|
||
Avatar: req.Avatar,
|
||
PositionUsers: req.PositionUsers,
|
||
}
|
||
var err1 error // 声明 err1 变量
|
||
if len(req.PositionUsers) > 0 && req.PositionUsers[0].DepartmentName != "" && req.PositionUsers[0].PositionName != "" {
|
||
_, err1 = service.PositionProvider.BindUserForName(c, positionReq)
|
||
} else {
|
||
_, err1 = service.PositionProvider.BindUser(c, positionReq)
|
||
}
|
||
|
||
if err1 != nil {
|
||
return err1, res
|
||
}
|
||
return err, res
|
||
}
|
||
|
||
// RefreshToken token
|
||
func RefreshToken(c *gin.Context) {
|
||
|
||
var jumpToWhere = "setting"
|
||
var isDriverAuth = false
|
||
var isDriverSupervisorAuth = false
|
||
|
||
var req account.RefreshTokenRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
req.Ip = c.ClientIP()
|
||
|
||
res, err := service.AccountProvider.RefreshToken(context.Background(), &req)
|
||
|
||
if err != nil {
|
||
c.JSON(e.Success, serializer.Response{
|
||
Code: 201,
|
||
Status: 1,
|
||
Msg: err.Error(),
|
||
Data: nil,
|
||
})
|
||
c.Abort()
|
||
return
|
||
}
|
||
|
||
//获取用户的岗位信息
|
||
uReq := rule.RulesRequest{
|
||
AccountID: res.AccountInfo.ID,
|
||
}
|
||
|
||
qres, err1 := service.RuleProvider.UserInfo(c, &uReq)
|
||
|
||
if err1 != nil {
|
||
service.Error(c, e.Error, err1)
|
||
return
|
||
}
|
||
|
||
if len(qres.PositionUsers) >= 1 {
|
||
isDriverAuth = isHaveDriverAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
|
||
isDriverSupervisorAuth = isHaveDriverSupervisorAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
|
||
}
|
||
|
||
accountInfo := &union.AccountInfo{
|
||
ID: res.AccountInfo.ID,
|
||
Account: res.AccountInfo.Account,
|
||
NickName: res.AccountInfo.NickName,
|
||
Domain: res.AccountInfo.Domain,
|
||
TelNum: res.AccountInfo.TelNum,
|
||
Status: res.AccountInfo.Status,
|
||
Avatar: res.AccountInfo.Avatar,
|
||
CreatedAt: res.AccountInfo.CreateAt,
|
||
IsNeedChange: res.AccountInfo.IsNeedChange,
|
||
EnterDate: res.AccountInfo.EnterDate,
|
||
WorkYear: res.AccountInfo.WorkYear,
|
||
IsAdmin: qres.IsAdmin,
|
||
PositionUsers: qres.PositionUsers,
|
||
JumpTo: res.AccountInfo.Extend.JumpTo,
|
||
DepartmentName: "",
|
||
JobNum: res.AccountInfo.JobNum,
|
||
BirthDate: res.AccountInfo.BirthDate,
|
||
Age: res.AccountInfo.Age,
|
||
Sex: res.AccountInfo.Sex,
|
||
Title: res.AccountInfo.Title,
|
||
IDNum: res.AccountInfo.IDNum,
|
||
DriverAuth: isDriverAuth,
|
||
DriverSupervisorAuth: isDriverSupervisorAuth,
|
||
}
|
||
|
||
code := "xxx"
|
||
if len(qres.PositionUsers) >= 1 {
|
||
accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
|
||
code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
|
||
}
|
||
|
||
token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
ruleUrlReq := rule.FindRuleByUrlRequest{
|
||
AccountID: accountInfo.ID,
|
||
Type: "menu",
|
||
Domain: accountInfo.Domain,
|
||
Url: "/home",
|
||
Method: "*",
|
||
}
|
||
|
||
ruleInfo, ruleErr := service.RuleProvider.FindUserRule(c, &ruleUrlReq)
|
||
if ruleInfo.IsPass == true {
|
||
jumpToWhere = "home"
|
||
}
|
||
|
||
if ruleErr != nil {
|
||
service.Error(c, e.Error, ruleErr)
|
||
return
|
||
}
|
||
|
||
resInfo := &union.Login{
|
||
Token: token,
|
||
RefreshToken: res.RefreshToken,
|
||
AccountInfo: accountInfo,
|
||
JumpToWhere: jumpToWhere,
|
||
}
|
||
|
||
service.Success(c, resInfo)
|
||
|
||
return
|
||
}
|
||
|
||
// Offline 下线
|
||
func Offline(c *gin.Context) {
|
||
|
||
intStr := c.DefaultQuery("id", "0")
|
||
|
||
intNum, err := strconv.Atoi(intStr)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
req := account.CommonRequest{
|
||
ID: uint64(intNum),
|
||
}
|
||
|
||
res, err := service.AccountProvider.OffLine(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// OnlineInfoById 获取登陆信息
|
||
func OnlineInfoById(c *gin.Context) {
|
||
|
||
intStr := c.DefaultQuery("id", "0")
|
||
|
||
id, err := strconv.Atoi(intStr)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
req := account.OnlineLogByIdRequest{
|
||
ID: uint64(id),
|
||
}
|
||
|
||
res, err := service.AccountProvider.OnlineLogById(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// OnlineInfos 用户登录操作
|
||
func OnlineInfos(c *gin.Context) {
|
||
|
||
intStr := c.DefaultQuery("UserId", "0")
|
||
|
||
id, err := strconv.Atoi(intStr)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
req := account.LoginInfosByUserIdRequest{
|
||
UserId: uint64(id),
|
||
}
|
||
|
||
res, err := service.AccountProvider.OnlineLog(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// SendMsg 用户登录操作
|
||
func SendMsg(c *gin.Context) {
|
||
|
||
var req account.SendMsgRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
req.SignNo = uint32(config.DefaultSignNo)
|
||
res, err := service.AccountProvider.SendMsg(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// CheckMsg 验证码是否正确
|
||
func CheckMsg(c *gin.Context) {
|
||
|
||
var req account.CheckMsgRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
res, err := service.AccountProvider.CheckMsg(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
func UserLogout(c *gin.Context) {
|
||
req := account.DecryptJwtRequest{}
|
||
|
||
//获取jwt
|
||
authorization := c.GetHeader(e.Authorization)
|
||
if authorization == "" {
|
||
service.Error(c, e.Error, errors.New("请求数据为空，请直接重新登录"))
|
||
return
|
||
}
|
||
|
||
jwt, err := secret.GetJwtFromStr(authorization)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err, "解析秘钥失败")
|
||
return
|
||
}
|
||
|
||
req.Token = jwt
|
||
|
||
//退出登陆
|
||
res, err := service.AccountProvider.Logout(context.Background(), &req)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// UserLogin 用户登录操作
|
||
func UserLogin(c *gin.Context) {
|
||
|
||
var jumpToWhere = "setting"
|
||
var isDriverAuth = false
|
||
var isDriverSupervisorAuth = false
|
||
|
||
var req account.LoginRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
req.Ip = c.ClientIP()
|
||
|
||
res, err := service.AccountProvider.Login(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
//获取用户的岗位信息
|
||
uReq := rule.RulesRequest{
|
||
AccountID: res.AccountInfo.ID,
|
||
}
|
||
|
||
qres, err1 := service.RuleProvider.UserInfo(c, &uReq)
|
||
|
||
if err1 != nil {
|
||
service.Error(c, e.Error, err1)
|
||
return
|
||
}
|
||
|
||
if len(qres.PositionUsers) >= 1 {
|
||
isDriverAuth = isHaveDriverAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
|
||
isDriverSupervisorAuth = isHaveDriverSupervisorAuth(c, res.AccountInfo.ID, qres.PositionUsers[0].DepartmentId)
|
||
}
|
||
|
||
accountInfo := &union.AccountInfo{
|
||
ID: res.AccountInfo.ID,
|
||
Account: res.AccountInfo.Account,
|
||
NickName: res.AccountInfo.NickName,
|
||
Domain: res.AccountInfo.Domain,
|
||
TelNum: res.AccountInfo.TelNum,
|
||
Status: res.AccountInfo.Status,
|
||
Avatar: res.AccountInfo.Avatar,
|
||
CreatedAt: res.AccountInfo.CreateAt,
|
||
IsNeedChange: res.AccountInfo.IsNeedChange,
|
||
EnterDate: res.AccountInfo.EnterDate,
|
||
WorkYear: res.AccountInfo.WorkYear,
|
||
IsAdmin: qres.IsAdmin,
|
||
PositionUsers: qres.PositionUsers,
|
||
JumpTo: res.AccountInfo.Extend.JumpTo,
|
||
DepartmentName: "",
|
||
JobNum: res.AccountInfo.JobNum,
|
||
BirthDate: res.AccountInfo.BirthDate,
|
||
Age: res.AccountInfo.Age,
|
||
Sex: res.AccountInfo.Sex,
|
||
Title: res.AccountInfo.Title,
|
||
IDNum: res.AccountInfo.IDNum,
|
||
DriverAuth: isDriverAuth,
|
||
DriverSupervisorAuth: isDriverSupervisorAuth,
|
||
MailAccount: res.AccountInfo.MailAccount,
|
||
Train: res.AccountInfo.Train,
|
||
Certificate: res.AccountInfo.Certificate,
|
||
TrainVideos: res.AccountInfo.TrainVideos,
|
||
}
|
||
|
||
code := "xxx"
|
||
if len(qres.PositionUsers) >= 1 {
|
||
accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
|
||
code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
|
||
}
|
||
|
||
token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
ruleUrlReq := rule.FindRuleByUrlRequest{
|
||
AccountID: accountInfo.ID,
|
||
Type: "menu",
|
||
Domain: accountInfo.Domain,
|
||
Url: "/home",
|
||
Method: "*",
|
||
}
|
||
|
||
ruleInfo, ruleErr := service.RuleProvider.FindUserRule(c, &ruleUrlReq)
|
||
if ruleInfo.IsPass == true {
|
||
jumpToWhere = "home"
|
||
}
|
||
|
||
if ruleErr != nil {
|
||
service.Error(c, e.Error, ruleErr)
|
||
return
|
||
}
|
||
|
||
resInfo := &union.Login{
|
||
Token: token,
|
||
RefreshToken: res.RefreshToken,
|
||
AccountInfo: accountInfo,
|
||
JumpToWhere: jumpToWhere,
|
||
}
|
||
|
||
fmt.Println("是否相同：", res.IsSampleAddress, res.AccountInfo.NowLogId)
|
||
if res.IsSampleAddress == false && res.AccountInfo.NowLogId != 0 { //登陆地址异常
|
||
|
||
url := fmt.Sprintf("https://erpapi.fontree.cn/off7524164487E?id=%d", res.AccountInfo.NowLogId)
|
||
shortUrl, err := utils.CreateShortUrl(url)
|
||
if err == nil {
|
||
url = shortUrl
|
||
}
|
||
|
||
msgReq := account.SendCustomMsgRequest{
|
||
ID: res.AccountInfo.ID,
|
||
TelNum: res.AccountInfo.TelNum,
|
||
MId: 134802,
|
||
SigNo: uint32(config.DefaultSignNo),
|
||
}
|
||
|
||
msgReq.Url = res.NowAddress + "|" + url
|
||
fmt.Println("发送短信", msgReq)
|
||
service.AccountProvider.SendCustomMsg(c, &msgReq)
|
||
|
||
}
|
||
|
||
service.Success(c, resInfo)
|
||
|
||
return
|
||
}
|
||
|
||
// Authentication 用户实名认证操作
|
||
func Authentication(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.AuthenticationRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
authorization := c.GetHeader(e.Authorization)
|
||
jwt, err := secret.GetJwtFromStr(authorization)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err, "解析秘钥失败")
|
||
return
|
||
}
|
||
|
||
req.Token = jwt
|
||
|
||
res, err := service.AccountProvider.Authentication(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
func List(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.ListRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
res, err := service.AccountProvider.List(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
//查询部门
|
||
puRequest := &rule.PositionUserListRequest{}
|
||
puRes, err := service.RuleProvider.PositionUserList(c, puRequest)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
if len(puRes.Data) > 0 {
|
||
for index, t := range res.Data {
|
||
|
||
var departments []*account.Department
|
||
var positions []*account.PositionUser
|
||
md := make(map[uint64]bool)
|
||
mp := make(map[uint64]bool)
|
||
|
||
for _, tt := range puRes.Data {
|
||
if tt.UserId == t.ID {
|
||
if _, ok := md[tt.DepartmentId]; !ok {
|
||
temp := &account.Department{
|
||
ID: tt.DepartmentId,
|
||
Name: tt.DepartmentName,
|
||
}
|
||
departments = append(departments, temp)
|
||
md[tt.DepartmentId] = true
|
||
}
|
||
if _, ok := mp[tt.PositionID]; !ok {
|
||
temp := &account.PositionUser{
|
||
PositionID: tt.PositionID,
|
||
PositionName: tt.PositionName,
|
||
}
|
||
positions = append(positions, temp)
|
||
md[tt.PositionID] = true
|
||
}
|
||
}
|
||
}
|
||
|
||
res.Data[index].Departments = departments
|
||
res.Data[index].Positions = positions
|
||
}
|
||
}
|
||
|
||
/* ES 操作 */
|
||
//go es.BulkIndexAccountInfo(es.OaIndex)
|
||
/* ES 操作 */
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// PrivacyInfo 获取私密信息
|
||
func PrivacyInfo(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.PrivacyInfoRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
res, err := service.AccountProvider.PrivacyInfo(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// Remove 用户删除
|
||
func Remove(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.RemoveRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
res, err := service.AccountProvider.Remove(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
//岗位删除
|
||
positionReq := &position.RemoveUserRequest{
|
||
Domain: req.Domain,
|
||
ID: req.ID,
|
||
}
|
||
|
||
_, err1 := service.PositionProvider.RemoveUser(c, positionReq)
|
||
if err1 != nil {
|
||
service.Error(c, e.Error, err1)
|
||
return
|
||
}
|
||
|
||
//部门删除
|
||
DepartmentReq := &department.RemoveUserRequest{
|
||
Domain: req.Domain,
|
||
LeaderID: req.ID,
|
||
}
|
||
|
||
_, err2 := service.DepartmentProvider.RemoveUser(c, DepartmentReq)
|
||
if err2 != nil {
|
||
service.Error(c, e.Error, err2)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// BaseInfo 用户信息
|
||
func BaseInfo(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.InfoRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
res, err := service.AccountProvider.Info(context.Background(), &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
func NowInfo(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
userInfo := login.GetUserInfoFromC(c)
|
||
|
||
user, err := GetUserInfoById(c, userInfo.ID, userInfo.Domain)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, user)
|
||
return
|
||
}
|
||
|
||
func Info(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req account.InfoRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
user, err := GetUserInfoById(c, req.ID, req.Domain)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, user)
|
||
return
|
||
}
|
||
|
||
// Update 用户更新信息
|
||
func Update(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req union.User
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
//账号服务
|
||
var updateReq = account.UpdateRequest{
|
||
ID: req.ID,
|
||
Domain: req.Domain,
|
||
NickName: req.NickName,
|
||
Password: req.Password,
|
||
TelNum: req.TelNum,
|
||
Avatar: req.Avatar,
|
||
Status: req.Status,
|
||
EnterDate: req.EnterDate,
|
||
JobNum: req.JobNum,
|
||
BirthDate: req.BirthDate,
|
||
Sex: req.Sex,
|
||
Title: req.Title,
|
||
LeftDate: req.LeftDate,
|
||
Remark: req.Remark,
|
||
RecentImg: req.RecentImg,
|
||
ICNum: req.ICNum,
|
||
Extend: req.Extend,
|
||
Train: req.Train,
|
||
Certificate: req.Certificate,
|
||
Operator: &account.Operator{
|
||
ID: 0,
|
||
Name: "人员管理",
|
||
},
|
||
}
|
||
|
||
if req.JumpTo != "" {
|
||
if updateReq.Extend == nil {
|
||
updateReq.Extend = &account.Extend{}
|
||
}
|
||
updateReq.Extend.JumpTo = req.JumpTo
|
||
}
|
||
|
||
user, err := GetUserInfoById(c, req.ID, req.Domain)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
_, err = service.AccountProvider.Update(context.Background(), &updateReq)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
//必须替换岗位
|
||
if req.PositionUsers != nil && len(req.PositionUsers) > 0 {
|
||
positionReq := &position.BindUserRequest{
|
||
Domain: req.Domain,
|
||
UserID: req.ID,
|
||
UserName: req.NickName,
|
||
Avatar: req.Avatar,
|
||
PositionUsers: req.PositionUsers,
|
||
}
|
||
|
||
_, err1 := service.PositionProvider.BindUser(c, positionReq)
|
||
if err1 != nil {
|
||
service.Error(c, e.Error, err1)
|
||
return
|
||
}
|
||
}
|
||
if req.RecentImg != "" && req.RecentImg != user.RecentImg {
|
||
_, _ = service.GrpcEmployeeProvider.UpdateEmployeeFile(c, &employee.UpdateEmployeeFileRequest{
|
||
UserId: user.ID,
|
||
RecentImg: req.RecentImg,
|
||
})
|
||
}
|
||
if req.RecentImg != "" && len(user.Clocks) > 0 && (req.RecentImg != user.RecentImg || req.NickName !=
|
||
user.NickName || req.TelNum != user.TelNum || req.ICNum != user.ICNum) {
|
||
if req.ICNum == "" {
|
||
req.ICNum = user.ICNum
|
||
}
|
||
if req.NickName == "" {
|
||
req.NickName = user.NickName
|
||
}
|
||
if req.TelNum == "" {
|
||
req.TelNum = user.TelNum
|
||
}
|
||
var dataSet []turnstile.DeviceUserData
|
||
var userId account.ClockUserDeviceBatch
|
||
deviceNums := make(map[string]string)
|
||
for _, i := range user.Clocks {
|
||
data := turnstile.DeviceUserData{
|
||
JobNum: user.ID,
|
||
RecentImg: req.RecentImg,
|
||
DeviceNum: i.Device.DeviceNum,
|
||
NickName: req.NickName,
|
||
Phone: req.TelNum,
|
||
DeviceName: i.Device.DeviceName,
|
||
IcNum: req.ICNum,
|
||
}
|
||
dataSet = append(dataSet, data)
|
||
}
|
||
for _, i := range user.Clocks {
|
||
deviceNums[i.Device.DeviceNum] = i.Device.DeviceName
|
||
}
|
||
//判断设备是否离线
|
||
oline := CheckDeviceIsOnline(deviceNums)
|
||
if oline != "" {
|
||
//service.Error(c, e.Error, errors.New(oline))
|
||
//return
|
||
}
|
||
//并发下发数据
|
||
err = ConcurrentUpdateDeviceUser(c, dataSet, 10)
|
||
if err != nil {
|
||
//service.Error(c, e.Error, err)
|
||
//return
|
||
}
|
||
//更新绑定关系
|
||
userId.UserId = user.ID
|
||
_, err = service.AccountProvider.UpdateDeviceRelevance(c, &userId)
|
||
if err != nil {
|
||
//service.Error(c, e.Error, err)
|
||
//return
|
||
}
|
||
}
|
||
service.Success(c, user)
|
||
return
|
||
}
|
||
|
||
// MallRandList 获取商城随机用户
|
||
func MallRandList(c *gin.Context) {
|
||
//创建一个UserLoginService对象
|
||
var req query.UserNumSearchQuery
|
||
res := vo.UserListResponse{}
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
|
||
//账号服务
|
||
var updateReq = account.ListRequest{
|
||
Domain: "mall",
|
||
PageSize: req.Num,
|
||
}
|
||
|
||
if req.UserId != 0 {
|
||
updateReq.PageSize = 1
|
||
res.Count = 1
|
||
res.UserIds = []uint64{req.UserId}
|
||
ures, _ := service.AccountProvider.RandList(context.Background(), &updateReq)
|
||
res.DomainCount = ures.AllCount
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
ures, err := service.AccountProvider.RandList(context.Background(), &updateReq)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
res.Count = ures.Count
|
||
var tempIds []uint64
|
||
for _, v := range ures.Data {
|
||
tempIds = append(tempIds, v.ID)
|
||
}
|
||
res.UserIds = tempIds
|
||
res.DomainCount = ures.AllCount
|
||
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
func GetUserInfoById(c *gin.Context, ID uint64, domain string) (union.UserResponse, error) {
|
||
info := union.UserResponse{}
|
||
var driverAuth = false
|
||
var driverSupervisorAuth = false
|
||
|
||
req := account.InfoRequest{
|
||
ID: ID,
|
||
}
|
||
if domain != "" {
|
||
req.Domain = domain
|
||
}
|
||
|
||
res, err := service.AccountProvider.Info(c, &req)
|
||
if err != nil {
|
||
return info, err
|
||
}
|
||
|
||
//获取用户的岗位信息
|
||
uReq := rule.RulesRequest{
|
||
AccountID: req.ID,
|
||
}
|
||
|
||
qres, err1 := service.RuleProvider.UserInfo(c, &uReq)
|
||
|
||
if err1 != nil {
|
||
return info, err1
|
||
}
|
||
|
||
if len(qres.PositionUsers) >= 1 {
|
||
driverAuth = isHaveDriverAuth(c, ID, qres.PositionUsers[0].DepartmentId)
|
||
driverSupervisorAuth = isHaveDriverSupervisorAuth(c, ID, qres.PositionUsers[0].DepartmentId)
|
||
}
|
||
|
||
fReq := position.FindRuleByUserIdRequest{
|
||
UserId: ID,
|
||
Urls: []string{e.AuthFinanceKey, e.AuthTrainingKey, e.AuthPublicizeKey, e.AuthWarehouseKey},
|
||
}
|
||
|
||
fRes, err1 := service.PositionProvider.FindRuleByUserId(c, &fReq)
|
||
|
||
info = union.UserResponse{
|
||
ID: res.Info.ID,
|
||
NickName: res.Info.NickName,
|
||
TelNum: res.Info.TelNum,
|
||
Avatar: res.Info.Avatar,
|
||
Status: res.Info.Status,
|
||
CreateAt: res.Info.CreateAt,
|
||
IsAdmin: qres.IsAdmin,
|
||
RealNameID: res.Info.RealNameID,
|
||
RealName: res.Info.RealName,
|
||
PositionUsers: qres.PositionUsers,
|
||
DepartmentLeaders: qres.DepartmentLeaders,
|
||
IsNeedChange: res.Info.IsNeedChange,
|
||
WorkYear: res.Info.WorkYear,
|
||
EnterDate: res.Info.EnterDate,
|
||
Extend: res.Info.Extend,
|
||
DepartmentName: "",
|
||
JumpTo: "",
|
||
JobNum: res.Info.JobNum,
|
||
BirthDate: res.Info.BirthDate,
|
||
Sex: res.Info.Sex,
|
||
Title: res.Info.Title,
|
||
Age: res.Info.Age,
|
||
IDNum: res.Info.IDNum,
|
||
LeftDate: res.Info.LeftDate,
|
||
DriverAuth: driverAuth,
|
||
DriverSupervisorAuth: driverSupervisorAuth,
|
||
Remark: res.Info.Remark,
|
||
RecentImg: res.Info.RecentImg,
|
||
Clocks: res.Info.Clocks,
|
||
MailAccount: res.Info.MailAccount,
|
||
ICNum: res.Info.ICNum,
|
||
Train: res.Info.Train,
|
||
Certificate: res.Info.Certificate,
|
||
TrainVideos: res.Info.TrainVideos,
|
||
}
|
||
|
||
if res.Info.Extend != nil {
|
||
info.JumpTo = res.Info.Extend.JumpTo
|
||
}
|
||
|
||
if len(qres.PositionUsers) >= 1 {
|
||
info.DepartmentName = qres.PositionUsers[0].DepartmentName
|
||
}
|
||
|
||
if len(fRes.Rules) >= 1 {
|
||
info.IdentityKey = fRes.Rules[0].Url
|
||
}
|
||
|
||
return info, nil
|
||
}
|
||
|
||
func isHaveDriverAuth(c *gin.Context, ID uint64, DepartmentID uint64) bool {
|
||
isLeader := false
|
||
|
||
req := position.DoIHavaAuthRequest{
|
||
UserId: ID,
|
||
Url: e.AuthDriveKey,
|
||
DepartmentID: DepartmentID,
|
||
}
|
||
|
||
res, err := service.PositionProvider.DoIHavaAuth(c, &req)
|
||
|
||
if err == nil && res.Hava == true {
|
||
isLeader = true
|
||
}
|
||
|
||
return isLeader
|
||
}
|
||
|
||
func isHaveDriverSupervisorAuth(c *gin.Context, ID uint64, DepartmentID uint64) bool {
|
||
isLeader := false
|
||
|
||
req := position.DoIHavaAuthRequest{
|
||
UserId: ID,
|
||
Url: e.AuthDriveSupervisorKey,
|
||
DepartmentID: DepartmentID,
|
||
}
|
||
|
||
res, err := service.PositionProvider.DoIHavaAuth(c, &req)
|
||
|
||
if err == nil && res.Hava == true {
|
||
isLeader = true
|
||
}
|
||
|
||
return isLeader
|
||
}
|
||
|
||
func MailAccount(c *gin.Context) {
|
||
var req query.UserRequest
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.ResponseMsg(c, e.SUCCESS, serializer.Response{
|
||
Msg: err.Error(),
|
||
Status: e.Failed,
|
||
})
|
||
return
|
||
}
|
||
|
||
mailReq := &account.MailAccountByNickNameRequest{NickName: req.NickName, ID: req.ID}
|
||
|
||
mailRes, err := service.AccountProvider.MailAccountByNickName(c, mailReq)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, mailRes)
|
||
return
|
||
}
|
||
|
||
func DepartmentLeaderList(c *gin.Context) {
|
||
var req dto.DepartmentListReq
|
||
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.ResponseMsg(c, e.SUCCESS, serializer.Response{
|
||
Msg: err.Error(),
|
||
Status: e.Failed,
|
||
})
|
||
return
|
||
}
|
||
|
||
findByUrlRequest := rule.FindByUrlRequest{
|
||
Url: e.DepartmentKey,
|
||
DepartmentIds: req.DepartmentIds,
|
||
}
|
||
|
||
fmt.Println("=============================== FindByUrlRequest ==================================")
|
||
fmt.Printf("findByUrlRequest : %+v\n", findByUrlRequest)
|
||
|
||
res, err := service.RuleProvider.FindUsersByUrl(c, &findByUrlRequest)
|
||
|
||
DepartmentListRes := new(dto.DepartmentListRes)
|
||
DepartmentListRes.DepartmentLeaders = make([]dto.DepartmentLeader, 0)
|
||
|
||
if err == nil && len(res.List) > 0 {
|
||
for _, tt := range res.List {
|
||
leader := dto.DepartmentLeader{
|
||
UserID: tt.UserId,
|
||
UserName: tt.UserName,
|
||
}
|
||
DepartmentListRes.DepartmentLeaders = append(DepartmentListRes.DepartmentLeaders, leader)
|
||
fmt.Println("=============================== FindByUrlResponse ==================================")
|
||
fmt.Printf("leader : %+v\n", leader)
|
||
|
||
}
|
||
}
|
||
|
||
service.ResponseMsg(c, e.SUCCESS, serializer.Response{
|
||
Data: DepartmentListRes,
|
||
Status: e.Ok,
|
||
})
|
||
}
|
||
|
||
// CreateClockDevice 创建打卡机
|
||
func CreateClockDevice(c *gin.Context) {
|
||
var req account.CreateClockDeviceRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var in = account.CreateClockDeviceRequest{
|
||
DeviceNum: req.DeviceNum,
|
||
DeviceName: req.DeviceName,
|
||
DeviceSite: req.DeviceSite,
|
||
}
|
||
res, err := service.AccountProvider.CreateClockDevice(c, &in)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// UpdateClockDevice 更新打卡机
|
||
func UpdateClockDevice(c *gin.Context) {
|
||
var req account.UpdateClockDeviceRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var in = account.UpdateClockDeviceRequest{
|
||
Id: req.Id,
|
||
DeviceNum: req.DeviceNum,
|
||
DeviceName: req.DeviceName,
|
||
DeviceSite: req.DeviceSite,
|
||
}
|
||
res, err := service.AccountProvider.UpdateClockDevice(c, &in)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// RemoveClockDevice 删除打卡机
|
||
func RemoveClockDevice(c *gin.Context) {
|
||
var req account.RemoveClockDeviceRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var in = account.RemoveClockDeviceRequest{
|
||
Id: req.Id,
|
||
}
|
||
res, err := service.AccountProvider.RemoveClockDevice(c, &in)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ClockDeviceInfo 查看打卡机详情
|
||
func ClockDeviceInfo(c *gin.Context) {
|
||
var req account.ClockDeviceInfoRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var in = account.ClockDeviceInfoRequest{
|
||
Id: req.Id,
|
||
Page: req.Page,
|
||
PageSize: req.PageSize,
|
||
}
|
||
res, err := service.AccountProvider.ClockDeviceInfo(c, &in)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ClockDeviceList 查看打卡机列表
|
||
func ClockDeviceList(c *gin.Context) {
|
||
var req account.ClockDeviceListRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var in = account.ClockDeviceListRequest{
|
||
DeviceSite: req.DeviceSite,
|
||
DeviceNum: req.DeviceNum,
|
||
DeviceName: req.DeviceName,
|
||
Page: req.Page,
|
||
PageSize: req.PageSize,
|
||
}
|
||
res, err := service.AccountProvider.ClockDeviceList(c, &in)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ClockDeviceSingleUntie 单人解绑打卡机设备
|
||
func ClockDeviceSingleUntie(c *gin.Context) {
|
||
var req account.RemoveClockDeviceRequest
|
||
deviceNums := make(map[string]string)
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
var batch account.ClockBatchBindRequest
|
||
batch.Id = req.Id
|
||
devRes, err := service.AccountProvider.ClockDeviceBatchList(c, &batch) //获取设备列表
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, errors.New("未找到设备"))
|
||
return
|
||
}
|
||
for _, i := range devRes.Data {
|
||
deviceNums[i.DeviceNum] = i.DeviceName
|
||
}
|
||
oline := CheckDeviceIsOnline(deviceNums)
|
||
if oline != "" {
|
||
service.Error(c, e.Error, errors.New(oline))
|
||
return
|
||
}
|
||
err = DelSingleDeviceAccount(c, devRes.Data[0].DeviceNum, devRes.Data[0].UserId)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
res, err := service.AccountProvider.ClockDeviceSingleUntie(c, &req) //删除绑定关联
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceBatchBind 批量绑定打卡机
|
||
func ClockDeviceBatchBind(c *gin.Context) {
|
||
var req account.ClockBatchBindRequest
|
||
deviceNums := make(map[string]string)
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
deviceIds := account.ClockDeviceListRequest{
|
||
Ids: req.DeviceId,
|
||
}
|
||
DeviceList, err := service.AccountProvider.ClockDeviceList(c, &deviceIds)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
//判断设备是否在线
|
||
for _, i := range DeviceList.Data {
|
||
deviceNums[i.DeviceNum] = i.DeviceName
|
||
}
|
||
oline := CheckDeviceIsOnline(deviceNums)
|
||
if oline != "" {
|
||
service.Error(c, e.Error, errors.New(oline))
|
||
return
|
||
}
|
||
//判断所选员工姓名和近照是否存在
|
||
userInfo, err := getUserInfo(c, req.UserId)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
// 整合数据
|
||
data, dataSet := SelectTheUserToBeDelivered(DeviceList, userInfo)
|
||
//保存不匹配的数据到新切片
|
||
if len(data.Data) == 0 {
|
||
service.Error(c, e.Error, errors.New("所选用户已经下发过"))
|
||
return
|
||
}
|
||
//并发下发用户数据
|
||
err = ConcurrentUpdateDeviceUser(c, dataSet, 10)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
//添加绑定关系
|
||
res, err := service.AccountProvider.ClockDeviceBatchBind(c, data)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ClockDeviceBatchUntie 批量解绑打卡机
|
||
func ClockDeviceBatchUntie(c *gin.Context) {
|
||
var req account.ClockBatchBindRequest
|
||
deviceNums := make(map[string]string)
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res1, err := service.AccountProvider.ClockDeviceBatchList(c, &req)
|
||
if len(res1.Data) == 0 {
|
||
service.Error(c, e.InvalidParams, errors.New("没有需要解绑的人员"))
|
||
return
|
||
}
|
||
//判断设备是否在线
|
||
for _, i := range res1.Data {
|
||
deviceNums[i.DeviceNum] = i.DeviceName
|
||
}
|
||
oline := CheckDeviceIsOnline(deviceNums)
|
||
if oline != "" {
|
||
service.Error(c, e.Error, errors.New(oline))
|
||
return
|
||
}
|
||
//整合数据
|
||
data := DeviceNumToJobNums(res1.Data)
|
||
//下发数据
|
||
err = DelBatchDeviceAccount(data)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, errors.New("下发命令失败"))
|
||
return
|
||
}
|
||
//删除关联
|
||
res, err := service.AccountProvider.ClockDeviceBatchUntie(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, errors.New("解绑失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceCapturePhoto 抓拍现场照片
|
||
func ClockDeviceCapturePhoto(c *gin.Context) {
|
||
var req request.NotificationDevice
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SnapPhotosOfTheScene(c, req.DeviceNum)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
decodedData, err := url.QueryUnescape(res)
|
||
if err != nil {
|
||
fmt.Println("URL 解码时出错:", err)
|
||
return
|
||
}
|
||
imageBytes, err := base64.StdEncoding.DecodeString(decodedData)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("解码Base64时出错"))
|
||
return
|
||
}
|
||
c.Writer.Header().Set("Content-Type", "image/png")
|
||
_, _ = c.Writer.WriteString(string(imageBytes))
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceDetectionPhoto 检测图片质量
|
||
func ClockDeviceDetectionPhoto(c *gin.Context) {
|
||
file, err := c.FormFile("file")
|
||
source := c.PostForm("deviceNum")
|
||
// 检验文件
|
||
if err != nil {
|
||
logger.Errorf("Upload FormFile err", err)
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
// 打开上传的文件
|
||
src, err := file.Open()
|
||
if err != nil {
|
||
logger.Errorf("Open file err: %v", err)
|
||
c.JSON(http.StatusInternalServerError, gin.H{
|
||
"error": "Unable to open file",
|
||
})
|
||
return
|
||
}
|
||
defer src.Close()
|
||
// 读取文件内容到字节切片
|
||
fileBytes := make([]byte, file.Size)
|
||
_, err = src.Read(fileBytes)
|
||
if err != nil {
|
||
logger.Errorf("Read file err: %v", err)
|
||
c.JSON(http.StatusInternalServerError, gin.H{
|
||
"error": "Unable to read file",
|
||
})
|
||
return
|
||
}
|
||
// 将字节切片编码为Base64字符串
|
||
base64String := base64.StdEncoding.EncodeToString(fileBytes)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
encodedData := url.QueryEscape(base64String)
|
||
res, err := CheckPictureQuality(c, source, encodedData)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ClockDeviceRuleIssuance 人员通行规则下发
|
||
func ClockDeviceRuleIssuance(c *gin.Context) {
|
||
var req turnstile.RuleIssuance
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err := GeneralRuleIssuance(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, nil)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceRuleAcquire 获取人员通行规则
|
||
func ClockDeviceRuleAcquire(c *gin.Context) {
|
||
var req turnstile.RuleIssuance
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := AccessRule(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceRuleDelete 删除人员通行规则
|
||
func ClockDeviceRuleDelete(c *gin.Context) {
|
||
var req request.DeleteRule
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err := DeleteRule(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, nil)
|
||
return
|
||
}
|
||
|
||
// ClockDevicePasswordSwitch 设备密码开门开关
|
||
func ClockDevicePasswordSwitch(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err := PasswordSwitch(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, nil)
|
||
return
|
||
}
|
||
|
||
// ClockDevicePasswordSet 设置设备开门密码
|
||
func ClockDevicePasswordSet(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err := PasswordSet(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, nil)
|
||
return
|
||
}
|
||
|
||
// ClockDevicePersonSync 通知设备同步人员数据
|
||
func ClockDevicePersonSync(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
err := PersonSync(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("下发失败"))
|
||
return
|
||
}
|
||
service.Success(c, nil)
|
||
return
|
||
}
|
||
|
||
// ClockDevicePersonTotal 查询设备人员数量和id
|
||
func ClockDevicePersonTotal(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := PersonTotal(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDevicePersonInfo 根据userid读取用户数据
|
||
func ClockDevicePersonInfo(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := PersonInfo(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetAcquire 获取设备设置
|
||
func ClockDeviceSetAcquire(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
lockStatus := -1
|
||
if req.Settings[0] == "all" {
|
||
lockStatus, _ = DoorLock(c, req)
|
||
}
|
||
res, err := SetAcquire(c, req)
|
||
res.LockState = lockStatus
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetLogo 设置设备logo
|
||
func ClockDeviceSetLogo(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetLogo(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetSlogan 设置广告语
|
||
func ClockDeviceSetSlogan(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetSlogan(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetTime 设置设备时间
|
||
func ClockDeviceSetTime(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetTime(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetDoor 控制设备开门/关门
|
||
func ClockDeviceSetDoor(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetDoor(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetInterval 设置设备识别间隔
|
||
func ClockDeviceSetInterval(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetInterval(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetDistance 设置设备识别距离
|
||
func ClockDeviceSetDistance(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetDistance(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetMask 口罩检测开关
|
||
func ClockDeviceSetMask(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetMask(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetLiving 活体检测
|
||
func ClockDeviceSetLiving(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetLiving(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetLivingClass 活体检测等级
|
||
func ClockDeviceSetLivingClass(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetLivingClass(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetStranger 陌生人识别
|
||
func ClockDeviceSetStranger(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetStranger(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetVolume 设备音量
|
||
func ClockDeviceSetVolume(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetVolume(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetUsername 播放用户名
|
||
func ClockDeviceSetUsername(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetUsername(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetHint 设置设备提示语音
|
||
func ClockDeviceSetHint(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetHint(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetPassword 修改进入设置页面密码
|
||
func ClockDeviceSetPassword(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetPassword(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetRestart 重启设备
|
||
func ClockDeviceSetRestart(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetRestart(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetRelay 设置继电器状态-常开/正常
|
||
func ClockDeviceSetRelay(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetRelay(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetCapture 设置设备识别照片抓拍的质量
|
||
func ClockDeviceSetCapture(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetCapture(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetCallout 访问呼叫开关
|
||
func ClockDeviceSetCallout(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetCallout(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetPrinter 打印机开关
|
||
func ClockDeviceSetPrinter(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetPrinter(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetVisitor 首页访客申请入库内容
|
||
func ClockDeviceSetVisitor(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetVisitor(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetToken 设置http请求的token
|
||
func ClockDeviceSetToken(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetToken(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetVerify 设置验证接口超时时长
|
||
func ClockDeviceSetVerify(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetVerify(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetDelay 设置设备开门延迟
|
||
func ClockDeviceSetDelay(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetDelay(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetPressTime 进入设置页面长按时间
|
||
func ClockDeviceSetPressTime(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetPressTime(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetDesensitization 姓名脱敏显示
|
||
func ClockDeviceSetDesensitization(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetDesensitization(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetSection 设置读卡扇区
|
||
func ClockDeviceSetSection(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetSection(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDeviceSetRail 设置设备位置围栏
|
||
func ClockDeviceSetRail(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := SetRail(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockScreensaverState 设备节能屏保开关
|
||
func ClockScreensaverState(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ScreensaverState(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockScreensaver 设置设备屏保
|
||
func ClockScreensaver(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := Screensaver(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDelScreensaver 删除屏保
|
||
func ClockDelScreensaver(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := DelScreensaver(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockScreensaverInterval 设置屏保显示时长
|
||
func ClockScreensaverInterval(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ScreensaverInterval(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureDetection 体温检测开关
|
||
func ClockTemperatureDetection(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureDetection(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureMode 体温检测模式
|
||
func ClockTemperatureMode(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureMode(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureStandard 初筛模式标准
|
||
func ClockTemperatureStandard(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureStandard(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureCalibration 设置体温校准模式
|
||
func ClockTemperatureCalibration(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureCalibration(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureLowPass 低温可通行开关
|
||
func ClockTemperatureLowPass(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureLowPass(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperaturePlay 播报体温开关
|
||
func ClockTemperaturePlay(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperaturePlay(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureReflectivity 设置体温反射率
|
||
func ClockTemperatureReflectivity(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureReflectivity(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureCorrection 设置体温校准值
|
||
func ClockTemperatureCorrection(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureCorrection(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureDistance 设置设备体温检测距离
|
||
func ClockTemperatureDistance(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureDistance(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockTemperatureMeasure 设置测温时间段
|
||
func ClockTemperatureMeasure(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := TemperatureMeasure(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockVersionAuto 开机自动更新
|
||
func ClockVersionAuto(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := VersionAuto(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockVersionInfo 获取设备版本信息
|
||
func ClockVersionInfo(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := VersionInfo(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res.Msg))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockVersionPush 发送设备版本信息给服务端
|
||
func ClockVersionPush(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := VersionPush(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("获取失败"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockVersionCheck 通知设备在线检查更新
|
||
func ClockVersionCheck(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := VersionCheck(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockApplyValue 设置设备首页二维码
|
||
func ClockApplyValue(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ApplyValue(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockApplyPrefix 设置访客二维码前缀
|
||
func ClockApplyPrefix(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ApplyPrefix(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockCameraPanoramic 全景相机开关
|
||
func ClockCameraPanoramic(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := CameraPanoramic(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockCameraParams 设置全景相机的参数
|
||
func ClockCameraParams(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := CameraParams(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockRecognitionStyle 识别结果样式
|
||
func ClockRecognitionStyle(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := RecognitionStyle(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnlineVerify 识别后在线验证
|
||
func ClockOnlineVerify(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := OnlineVerify(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnlineCard 在线验证卡号
|
||
func ClockOnlineCard(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := OnlineCard(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnlineIdCard 在线验证身份证号
|
||
func ClockOnlineIdCard(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := OnlineIdCard(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnline 设置在线识别间隔
|
||
func ClockOnline(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := Online(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnlineState 在线识别开关
|
||
func ClockOnlineState(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := OnlineState(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockOnlineTemporary 临时启用在线识别
|
||
func ClockOnlineTemporary(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := OnlineTemporary(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDiscernSettings 设置可通行人员类型
|
||
func ClockDiscernSettings(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := DiscernSettings(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDiscernClass 设置设备识别置信度
|
||
func ClockDiscernClass(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := DiscernClass(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockForbiddenSwitch 开启/关闭设备识别
|
||
func ClockForbiddenSwitch(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ForbiddenSwitch(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockForbiddenNumber 停用状态通行人数
|
||
func ClockForbiddenNumber(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := ForbiddenNumber(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockAdvertisingAdd 下发广告 - 图片
|
||
func ClockAdvertisingAdd(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := AdvertisingAdd(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockAdvertisingDel 删除广告
|
||
func ClockAdvertisingDel(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := AdvertisingDel(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockAdvertisingChange 启用停用广告
|
||
func ClockAdvertisingChange(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := AdvertisingChange(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDoorLock 获取(上报)门锁状态
|
||
func ClockDoorLock(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := DoorLock(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(strconv.Itoa(res)))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockDoorListener 设置门锁实时监听开关
|
||
func ClockDoorListener(c *gin.Context) {
|
||
var req request.DeviceReq
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := DoorListener(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New(res))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockLogList 打卡记录列表
|
||
func ClockLogList(c *gin.Context) {
|
||
req := &account.ClockLogReq{}
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := service.AccountProvider.FindClockLogList(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockLogInfo 打卡记录详情
|
||
func ClockLogInfo(c *gin.Context) {
|
||
req := &account.ClockLogReq{}
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := service.AccountProvider.FindClockLogList(c, req)
|
||
|
||
res.Count = uint64(len(res.Data))
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ClockVisitor 访客申请
|
||
func ClockVisitor(c *gin.Context) {
|
||
req := &account.ClockLogInfo{}
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
face, _ := SnapPhotosOfTheScene(c, req.Sn)
|
||
decodedData, err := url.QueryUnescape(face)
|
||
if err != nil {
|
||
fmt.Println("URL 解码时出错:", err)
|
||
return
|
||
}
|
||
uuids, _ := uuid.NewV4()
|
||
var objectName = fmt.Sprintf("%s/%s/%s.jpeg", config.ConfigData.Oss.BaseDir, config.Env, uuids)
|
||
BOSClient, _ := objstorage.NewOSS(config.ConfigData.Oss.AccessKeyId, config.ConfigData.Oss.AccessKeySecret, config.ConfigData.Oss.Endpoint)
|
||
imageBytes, err := base64.StdEncoding.DecodeString(decodedData)
|
||
_, err = BOSClient.PutObjectFromBytes(config.ConfigData.Oss.BucketName, objectName, imageBytes)
|
||
Url := fmt.Sprintf("%s/%s", config.ConfigData.Oss.CdnHost, objectName)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("解码Base64时出错"))
|
||
return
|
||
}
|
||
userReq := &account.UserByTelRequest{
|
||
Tel: req.ReceiverTel,
|
||
}
|
||
userRes, err := service.AccountProvider.UserByTel(c, userReq)
|
||
if userRes.Info.ID == 0 || err != nil {
|
||
service.Error(c, e.Error, errors.New("接待人不存在"))
|
||
return
|
||
}
|
||
req = &account.ClockLogInfo{
|
||
Sn: req.Sn,
|
||
UserId: "F1000001",
|
||
RecogType: "manual_visitor",
|
||
RecogTime: time.Now().Format("2006-01-02 15:04:05"),
|
||
Gender: req.Gender,
|
||
Photo: Url,
|
||
PassStatus: 1,
|
||
UserName: req.UserName,
|
||
UserType: 2,
|
||
Tel: req.Tel,
|
||
ReasonVisit: req.ReasonVisit,
|
||
ReceiverTel: req.ReceiverTel,
|
||
NumOfPeople: req.NumOfPeople,
|
||
}
|
||
res, err := service.AccountProvider.CreateClockLog(c, req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
strangerReq := account.SendClockInWechatRequest{
|
||
GhId: "gh_d838598b1a23",
|
||
Address: req.Sn,
|
||
UserId: uint32(userRes.Info.ID),
|
||
LogId: res.Id,
|
||
}
|
||
_, err = service.AccountProvider.SendStrangerClockInWechat(c, &strangerReq)
|
||
if err != nil {
|
||
service.Error(c, e.Error, errors.New("接待人未注册"))
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
// ExamineList 审核列表
|
||
func ExamineList(c *gin.Context) {
|
||
var req account.WriteOffListRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := service.AccountProvider.FindWriteOffList(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
}
|
||
|
||
// ExamineApprove 审批
|
||
func ExamineApprove(c *gin.Context) {
|
||
var req account.WriteOffApproveRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
res, err := service.AccountProvider.WriteOffInfo(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
if res.Status != 1 {
|
||
service.Error(c, e.InvalidParams, errors.New("审批结束,不可重复提交"))
|
||
return
|
||
}
|
||
_, err = service.AccountProvider.WriteOffUpdate(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.InvalidParams, errors.New("审批错误"))
|
||
return
|
||
}
|
||
// 拒绝审批
|
||
if req.Status == 3 {
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
// 通过审批
|
||
if req.Status == 2 {
|
||
err := handleApprovalSuccess(c, res)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
service.Success(c, res)
|
||
return
|
||
}
|
||
|
||
service.Error(c, e.InvalidParams, errors.New("参数错误"))
|
||
return
|
||
}
|
||
|
||
// ArtworkUserLogin 用户登录操作
|
||
func ArtworkUserLogin(c *gin.Context) {
|
||
|
||
var jumpToWhere = "setting"
|
||
|
||
var req account.LoginRequest
|
||
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
||
service.Error(c, e.InvalidParams, err)
|
||
return
|
||
}
|
||
req.Ip = c.ClientIP()
|
||
|
||
res, err := service.AccountProvider.Login(c, &req)
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
//获取用户的岗位信息
|
||
uReq := rule.RulesRequest{
|
||
AccountID: res.AccountInfo.ID,
|
||
}
|
||
|
||
qres, err1 := service.RuleProvider.UserInfo(c, &uReq)
|
||
|
||
if err1 != nil {
|
||
service.Error(c, e.Error, err1)
|
||
return
|
||
}
|
||
|
||
if isHaveAuth(c, res.AccountInfo.ID, e.AuthArtworkFix, "button") == false {
|
||
service.Error(c, e.Error, errors.New("您暂时没有登陆的权限"))
|
||
return
|
||
}
|
||
|
||
accountInfo := &union.AccountInfo{
|
||
ID: res.AccountInfo.ID,
|
||
Account: res.AccountInfo.Account,
|
||
NickName: res.AccountInfo.NickName,
|
||
Domain: res.AccountInfo.Domain,
|
||
TelNum: res.AccountInfo.TelNum,
|
||
Status: res.AccountInfo.Status,
|
||
Avatar: res.AccountInfo.Avatar,
|
||
CreatedAt: res.AccountInfo.CreateAt,
|
||
IsNeedChange: res.AccountInfo.IsNeedChange,
|
||
EnterDate: res.AccountInfo.EnterDate,
|
||
WorkYear: res.AccountInfo.WorkYear,
|
||
IsAdmin: qres.IsAdmin,
|
||
PositionUsers: qres.PositionUsers,
|
||
JumpTo: res.AccountInfo.Extend.JumpTo,
|
||
DepartmentName: "",
|
||
JobNum: res.AccountInfo.JobNum,
|
||
BirthDate: res.AccountInfo.BirthDate,
|
||
Age: res.AccountInfo.Age,
|
||
Sex: res.AccountInfo.Sex,
|
||
Title: res.AccountInfo.Title,
|
||
IDNum: res.AccountInfo.IDNum,
|
||
MailAccount: res.AccountInfo.MailAccount,
|
||
Train: res.AccountInfo.Train,
|
||
Certificate: res.AccountInfo.Certificate,
|
||
TrainVideos: res.AccountInfo.TrainVideos,
|
||
}
|
||
|
||
code := "xxx"
|
||
if len(qres.PositionUsers) >= 1 {
|
||
accountInfo.DepartmentName = qres.PositionUsers[0].DepartmentName
|
||
code = secret.GetPositionCode(qres.PositionUsers[0].PositionName)
|
||
}
|
||
|
||
token, err := secret.CombineSecret(code, accountInfo.DepartmentName, res.Token)
|
||
|
||
if err != nil {
|
||
service.Error(c, e.Error, err)
|
||
return
|
||
}
|
||
|
||
resInfo := &union.Login{
|
||
Token: token,
|
||
RefreshToken: res.RefreshToken,
|
||
AccountInfo: accountInfo,
|
||
JumpToWhere: jumpToWhere,
|
||
}
|
||
|
||
fmt.Println("是否相同：", res.IsSampleAddress, res.AccountInfo.NowLogId)
|
||
if res.IsSampleAddress == false && res.AccountInfo.NowLogId != 0 { //登陆地址异常
|
||
|
||
url := fmt.Sprintf("https://erpapi.fontree.cn/off7524164487E?id=%d", res.AccountInfo.NowLogId)
|
||
shortUrl, err := utils.CreateShortUrl(url)
|
||
if err == nil {
|
||
url = shortUrl
|
||
}
|
||
|
||
msgReq := account.SendCustomMsgRequest{
|
||
ID: res.AccountInfo.ID,
|
||
TelNum: res.AccountInfo.TelNum,
|
||
MId: 134802,
|
||
SigNo: uint32(config.DefaultSignNo),
|
||
}
|
||
|
||
msgReq.Url = res.NowAddress + "|" + url
|
||
fmt.Println("发送短信", msgReq)
|
||
service.AccountProvider.SendCustomMsg(c, &msgReq)
|
||
|
||
}
|
||
|
||
service.Success(c, resInfo)
|
||
|
||
return
|
||
}
|
||
|
||
func isHaveAuth(c *gin.Context, ID uint64, url, ruleType string) bool {
|
||
isLeader := false
|
||
|
||
req := position.DoIHavaAuthRequest{
|
||
UserId: ID,
|
||
Url: url,
|
||
Type: ruleType,
|
||
}
|
||
|
||
res, err := service.PositionProvider.DoIHavaAuth(c, &req)
|
||
|
||
if err == nil && res.Hava == true {
|
||
isLeader = true
|
||
}
|
||
|
||
return isLeader
|
||
}
|
||
|
||
// handleApprovalSuccess 处理通过审批的逻辑
|
||
func handleApprovalSuccess(c *gin.Context, req *account.WriteOffRequest) error {
|
||
// 获取用户信息
|
||
user, err := GetUserInfoById(c, req.UserId, req.Domain)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 构建新的岗位用户列表，排除当前岗位
|
||
newPositionUsers := filterPositionUsers(user.PositionUsers, req.SiteId)
|
||
// 替换岗位
|
||
positionReq := &position.BindUserRequest{
|
||
Domain: user.Domain,
|
||
UserID: user.ID,
|
||
UserName: user.NickName,
|
||
Avatar: user.Avatar,
|
||
PositionUsers: newPositionUsers,
|
||
}
|
||
_, err = service.PositionProvider.BindUser(c, positionReq)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 如果用户不属于其他部门，则将其状态设置为"left"
|
||
if len(newPositionUsers) == 0 {
|
||
removeReq := account.UpdateRequest{
|
||
Domain: "fontree",
|
||
ID: req.UserId,
|
||
Status: "left",
|
||
Operator: &account.Operator{
|
||
ID: 0,
|
||
Name: "销售宝",
|
||
},
|
||
}
|
||
_, err = service.AccountProvider.Update(c, &removeReq)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// filterPositionUsers 过滤掉指定岗位的用户
|
||
func filterPositionUsers(users []*rule.PositionUser, siteID uint64) []*position.PositionUser {
|
||
var newPositionUsers []*position.PositionUser
|
||
for _, u := range users {
|
||
if u.DepartmentId != siteID {
|
||
p := &position.PositionUser{
|
||
PositionID: u.PositionID,
|
||
DepartmentID: u.DepartmentId,
|
||
DepartmentCode: u.DepartmentCode,
|
||
UserId: u.UserId,
|
||
UserName: u.UserName,
|
||
DepartmentName: u.DepartmentName,
|
||
PositionName: u.PositionName,
|
||
}
|
||
newPositionUsers = append(newPositionUsers, p)
|
||
}
|
||
}
|
||
return newPositionUsers
|
||
}
|
||
|
||
func GetECardInfo(userID uint64, changedPlace string) (addChainRequest *e_card.AddChainRequest, err error) {
|
||
// 生成电子名片
|
||
// 获取用户信息，如果是非erp用户则不需要生成电子名片
|
||
infoRequest := &account.InfoRequest{
|
||
Domain: "fontree",
|
||
ID: userID,
|
||
}
|
||
var userInfo *account.InfoResponse
|
||
userInfo, err = service.AccountProvider.Info(context.Background(), infoRequest)
|
||
if err != nil {
|
||
return
|
||
}
|
||
// 重新获取用户的部门、岗位
|
||
rulesReq := &rule.RulesRequest{
|
||
AccountID: userID,
|
||
}
|
||
|
||
qres, err := service.RuleProvider.UserInfo(context.Background(), rulesReq)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
var departments []string
|
||
var posts []string
|
||
|
||
for _, positionUser := range qres.PositionUsers {
|
||
departments = append(departments, positionUser.DepartmentName)
|
||
posts = append(posts, positionUser.PositionName)
|
||
}
|
||
|
||
addChainRequest = &e_card.AddChainRequest{
|
||
Name: userInfo.Info.NickName,
|
||
Phone: userInfo.Info.TelNum,
|
||
Company: "泰丰文化集团",
|
||
Department: departments,
|
||
Post: posts,
|
||
DateOnBoard: userInfo.Info.EnterDate,
|
||
UserID: int32(userID),
|
||
Addr: userInfo.Info.Account,
|
||
ChangedPlace: changedPlace,
|
||
}
|
||
|
||
return
|
||
}
|