fonchain-fiee/pkg/service/blockchain/blockchain.go

302 lines
7.1 KiB
Go
Raw Normal View History

2025-02-19 06:24:15 +00:00
package blockchain
import (
"context"
"fmt"
"github.com/fonchain_enterprise/fonchain-main/api/account"
"github.com/fonchain_enterprise/fonchain-main/api/e_card"
"github.com/fonchain_enterprise/fonchain-main/api/equity"
"github.com/fonchain_enterprise/fonchain-main/api/rule"
"github.com/fonchain_enterprise/fonchain-main/pkg/e"
"github.com/fonchain_enterprise/fonchain-main/pkg/model/request"
"github.com/fonchain_enterprise/fonchain-main/pkg/response"
"github.com/fonchain_enterprise/fonchain-main/pkg/service"
"github.com/gin-gonic/gin"
)
// BlockUserList 用户列表
func BlockUserList(ctx *gin.Context) {
req := &request.BlockUserListReq{}
resp := &response.BlockUserListResp{}
var err error
if err = ctx.ShouldBind(&req); err != nil {
service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
return
}
status := ""
if req.Status == 1 {
status = "notactive"
} else if req.Status == 2 {
status = "left"
}
userReq := &account.ListRequest{
Domain: "blockchain",
PageSize: req.PageSize,
Page: req.Page,
Key: req.Name,
TelNum: req.TelNum,
Status: status,
StartEnterDate: req.StartDate,
EndEnterDate: req.EndDate,
}
res, err := service.AccountProvider.List(ctx, userReq)
if err != nil {
service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
return
}
// 一次性分配 UserId 切片的空间
UserId := make([]int32, 0, len(res.Data))
for _, v := range res.Data {
UserId = append(UserId, int32(v.ID))
}
// 获取余额
rep, err := service.EquityProvider.GetResourcesByUserIds(ctx, &equity.GetResourcesByUserIdsRequest{
UserIDs: UserId,
})
if err != nil {
service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
return
}
resourcesByUserID := make(map[uint64]*equity.ResourcesByUserID)
for _, resource := range rep.ResourcesByUserID {
resourcesByUserID[uint64(resource.UserID)] = resource
}
// 处理结果
for _, v := range res.Data {
resource, ok := resourcesByUserID[v.ID]
if !ok {
// 如果获取不到余额将余额赋值为0
resource = &equity.ResourcesByUserID{
UserID: int32(v.ID),
Money: 0,
Resource: 0,
}
}
resStatus := 0
switch v.Status {
case "notactive":
resStatus = 1
case "left":
resStatus = 2
}
resp.List = append(resp.List, &response.BlockUserList{
Id: v.ID,
Name: v.NickName,
TelNum: v.TelNum,
Status: resStatus,
RegisterDate: v.EnterDate,
IdCard: v.IDNum,
BlockAddr: v.BlockAddr,
CardBalance: uint64(resource.Money),
EquityBalance: uint64(resource.Resource),
})
}
service.ResponseQuickMsg(ctx, e.Success, "success", resp)
return
}
func BlockUserSetting(ctx *gin.Context) {
req := &request.BlockUserSettingReq{}
var err error
if err = ctx.ShouldBind(&req); err != nil {
service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
return
}
if len(req.Ids) > 10 || req.Status != 1 && req.Status != 2 {
service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
return
}
status := ""
switch req.Status {
case 1:
status = "notactive"
case 2:
status = "left"
}
for _, i := range req.Ids {
_, err = service.AccountProvider.Update(ctx, &account.UpdateRequest{
ID: i,
Domain: "blockchian",
Status: status,
})
if err != nil {
service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
return
}
}
service.ResponseQuickMsg(ctx, e.Success, "success", nil)
return
}
func AddChain(c *gin.Context) {
var addChainRequest e_card.AddChainRequest
if err := c.ShouldBind(&addChainRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.ECardProvider.AddChain(context.Background(), &addChainRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, rep)
return
}
func ECardUserManage(c *gin.Context) {
var eCardUserManageRequest e_card.ECardUserManageRequest
if err := c.ShouldBind(&eCardUserManageRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.ECardProvider.ECardUserManage(context.Background(), &eCardUserManageRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, rep)
return
}
func ChainRecord(c *gin.Context) {
var chainRecordRequest e_card.ChainRecordRequest
if err := c.ShouldBind(&chainRecordRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.ECardProvider.ChainRecord(context.Background(), &chainRecordRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, rep)
return
}
func SaveInfo(c *gin.Context) {
res, err := service.AccountProvider.List(context.Background(), &account.ListRequest{Domain: "fontree", PageSize: 99999, Page: 1, Status: "notactive"})
if err != nil {
fmt.Println("获取用户信息失败", err)
return
}
for _, data := range res.Data {
// 获取岗位信息
uReq := rule.RulesRequest{
Domain: "fontree",
AccountID: data.ID,
}
posResp, err := service.RuleProvider.UserInfo(context.Background(), &uReq)
if err != nil {
fmt.Println("获取用户信息失败", err)
service.Error(c, e.Error, err)
return
}
var department []string
var post []string
for _, position := range posResp.PositionUsers {
department = append(department, position.DepartmentName)
post = append(post, position.PositionName)
}
addChainRequest := &e_card.AddChainRequest{
Name: data.NickName,
Phone: data.TelNum,
Company: "泰丰国际",
Department: department,
Post: post,
DateOnBoard: data.EnterDate,
UserID: int32(data.ID),
Addr: data.Account,
ChangedPlace: "新建电子名片",
}
_, err = service.ECardProvider.AddChain(context.Background(), addChainRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
}
return
}
func UserExist(c *gin.Context) {
var userByTelRequest account.UserByTelRequest
if err := c.ShouldBind(&userByTelRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.AccountProvider.UserByTel(c, &userByTelRequest)
if err != nil {
return
}
service.Success(c, rep)
}
func Send(c *gin.Context) {
var req account.SendMsgRequest
if err := c.ShouldBind(&req); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
res, err := service.AccountProvider.SendMsg(context.Background(), &req)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, res)
return
}
func Login(c *gin.Context) {
var loginRequest account.LoginRequest
if err := c.ShouldBind(&loginRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.AccountProvider.Login(c, &loginRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, rep)
}
func Check(c *gin.Context) {
var checkMsgRequest account.CheckMsgRequest
if err := c.ShouldBind(&checkMsgRequest); err != nil {
service.Error(c, e.InvalidParams, err)
return
}
rep, err := service.AccountProvider.CheckMsg(c, &checkMsgRequest)
if err != nil {
service.Error(c, e.Error, err)
return
}
service.Success(c, rep)
}