kami_boss/internal/controllers/getController.go

package controllers

import (
	"boss/internal/common"
	"boss/internal/datas"
	"boss/internal/models/accounts"
	"boss/internal/models/agent"
	"boss/internal/models/merchant"
	"boss/internal/models/notify"
	"boss/internal/models/order"
	"boss/internal/models/payfor"
	"boss/internal/models/road"
	"boss/internal/models/system"
	"boss/internal/models/user"
	"boss/internal/service"
	"encoding/json"
	"fmt"
	"github.com/duke-git/lancet/v2/convertor"
	"sort"
	"strings"
	"time"

	"github.com/beego/beego/v2/core/logs"
	"github.com/duke-git/lancet/v2/slice"
	"github.com/xuri/excelize/v2"
)

type GetController struct {
	BaseController
	DisplayCount int
	CurrentPage  int
	TotalPage    int
	JumpPage     int
	Offset       int
}

// GetCutPage 处理分页的函数
func (c *GetController) GetCutPage(l int) {
	c.DisplayCount, _ = c.GetInt("displayCount")
	c.CurrentPage, _ = c.GetInt("currentPage")
	c.TotalPage, _ = c.GetInt("totalPage")
	c.JumpPage, _ = c.GetInt("jumpPage")

	if c.CurrentPage == 0 {
		c.CurrentPage = 1
	}
	if c.DisplayCount == 0 {
		c.DisplayCount = 20
	}
	if c.JumpPage > 0 {
		c.CurrentPage = c.JumpPage
	}

	if l > 0 {
		c.TotalPage = l / c.DisplayCount
		if l%c.DisplayCount > 0 {
			c.TotalPage += 1
		}
	} else {
		c.TotalPage = 0
		c.CurrentPage = 0
	}
	//假如当前页超过了总页数
	if c.CurrentPage > c.TotalPage {
		c.CurrentPage = c.TotalPage
	}
	//计算出偏移量
	c.Offset = (c.CurrentPage - 1) * c.DisplayCount
}

func (c *GetController) GetMenu() {
	ctx := c.Ctx.Request.Context()
	firstMenuSearch := strings.TrimSpace(c.GetString("firstMenuSearch"))

	params := make(map[string]string)
	params["first_menu__icontains"] = firstMenuSearch
	c.GetCutPage(system.GetMenuLenByMap(ctx, params))

	menuDataJSON := new(datas.MenuDataJSON)
	menuDataJSON.DisplayCount = c.DisplayCount
	menuDataJSON.CurrentPage = c.CurrentPage
	menuDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		menuDataJSON.Code = -1
		menuDataJSON.MenuList = make([]system.MenuInfo, 0)
		c.GenerateJSON(menuDataJSON)
		return
	}

	menuInfoList := system.GetMenuOffsetByMap(ctx, params, c.DisplayCount, c.Offset)
	sort.Sort(system.MenuInfoSlice(menuInfoList))
	for i, m := range menuInfoList {
		secondMenuInfoList := system.GetSecondMenuListByFirstMenuUid(ctx, m.MenuUid)
		smenus := ""
		for j := 0; j < len(secondMenuInfoList); j++ {
			smenus += secondMenuInfoList[j].SecondMenu
			if j != (len(secondMenuInfoList) - 1) {
				smenus += "||"
			}
		}
		m.SecondMenu = smenus
		menuInfoList[i] = m
	}
	menuDataJSON.Code = 200
	menuDataJSON.MenuList = menuInfoList
	menuDataJSON.StartIndex = c.Offset

	if len(menuInfoList) == 0 {
		menuDataJSON.Msg = "获取菜单列表失败"
	}

	c.GenerateJSON(menuDataJSON)
}

func (c *GetController) GetFirstMenu() {
	ctx := c.Ctx.Request.Context()
	menuDataJSON := new(datas.MenuDataJSON)
	menuList := system.GetMenuAll(ctx)

	if len(menuList) == 0 {
		menuDataJSON.Code = -1
	} else {
		menuDataJSON.Code = 200
	}
	sort.Sort(system.MenuInfoSlice(menuList))
	menuDataJSON.MenuList = menuList
	c.GenerateJSON(menuDataJSON)
}

// GetSecondMenu 获取所有的二级菜单
func (c *GetController) GetSecondMenu() {
	ctx := c.Ctx.Request.Context()
	firstMenuSearch := strings.TrimSpace(c.GetString("firstMenuSerach"))
	secondMenuSearch := strings.TrimSpace(c.GetString("secondMenuSerach"))

	params := make(map[string]string)
	params["first_menu__icontains"] = firstMenuSearch
	params["second_menu__icontains"] = secondMenuSearch
	l := system.GetSecondMenuLenByMap(ctx, params)

	c.GetCutPage(l)

	secondMenuDataJSON := new(datas.SecondMenuDataJSON)
	secondMenuDataJSON.DisplayCount = c.DisplayCount

	secondMenuDataJSON.Code = 200
	secondMenuDataJSON.CurrentPage = c.CurrentPage
	secondMenuDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		secondMenuDataJSON.SecondMenuList = make([]system.SecondMenuInfo, 0)
		c.GenerateJSON(secondMenuDataJSON)
		return
	}

	secondMenuList := system.GetSecondMenuByMap(ctx, params, c.DisplayCount, c.Offset)
	sort.Sort(system.SecondMenuSlice(secondMenuList))
	secondMenuDataJSON.SecondMenuList = secondMenuList
	secondMenuDataJSON.StartIndex = c.Offset

	if len(secondMenuList) == 0 {
		secondMenuDataJSON.Msg = "获取二级菜单失败"
	}

	c.GenerateJSON(secondMenuDataJSON)
}

func (c *GetController) GetSecondMenus() {
	ctx := c.Ctx.Request.Context()
	firstMenuUid := strings.TrimSpace(c.GetString("firMenuUid"))

	secondMenuDataJSON := new(datas.SecondMenuDataJSON)

	secondMenuList := system.GetSecondMenuListByFirstMenuUid(ctx, firstMenuUid)

	secondMenuDataJSON.Code = 200
	secondMenuDataJSON.SecondMenuList = secondMenuList
	c.GenerateJSON(secondMenuDataJSON)
}

func (c *GetController) GetOneMenu() {
	ctx := c.Ctx.Request.Context()
	menuUid := c.GetString("menuUid")

	dataJSON := new(datas.MenuDataJSON)
	menuInfo := system.GetMenuInfoByMenuUid(ctx, menuUid)
	if menuInfo.MenuUid == "" {
		dataJSON.Code = -1
		dataJSON.Msg = "该菜单项不存在"
	} else {
		dataJSON.MenuList = make([]system.MenuInfo, 0)
		dataJSON.MenuList = append(dataJSON.MenuList, menuInfo)
		dataJSON.Code = 200
	}
	c.Data["json"] = dataJSON
	_ = c.ServeJSONP()
}

func (c *GetController) GetPowerItem() {
	ctx := c.Ctx.Request.Context()
	powerID := c.GetString("powerID")
	powerItem := c.GetString("powerItem")

	params := make(map[string]string)
	params["power_uid__icontains"] = powerID
	params["power_item_icontains"] = powerItem

	l := system.GetPowerItemLenByMap(ctx, params)

	c.GetCutPage(l)

	powerItemDataJSON := new(datas.PowerItemDataJSON)
	powerItemDataJSON.DisplayCount = c.DisplayCount
	powerItemDataJSON.Code = 200
	powerItemDataJSON.CurrentPage = c.CurrentPage
	powerItemDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		powerItemDataJSON.PowerItemList = make([]system.PowerInfo, 0)
		c.GenerateJSON(powerItemDataJSON)
		return
	}

	powerItemDataJSON.StartIndex = c.Offset
	powerItemList := system.GetPowerItemByMap(ctx, params, c.DisplayCount, c.Offset)
	sort.Sort(system.PowerInfoSlice(powerItemList))
	powerItemDataJSON.PowerItemList = powerItemList

	c.GenerateJSON(powerItemDataJSON)
}

func (c *GetController) GetRole() {
	ctx := c.Ctx.Request.Context()
	roleName := strings.TrimSpace(c.GetString("roleName"))

	params := make(map[string]string)
	params["role_name__icontains"] = roleName

	l := system.GetRoleLenByMap(ctx, params)

	c.GetCutPage(l)

	roleInfoDataJSON := new(datas.RoleInfoDataJSON)
	roleInfoDataJSON.DisplayCount = c.DisplayCount
	roleInfoDataJSON.Code = 200
	roleInfoDataJSON.CurrentPage = c.CurrentPage
	roleInfoDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		roleInfoDataJSON.RoleInfoList = make([]system.RoleInfo, 0)
		c.GenerateJSON(roleInfoDataJSON)
		return
	}
	roleInfoDataJSON.StartIndex = c.Offset
	roleInfoDataJSON.RoleInfoList = system.GetRoleByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(roleInfoDataJSON)
}

func (c *GetController) GetAllRole() {
	ctx := c.Ctx.Request.Context()
	roleInfoDataJSON := new(datas.RoleInfoDataJSON)
	roleInfoList := system.GetRole(ctx)
	fmt.Println(roleInfoList)
	if len(roleInfoList) == 0 {
		roleInfoDataJSON.Code = -1
	} else {
		roleInfoDataJSON.Code = 200
		roleInfoDataJSON.RoleInfoList = roleInfoList
	}
	c.GenerateJSON(roleInfoDataJSON)
}

func (c *GetController) GetDeployTree() {
	ctx := c.Ctx.Request.Context()
	roleUid := strings.TrimSpace(c.GetString("roleUid"))
	roleInfo := system.GetRoleByRoleUid(ctx, roleUid)

	allFirstMenu := system.GetMenuAll(ctx)
	sort.Sort(system.MenuInfoSlice(allFirstMenu))
	allSecondMenu := system.GetSecondMenuList(ctx)
	sort.Sort(system.SecondMenuSlice(allSecondMenu))
	allPower := system.GetPower(ctx)

	deployTreeJSON := new(datas.DeployTreeJSON)
	deployTreeJSON.Code = 200
	deployTreeJSON.AllFirstMenu = allFirstMenu
	deployTreeJSON.AllSecondMenu = allSecondMenu
	deployTreeJSON.AllPower = allPower
	deployTreeJSON.ShowFirstMenuUid = make(map[string]bool)
	for _, v := range strings.Split(roleInfo.ShowFirstUid, "||") {
		deployTreeJSON.ShowFirstMenuUid[v] = true
	}
	deployTreeJSON.ShowSecondMenuUid = make(map[string]bool)
	for _, v := range strings.Split(roleInfo.ShowSecondUid, "||") {
		deployTreeJSON.ShowSecondMenuUid[v] = true
	}
	deployTreeJSON.ShowPowerUid = make(map[string]bool)
	for _, v := range strings.Split(roleInfo.ShowPowerUid, "||") {
		deployTreeJSON.ShowPowerUid[v] = true
	}

	c.GenerateJSON(deployTreeJSON)
}

// GetOperator 获取操作员列表
func (c *GetController) GetOperator() {
	ctx := c.Ctx.Request.Context()
	operatorName := strings.TrimSpace(c.GetString("operatorName"))

	params := make(map[string]string)
	params["user_id__icontains"] = operatorName

	l := user.GetOperatorLenByMap(ctx, params)
	c.GetCutPage(l)
	operatorDataJSON := new(datas.OperatorDataJSON)
	operatorDataJSON.DisplayCount = c.DisplayCount
	operatorDataJSON.Code = 200
	operatorDataJSON.CurrentPage = c.CurrentPage
	operatorDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		operatorDataJSON.OperatorList = make([]user.UserInfo, 0)
		c.GenerateJSON(operatorDataJSON)
		return
	}

	operatorDataJSON.StartIndex = c.Offset
	operatorDataJSON.OperatorList = user.GetOperatorByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(operatorDataJSON)
}

func (c *GetController) GetOneOperator() {
	ctx := c.Ctx.Request.Context()
	userId := strings.TrimSpace(c.GetString("userId"))

	userInfo := user.GetUserInfoByUserID(ctx, userId)

	operatorDataJSON := new(datas.OperatorDataJSON)
	operatorDataJSON.OperatorList = make([]user.UserInfo, 0)
	operatorDataJSON.OperatorList = append(operatorDataJSON.OperatorList, userInfo)

	operatorDataJSON.Code = 200

	c.GenerateJSON(operatorDataJSON)
}

func (c *GetController) GetEditOperator() {
	ctx := c.Ctx.Request.Context()
	userId := strings.TrimSpace(c.GetString("userId"))

	editOperatorDataJSON := new(datas.EditOperatorDataJSON)
	userInfo := user.GetUserInfoByUserID(ctx, userId)
	fmt.Println(userInfo)
	editOperatorDataJSON.OperatorList = append(editOperatorDataJSON.OperatorList, userInfo)
	editOperatorDataJSON.RoleList = system.GetRole(ctx)
	editOperatorDataJSON.Code = 200

	c.GenerateJSON(editOperatorDataJSON)
}

func (c *GetController) GetBankCard() {
	ctx := c.Ctx.Request.Context()
	accountNameSearch := strings.TrimSpace(c.GetString("accountNameSearch"))
	params := make(map[string]string)
	params["account_name__icontains"] = accountNameSearch

	l := system.GetBankCardLenByMap(ctx, params)
	c.GetCutPage(l)

	bankCardDataJSON := new(datas.BankCardDataJSON)
	bankCardDataJSON.DisplayCount = c.DisplayCount
	bankCardDataJSON.Code = 200
	bankCardDataJSON.CurrentPage = c.CurrentPage
	bankCardDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		bankCardDataJSON.BankCardInfoList = make([]system.BankCardInfo, 0)
		c.GenerateJSON(bankCardDataJSON)
		return
	}

	bankCardDataJSON.StartIndex = c.Offset
	bankCardDataJSON.BankCardInfoList = system.GetBankCardByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(bankCardDataJSON)
}

func (c *GetController) GetOneBankCard() {
	ctx := c.Ctx.Request.Context()
	uid := strings.TrimSpace(c.GetString("uid"))
	bankCardInfo := system.GetBankCardByUid(ctx, uid)

	bankCardDataJSON := new(datas.BankCardDataJSON)
	bankCardDataJSON.Code = -1

	if bankCardInfo.Uid != "" {
		bankCardDataJSON.BankCardInfoList = append(bankCardDataJSON.BankCardInfoList, bankCardInfo)
		bankCardDataJSON.Code = 200
	}

	c.GenerateJSON(bankCardDataJSON)
}

// GetRoad 获取通道
func (c *GetController) GetRoad() {
	ctx := c.Ctx.Request.Context()
	roadName := strings.TrimSpace(c.GetString("roadName"))
	productName := strings.TrimSpace(c.GetString("productName"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))
	payType := strings.TrimSpace(c.GetString("payType"))
	roadPoolCode := strings.TrimSpace(c.GetString("roadPoolCode"))

	params := make(map[string]string)
	params["road_name__icontains"] = roadName
	params["product_name__icontains"] = productName
	params["road_uid"] = roadUid
	params["pay_type"] = payType

	l := road.GetRoadLenByMap(ctx, params)
	c.GetCutPage(l)

	roadDataJSON := new(datas.RoadDataJSON)
	roadDataJSON.DisplayCount = c.DisplayCount
	roadDataJSON.Code = 200
	roadDataJSON.CurrentPage = c.CurrentPage
	roadDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		roadDataJSON.RoadInfoList = make([]road.RoadInfo, 0)
		c.GenerateJSON(roadDataJSON)
		return
	}

	roadDataJSON.StartIndex = c.Offset
	roadDataJSON.RoadInfoList = road.GetRoadInfoByMap(ctx, params, c.DisplayCount, c.Offset)
	roadDataJSON.RoadPool = road.GetRoadPoolByRoadPoolCode(ctx, roadPoolCode)
	c.GenerateJSON(roadDataJSON)
}

func (c *GetController) GetAllRoad() {
	ctx := c.Ctx.Request.Context()
	roadName := strings.TrimSpace(c.GetString("roadName"))
	params := make(map[string]string)
	if roadName != "" {
		params["road_name__icontains"] = roadName
	}

	roadDataJSON := new(datas.RoadDataJSON)
	roadInfoList := road.GetAllRoad(ctx, params)

	roadDataJSON.Code = 200
	roadDataJSON.RoadInfoList = roadInfoList
	c.GenerateJSON(roadDataJSON)
}

// GetOneRoad 获取单个通道
func (c *GetController) GetOneRoad() {
	ctx := c.Ctx.Request.Context()
	roadUid := strings.TrimSpace(c.GetString("roadUid"))

	roadInfo := road.GetRoadInfoByRoadUid(ctx, roadUid)
	roadDataJSON := new(datas.RoadDataJSON)
	roadDataJSON.Code = -1

	if roadInfo.RoadUid != "" {
		roadDataJSON.RoadInfoList = append(roadDataJSON.RoadInfoList, roadInfo)
		roadDataJSON.Code = 200
	} else {
		roadDataJSON.RoadInfoList = make([]road.RoadInfo, 0)
	}

	c.GenerateJSON(roadDataJSON)
}

func (c *GetController) GetRoadPool() {
	ctx := c.Ctx.Request.Context()
	roadPoolName := strings.TrimSpace(c.GetString("roadPoolName"))
	roadPoolCode := strings.TrimSpace(c.GetString("roadPoolCode"))

	params := make(map[string]string)
	params["road_pool_name__icontains"] = roadPoolName
	params["road_pool_code__icontains"] = roadPoolCode

	l := road.GetRoadPoolLenByMap(ctx, params)
	c.GetCutPage(l)

	roadPoolDataJSON := new(datas.RoadPoolDataJSON)
	roadPoolDataJSON.DisplayCount = c.DisplayCount
	roadPoolDataJSON.Code = 200
	roadPoolDataJSON.CurrentPage = c.CurrentPage
	roadPoolDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		roadPoolDataJSON.RoadPoolInfoList = make([]road.RoadPoolInfo, 0)
		c.GenerateJSON(roadPoolDataJSON)
		return
	}

	roadPoolDataJSON.StartIndex = c.Offset
	roadPoolDataJSON.RoadPoolInfoList = road.GetRoadPoolByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(roadPoolDataJSON)
}

func (c *GetController) GetAllRollPool() {
	ctx := c.Ctx.Request.Context()
	rollPoolName := strings.TrimSpace(c.GetString("rollPoolName"))
	params := make(map[string]string)
	params["road_pool_name__icontains"] = rollPoolName

	roadPoolDataJSON := new(datas.RoadPoolDataJSON)
	roadPoolDataJSON.Code = 200
	roadPoolDataJSON.RoadPoolInfoList = road.GetAllRollPool(ctx, params)
	c.GenerateJSON(roadPoolDataJSON)
}

func (c *GetController) GetMerchant() {
	ctx := c.Ctx.Request.Context()
	merchantName := strings.TrimSpace(c.GetString("merchantName"))
	merchantNo := strings.TrimSpace(c.GetString("merchantNo"))

	params := make(map[string]string)
	params["merchant_name__icontains"] = merchantName
	params["merchant_uid__icontains"] = merchantNo

	l := merchant.GetMerchantLenByMap(ctx, params)
	c.GetCutPage(l)

	merchantDataJSON := new(datas.MerchantDataJSON)
	merchantDataJSON.DisplayCount = c.DisplayCount
	merchantDataJSON.Code = 200
	merchantDataJSON.CurrentPage = c.CurrentPage
	merchantDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		merchantDataJSON.MerchantList = make([]merchant.MerchantInfo, 0)
		c.GenerateJSON(merchantDataJSON)
		return
	}

	merchantDataJSON.StartIndex = c.Offset
	merchantDataJSON.MerchantList = merchant.GetMerchantListByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(merchantDataJSON)
}

func (c *GetController) GetAllMerchant() {
	ctx := c.Ctx.Request.Context()
	merchantDataJSON := new(datas.MerchantDataJSON)
	merchantDataJSON.Code = 200
	merchantDataJSON.MerchantList = merchant.GetAllMerchant(ctx)
	c.GenerateJSON(merchantDataJSON)
}

func (c *GetController) GetOneMerchant() {
	ctx := c.Ctx.Request.Context()
	merchantUid := strings.TrimSpace(c.GetString("merchantUid"))
	merchantDataJSON := new(datas.MerchantDataJSON)

	if merchantUid == "" {
		merchantDataJSON.Code = -1
		c.GenerateJSON(merchantDataJSON)
		return
	}

	merchantInfo := merchant.GetMerchantByUid(ctx, merchantUid)

	merchantDataJSON.Code = 200
	merchantDataJSON.MerchantList = append(merchantDataJSON.MerchantList, merchantInfo)
	c.GenerateJSON(merchantDataJSON)
}

func (c *GetController) GetOneMerchantDeploy() {
	ctx := c.Ctx.Request.Context()
	merchantNo := strings.TrimSpace(c.GetString("merchantNo"))
	payType := strings.TrimSpace(c.GetString("payType"))

	merchantDeployDataJSON := new(datas.MerchantDeployDataJSON)

	merchantDeployInfo := merchant.GetMerchantDeployByUidAndPayType(ctx, merchantNo, payType)

	if merchantDeployInfo.Status == "active" {
		merchantDeployDataJSON.Code = 200
		merchantDeployDataJSON.MerchantDeploy = merchantDeployInfo
	} else {
		merchantDeployDataJSON.Code = -1
		merchantDeployDataJSON.MerchantDeploy = merchantDeployInfo
	}

	c.GenerateJSON(merchantDeployDataJSON)
}

func (c *GetController) GetAllAccount() {
	ctx := c.Ctx.Request.Context()
	accountDataJSON := new(datas.AccountDataJSON)
	accountDataJSON.Code = 200

	accountDataJSON.AccountList = accounts.GetAllAccount(ctx)

	c.GenerateJSON(accountDataJSON)
}

func (c *GetController) GetAccount() {
	ctx := c.Ctx.Request.Context()
	accountName := strings.TrimSpace(c.GetString("accountName"))
	accountUid := strings.TrimSpace(c.GetString("accountNo"))

	params := make(map[string]string)
	params["account_name__icontains"] = accountName
	params["account_uid_icontains"] = accountUid

	l := accounts.GetAccountLenByMap(ctx, params)
	c.GetCutPage(l)

	accountDataJSON := new(datas.AccountDataJSON)
	accountDataJSON.DisplayCount = c.DisplayCount
	accountDataJSON.Code = 200
	accountDataJSON.CurrentPage = c.CurrentPage
	accountDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		accountDataJSON.AccountList = make([]accounts.AccountInfo, 0)
		c.GenerateJSON(accountDataJSON)
		return
	}

	accountDataJSON.StartIndex = c.Offset
	accountDataJSON.AccountList = accounts.GetAccountByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(accountDataJSON)
}

func (c *GetController) GetOneAccount() {
	ctx := c.Ctx.Request.Context()
	//从http的body中获取accountUid字段，并且这个字段是string类型
	accountUid := strings.TrimSpace(c.GetString("accountUid"))
	//new一个accountDataJSON结构体对象，用来做jsonp返回
	accountDataJSON := new(datas.AccountDataJSON)
	//用accountuid作为过滤字段，从数据库中读取一条信息
	accountInfo := accounts.GetAccountByUid(ctx, accountUid)
	//code初始值为200
	accountDataJSON.Code = 200
	//将从数据库读出来的数据插入到accountList数组中
	accountDataJSON.AccountList = append(accountDataJSON.AccountList, accountInfo)
	//返回jsonp格式的数据给前端
	c.GenerateJSON(accountDataJSON)
}

func (c *GetController) GetAccountHistory() {
	ctx := c.Ctx.Request.Context()
	accountName := strings.TrimSpace(c.GetString("accountHistoryName"))
	accountUid := strings.TrimSpace(c.GetString("accountHistoryNo"))
	operatorType := strings.TrimSpace(c.GetString("operatorType"))
	startTime := c.GetString("startTime")
	endTime := c.GetString("endTime")

	switch operatorType {
	case "plus-amount":
		operatorType = common.PLUS_AMOUNT
	case "sub-amount":
		operatorType = common.SUB_AMOUNT
	case "freeze-amount":
		operatorType = common.FREEZE_AMOUNT
	case "unfreeze-amount":
		operatorType = common.UNFREEZE_AMOUNT
	}
	params := make(map[string]string)
	params["account_name__icontains"] = accountName
	params["account_uid__icontains"] = accountUid
	params["type"] = operatorType
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime

	l := accounts.GetAccountHistoryLenByMap(ctx, params)
	c.GetCutPage(l)

	accountHistoryDataJSON := new(datas.AccountHistoryDataJSON)
	accountHistoryDataJSON.DisplayCount = c.DisplayCount
	accountHistoryDataJSON.Code = 200
	accountHistoryDataJSON.CurrentPage = c.CurrentPage
	accountHistoryDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		accountHistoryDataJSON.AccountHistoryList = make([]accounts.AccountHistoryInfo, 0)
		c.GenerateJSON(accountHistoryDataJSON)
		return
	}

	accountHistoryDataJSON.StartIndex = c.Offset
	accountHistoryDataJSON.AccountHistoryList = accounts.GetAccountHistoryByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(accountHistoryDataJSON)
}

func (c *GetController) GetAgent() {
	ctx := c.Ctx.Request.Context()
	agentName := strings.TrimSpace(c.GetString("agentName"))
	params := make(map[string]string)
	params["agnet_name__icontains"] = agentName

	l := agent.GetAgentInfoLenByMap(ctx, params)
	c.GetCutPage(l)

	agentDataJSON := new(datas.AgentDataJSON)
	agentDataJSON.DisplayCount = c.DisplayCount
	agentDataJSON.Code = 200
	agentDataJSON.CurrentPage = c.CurrentPage
	agentDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		agentDataJSON.AgentList = make([]agent.AgentInfo, 0)
		c.GenerateJSON(agentDataJSON)
		return
	}

	agentDataJSON.StartIndex = c.Offset
	agentDataJSON.AgentList = agent.GetAgentInfoByMap(ctx, params, c.DisplayCount, c.Offset)
	c.GenerateJSON(agentDataJSON)
}

func (c *GetController) GetAllAgent() {
	ctx := c.Ctx.Request.Context()
	agentName := strings.TrimSpace(c.GetString("agentName"))
	params := make(map[string]string)
	params["agent_name__icontains"] = agentName

	agentDataJSON := new(datas.AgentDataJSON)
	agentDataJSON.Code = 200
	agentDataJSON.AgentList = agent.GetAllAgentByMap(ctx, params)

	c.GenerateJSON(agentDataJSON)
}

func (c *GetController) GetProduct() {
	supplierCode2Name := common.GetSupplierMap()
	productDataJSON := new(datas.ProductDataJSON)
	productDataJSON.Code = 200
	productDataJSON.ProductMap = supplierCode2Name
	c.GenerateJSON(productDataJSON)
}

func (c *GetController) GetAgentToMerchant() {
	ctx := c.Ctx.Request.Context()
	agentUid := strings.TrimSpace(c.GetString("agentUid"))
	merchantUid := strings.TrimSpace(c.GetString("merchantUid"))

	params := make(map[string]string)
	params["belong_agent_uid"] = agentUid
	params["merchant_uid"] = merchantUid

	l := merchant.GetMerchantLenByParams(ctx, params)
	c.GetCutPage(l)

	merchantDataJSON := new(datas.MerchantDataJSON)
	merchantDataJSON.DisplayCount = c.DisplayCount
	merchantDataJSON.Code = 200
	merchantDataJSON.CurrentPage = c.CurrentPage
	merchantDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		merchantDataJSON.MerchantList = make([]merchant.MerchantInfo, 0)
	} else {
		merchantDataJSON.MerchantList = merchant.GetMerchantByParams(ctx, params, c.DisplayCount, c.Offset)
	}

	c.GenerateJSON(merchantDataJSON)
}

// GetOrder 获取订单数据
func (c *GetController) GetOrder() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantName := strings.TrimSpace(c.GetString("merchantName"))
	orderNo := strings.TrimSpace(c.GetString("merchantOrderId"))
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	status := strings.TrimSpace(c.GetString("orderStatus"))
	supplierUid := strings.TrimSpace(c.GetString("supplierUid"))
	payWayCode := strings.TrimSpace(c.GetString("payWayCode"))
	freeStatus := strings.TrimSpace(c.GetString("freeStatus"))
	cardData := strings.TrimSpace(c.GetString("cardData"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))
	poolCodeId := strings.TrimSpace(c.GetString("poolCodeId"))
	message := strings.TrimSpace(c.GetString("message"))
	hideDuplicateCard := strings.TrimSpace(c.GetString("hideDuplicateCard"))

	params := make(map[string]string)
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime
	params["merchant_name__icontains"] = merchantName
	params["merchant_order_id__icontains"] = orderNo
	params["bank_order_id__icontains"] = bankOrderId
	params["status"] = status
	params["pay_product_code"] = supplierUid
	params["pay_type_code"] = payWayCode
	params["ex_value__icontains"] = cardData
	params["road_uid"] = roadUid
	params["pool_order_id__icontains"] = poolCodeId
	params["card_return_data__icontains"] = message

	if hideDuplicateCardBool, err := convertor.ToBool(hideDuplicateCard); err != nil {
		if hideDuplicateCardBool {
			params["is_replace"] = "1"
		} else {
			params["is_replace"] = "0"
		}
	}

	switch freeStatus {
	case "free":
		params["free"] = "yes"
	case "unfree":
		params["unfree"] = "yes"
	case "refund":
		params["refund"] = "yes"
	}
	l := order.GetOrderLenByMap(ctx, params)
	c.GetCutPage(l)
	orderDataJSON := new(datas.OrderDataJSON)
	orderDataJSON.DisplayCount = c.DisplayCount
	orderDataJSON.Code = 200
	orderDataJSON.CurrentPage = c.CurrentPage
	orderDataJSON.TotalPage = c.TotalPage
	if c.Offset < 0 {
		orderDataJSON.OrderList = make([]datas.OrderInfoWithRoadInfo, 0)
		c.GenerateJSON(orderDataJSON)
		return
	}
	orderDataJSON.StartIndex = c.Offset
	orderList := order.GetOrderByMap(ctx, params, int64(c.DisplayCount), int64(c.Offset))
	slice.ForEach(orderList, func(i int, v order.OrderInfo) {
		orderDataJSON.OrderList = append(orderDataJSON.OrderList, datas.OrderInfoWithRoadInfo{
			OrderInfo: v,
			RoadInfo:  road.GetRoadInfoByRoadUid(ctx, v.RoadUid),
		})
	})
	params["status"] = common.OrderStatusSuccess
	c.GenerateJSON(orderDataJSON)
}

func (c *GetController) GetOrderExport() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantName := strings.TrimSpace(c.GetString("merchantName"))
	orderNo := strings.TrimSpace(c.GetString("merchantOrderId"))
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	status := strings.TrimSpace(c.GetString("orderStatus"))
	supplierUid := strings.TrimSpace(c.GetString("supplierUid"))
	payWayCode := strings.TrimSpace(c.GetString("payWayCode"))
	freeStatus := strings.TrimSpace(c.GetString("freeStatus"))
	cardData := strings.TrimSpace(c.GetString("cardData"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))

	params := make(map[string]string)
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime
	params["merchant_name__icontains"] = merchantName
	params["merchant_order_id"] = orderNo
	params["bank_order_id"] = bankOrderId
	params["status"] = status
	params["pay_product_code"] = supplierUid
	params["pay_type_code"] = payWayCode
	params["ex_value__icontains"] = cardData
	params["road_uid"] = roadUid
	switch freeStatus {
	case "free":
		params["free"] = "yes"
	case "unfree":
		params["unfree"] = "yes"
	case "refund":
		params["refund"] = "yes"
	}

	orderList := order.GetOrderAllByMap(ctx, params)
	excel := excelize.NewFile()
	sheetName, _ := excel.NewSheet("Sheet1")
	excel.SetActiveSheet(sheetName)

	_ = excel.SetCellValue("Sheet1", "A1", "订单号")
	_ = excel.SetCellValue("Sheet1", "B1", "商户订单号")
	_ = excel.SetCellValue("Sheet1", "C1", "卡号")
	_ = excel.SetCellValue("Sheet1", "D1", "卡密")
	_ = excel.SetCellValue("Sheet1", "E1", "面额")
	_ = excel.SetCellValue("Sheet1", "F1", "实付金额")
	_ = excel.SetCellValue("Sheet1", "G1", "支付状态")
	_ = excel.SetCellValue("Sheet1", "H1", "上游返回数据")

	slice.ForEachConcurrent(orderList, func(i int, v order.OrderInfo) {
		var redeemCardInfo struct {
			Data   string `json:"data,omitempty"`   // 卡密
			CardNo string `json:"cardNo,omitempty"` // 卡号
		}
		err := json.Unmarshal([]byte(v.ExValue), &redeemCardInfo)
		if err != nil {
			logs.Error("json unmarshal fail: ", err)
			redeemCardInfo.CardNo = ""
			redeemCardInfo.Data = ""
		}
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("A%d", i+2), v.BankOrderId)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("B%d", i+2), v.MerchantOrderId)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("C%d", i+2), redeemCardInfo.CardNo)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("D%d", i+2), redeemCardInfo.Data)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("E%d", i+2), v.OrderAmount)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("F%d", i+2), v.FactAmount)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("G%d", i+2), v.Status)
		_ = excel.SetCellValue("Sheet1", fmt.Sprintf("H%d", i+2), v.CardReturnData)

	}, 10)

	excel.Close()
	fileName := fmt.Sprintf("订单导出-%s.xlsx", time.Now().Format("2006-01-02 15:04:05"))

	c.Ctx.Output.Header("Content-Disposition", "attachment; filename="+fileName)
	c.Ctx.Output.Header("Content-Description", "File Transfer")
	c.Ctx.Output.Header("Content-Type", "application/octet-stream")
	c.Ctx.Output.Header("Content-Transfer-Encoding", "binary")
	c.Ctx.Output.Header("Expires", "0")
	c.Ctx.Output.Header("Cache-Control", "must-revalidate")
	c.Ctx.Output.Header("Pragma", "public")
	_ = excel.Write(c.Ctx.ResponseWriter)
	c.StopRun()
}

// GetOrderSummary 获取订单统计数据
func (c *GetController) GetOrderSummary() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantName := strings.TrimSpace(c.GetString("merchantName"))
	orderNo := strings.TrimSpace(c.GetString("merchantOrderId"))
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	status := strings.TrimSpace(c.GetString("orderStatus"))
	supplierUid := strings.TrimSpace(c.GetString("supplierUid"))
	payWayCode := strings.TrimSpace(c.GetString("payWayCode"))
	freeStatus := strings.TrimSpace(c.GetString("freeStatus"))
	cardData := strings.TrimSpace(c.GetString("cardData"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))
	message := strings.TrimSpace(c.GetString("message"))

	params := make(map[string]string)
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime
	params["merchant_name__icontains"] = merchantName
	params["merchant_order_id__icontains"] = orderNo
	params["bank_order_id__icontains"] = bankOrderId
	params["status"] = status
	params["pay_product_code"] = supplierUid
	params["pay_type_code"] = payWayCode
	params["ex_value__icontains"] = cardData
	params["road_uid"] = roadUid
	params["card_return_data__icontains"] = message
	hideDuplicateCard := strings.TrimSpace(c.GetString("hideDuplicateCard"))
	if hideDuplicateCardBool, err := convertor.ToBool(hideDuplicateCard); err != nil {
		if hideDuplicateCardBool {
			params["is_replace"] = "1"
		} else {
			params["is_replace"] = "0"
		}
	}
	switch freeStatus {
	case "free":
		params["free"] = "yes"
	case "unfree":
		params["unfree"] = "yes"
	case "refund":
		params["refund"] = "yes"
	}

	orderDataJSON := new(datas.OrderDataSummaryJSON)
	orderDataJSON.OrderProfitSummary = order.ProfitSummary{
		TotalProfit: service.QueryTotalSummary(ctx, params),
		TodayProfit: service.QueryTodaySummary(ctx, params),
	}
	c.GenerateJSON(orderDataJSON)
}

func (c *GetController) GetOneOrder() {
	ctx := c.Ctx.Request.Context()
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	orderDataJSON := new(datas.OrderDataJSON)
	orderInfo := order.GetOneOrder(ctx, bankOrderId)

	orderDataJSON.Code = 200
	orderDataJSON.OrderList = append(orderDataJSON.OrderList, datas.OrderInfoWithRoadInfo{
		OrderInfo: orderInfo,
		RoadInfo:  road.GetRoadInfoByRoadUid(ctx, orderInfo.RoadUid),
	})
	notifyInfo := notify.GetNotifyInfoByBankOrderId(ctx, bankOrderId)
	if notifyInfo.Url == "" || len(notifyInfo.Url) == 0 {
		orderDataJSON.NotifyUrl = orderInfo.NotifyUrl
	} else {
		orderDataJSON.NotifyUrl = notifyInfo.Url
	}
	c.GenerateJSON(orderDataJSON)
}

func (c *GetController) GetOrderProfit() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantName := strings.TrimSpace(c.GetString("merchantName"))
	agentName := strings.TrimSpace(c.GetString("agentName"))
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	status := strings.TrimSpace(c.GetString("orderStatus"))
	supplierUid := strings.TrimSpace(c.GetString("supplierUid"))
	payWayCode := strings.TrimSpace(c.GetString("payWayCode"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))

	params := make(map[string]interface{})
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime
	params["merchant_name__icontains"] = merchantName
	params["agent_name__icontains"] = agentName
	params["bank_order_id"] = bankOrderId
	params["status"] = status
	params["pay_product_code"] = supplierUid
	params["pay_type_code"] = payWayCode
	orderList := order.GetAllOrderByMap(ctx, map[string]string{"road_uid": roadUid})
	if len(orderList) > 0 {
		orderIDList := make([]string, len(orderList))
		for _, info := range orderList {
			orderIDList = append(orderIDList, info.BankOrderId)
		}
		params["bank_order_id__in"] = orderIDList
	}
	l := order.GetOrderProfitLenByMap(ctx, params)
	c.GetCutPage(l)

	listDataJSON := new(datas.ListDataJSON)
	listDataJSON.DisplayCount = c.DisplayCount
	listDataJSON.Code = 200
	listDataJSON.CurrentPage = c.CurrentPage
	listDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		listDataJSON.List = make([]order.OrderProfitInfo, 0)
		c.GenerateJSON(listDataJSON)
		return
	}

	listDataJSON.StartIndex = c.Offset
	listDataJSON.List = order.GetOrderProfitByMap(ctx, params, c.DisplayCount, c.Offset)

	c.GenerateJSON(listDataJSON)
}

func (c *GetController) GetPayFor() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantOrderId := strings.TrimSpace(c.GetString("merchantOrderId"))
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))
	status := strings.TrimSpace(c.GetString("status"))

	params := make(map[string]string)
	params["create_time__lte"] = endTime
	params["create_time__gte"] = startTime
	params["merchant_order_id"] = merchantOrderId
	params["bank_order_id"] = bankOrderId
	params["status"] = status

	l := payfor.GetPayForLenByMap(ctx, params)
	c.GetCutPage(l)

	listDataJSON := new(datas.PayForDataJSON)
	listDataJSON.DisplayCount = c.DisplayCount
	listDataJSON.Code = 200
	listDataJSON.CurrentPage = c.CurrentPage
	listDataJSON.TotalPage = c.TotalPage

	if c.Offset < 0 {
		listDataJSON.PayForList = make([]payfor.PayforInfo, 0)
		c.GenerateJSON(listDataJSON)
		return
	}

	listDataJSON.StartIndex = c.Offset
	listDataJSON.PayForList = payfor.GetPayForByMap(ctx, params, c.DisplayCount, c.Offset)
	for index, p := range listDataJSON.PayForList {
		if p.MerchantName == "" {
			listDataJSON.PayForList[index].MerchantName = "任意下发"
		}
		if p.MerchantOrderId == "" {
			listDataJSON.PayForList[index].MerchantOrderId = "任意发下"
		}
		if p.RoadName == "" {
			listDataJSON.PayForList[index].RoadName = "无"
		}
	}
	c.GenerateJSON(listDataJSON)
}

func (c *GetController) GetOnePayFor() {
	ctx := c.Ctx.Request.Context()
	bankOrderId := strings.TrimSpace(c.GetString("bankOrderId"))

	payForInfo := payfor.GetPayForByBankOrderId(ctx, bankOrderId)

	listDataJSON := new(datas.PayForDataJSON)
	listDataJSON.Code = 200
	listDataJSON.PayForList = append(listDataJSON.PayForList, payForInfo)

	c.GenerateJSON(listDataJSON)
}

func (c *GetController) GetBalance() {
	/*roadName := strings.TrimSpace(c.GetString("roadName"))
	roadUid := strings.TrimSpace(c.GetString("roadUid"))*/

	/*var roadInfo road.RoadInfo
	if roadUid != "" {
		roadInfo = road.GetRoadInfoByRoadUid(roadUid)
	} else {
		roadInfo = road.GetRoadInfoByName(roadName)
	}*/

	balanceDataJSON := new(datas.BalanceDataJSON)
	balanceDataJSON.Code = 200

	/*supplier := controller.GetPaySupplierByCode(roadInfo.ProductUid)
	if supplier == nil {
		balanceDataJSON.Code = -1
		balanceDataJSON.Balance = -1.00
	} else {
		balance := supplier.BalanceQuery(roadInfo)
		balanceDataJSON.Balance = balance
	}*/
	// TODO 从gateway获取账户余额
	balanceDataJSON.Balance = 1

	c.GenerateJSON(balanceDataJSON)
}

func (c *GetController) GetNotifyBankOrderIdList() {
	ctx := c.Ctx.Request.Context()
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))
	merchantUid := strings.TrimSpace(c.GetString("merchantUid"))
	notifyType := strings.TrimSpace(c.GetString("notifyType"))

	params := make(map[string]string)
	params["create_time__gte"] = startTime
	params["create_time_lte"] = endTime
	params["merchant_uid"] = merchantUid
	params["type"] = notifyType

	bankOrderIdListJSON := new(datas.NotifyBankOrderIdListJSON)
	bankOrderIdListJSON.Code = 200
	bankOrderIdListJSON.NotifyIdList = notify.GetNotifyBankOrderIdListByParams(ctx, params)
	c.GenerateJSON(bankOrderIdListJSON)
}

// GetProfit 获取利润表
func (c *GetController) GetProfit() {
	ctx := c.Ctx.Request.Context()
	merchantUid := strings.TrimSpace(c.GetString("merchantUid"))
	agentUid := strings.TrimSpace(c.GetString("agentUid"))
	supplierUid := strings.TrimSpace(c.GetString("supplierUid"))
	payType := strings.TrimSpace(c.GetString("payType"))
	startTime := strings.TrimSpace(c.GetString("startTime"))
	endTime := strings.TrimSpace(c.GetString("endTime"))

	params := make(map[string]string)
	params["merchant_uid"] = merchantUid
	params["agent_uid"] = agentUid
	params["pay_product_code"] = supplierUid
	params["pay_type_code"] = payType
	params["create_time__gte"] = startTime
	params["create_time__lte"] = endTime

	profitListJSON := new(datas.ProfitListJSON)
	profitListJSON.Code = 200
	profitListJSON.ProfitList = order.GetPlatformProfitByMap(ctx, params)

	profitListJSON.TotalAmount = 0.00
	profitListJSON.PlatformTotalProfit = 0.00
	profitListJSON.AgentTotalProfit = 0.00

	for i, p := range profitListJSON.ProfitList {
		profitListJSON.TotalAmount += p.OrderAmount
		profitListJSON.PlatformTotalProfit += p.PlatformProfit
		profitListJSON.AgentTotalProfit += p.AgentProfit
		if p.AgentName == "" {
			p.AgentName = "无代理商"
		}
		profitListJSON.ProfitList[i] = p
	}

	c.GenerateJSON(profitListJSON)
}