fonchain-fiee/pkg/service/order/report.go

package order

import (
	"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/order"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/api/rule"
	"github.com/fonchain_enterprise/fonchain-main/pkg/common/untils/timetool"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"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/vo"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/shopspring/decimal"
	"strconv"
	"strings"
	"time"
)

// ReportsList 提交的报表列表
func ReportsList(c *gin.Context) {
	req := &order.ReportList{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	fmt.Println(userInfo)
	req.Status = []uint64{e.REPORT_PUBLISH}

	res, err := service.OrderProvider.GetReports(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	Tels := &account.UsersByTelRequest{
		Domain: "fontree",
		Tels: []string{
			"13862003100",
			"13773091883",
			"15895559080",
		},
	}
	fmt.Println(res.Data)
	userMap, err := fetchUserMap(c, Tels)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	serializer.ProcessReportReads(res.Data, userMap)
	response := vo.PageResponse{
		Count: res.Count,
		Data:  serializer.BuildReports(res.Data),
	}

	service.Success(c, response)
	return
}

// ReportsMyList 历史周报
func ReportsMyList(c *gin.Context) {
	req := &order.ReportList{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	fmt.Println(userInfo)
	if len(userInfo.PositionUsers) == 0 {
		service.Success(c, vo.PageResponse{
			Count: 0,
			Data:  nil,
		})
		return
	}
	req.Status = []uint64{e.REPORT_PUBLISH}
	departmentIds := []uint64{}
	//todo 判断当前人员是否有出纳权限
	for _, i := range userInfo.PositionUsers {
		tellerRes, _ := service.PositionProvider.DoIHavaAuth(c, &position.DoIHavaAuthRequest{
			Domain:       "fontree",
			UserId:       userInfo.ID,
			Url:          e.SellerTellerKey,
			DepartmentID: i.DepartmentId,
		})
		if tellerRes.Hava == true {
			departmentIds = append(departmentIds, i.DepartmentId)
		}
	}
	if len(departmentIds) == 0 {
		service.Success(c, vo.PageResponse{
			Count: 0,
			Data:  nil,
		})
		return
	}
	req.SiteIds = departmentIds
	res, err := service.OrderProvider.GetReports(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	response := vo.PageResponse{
		Count: res.Count,
		Data:  serializer.BuildReports(res.Data),
	}

	service.Success(c, response)
	return
}

func ReportRe(c *gin.Context) {
	req := &order.SetStatusRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Status = e.REPORT_NEED_CASHIER_SURE

	res, err := service.OrderProvider.SetReportStatus(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	detailReq := &order.ReportDetail{ID: req.ID}

	detailRes, err := service.OrderProvider.GetReport(c, detailReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	fmt.Println(detailRes)
	if len(detailRes.ReportUsers) > 0 {
		var users []*order.ReportUserRequest

		for _, tt := range detailRes.ReportUsers {
			temp := &order.ReportUserRequest{
				ID:        tt.ID,
				DueAmount: "0",
			}
			users = append(users, temp)
		}

		upReq := &order.UpdateReportUserList{Data: users}

		res, err = service.OrderProvider.UpdateReportUsers(c, upReq)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
	}

	service.Success(c, res)
	return
}

func ReportSure(c *gin.Context) {
	req := &order.SetStatusRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	req.Status = e.REPORT_NEED_BOSS_SURE

	res, err := service.OrderProvider.SetReportStatus(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

// ReportUsersUpdate 提交的报表列表
func ReportUsersUpdate(c *gin.Context) {
	req := &order.UpdateReportUserList{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.OrderProvider.UpdateReportUsers(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	err = MakeReportSure(c, req.ID, e.REPORT_CASHIER_FINAL_OPTION)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

// CashierReportsList 出纳查看列表
func CashierReportsList(c *gin.Context) {

	var saleSites []string
	req := &order.ReportList{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	if len(req.Status) == 0 {
		req.Status = []uint64{e.REPORT_NEED_CASHIER_SURE, e.REPORT_NEED_BOSS_SURE, e.REPORT_CASHIER_FINAL_OPTION}
	}

	userInfo := login.GetUserInfoFromC(c)
	for _, tt := range userInfo.PositionUsers {
		saleSites = append(saleSites, tt.DepartmentName)
	}

	req.SaleSites = saleSites
	//req.SaleSite = userInfo.PositionUsers[0].DepartmentName

	res, err := service.OrderProvider.GetReports(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	fmt.Println(res.Data)

	response := vo.PageResponse{
		Count: res.Count,
		Data:  serializer.BuildReports(res.Data),
	}

	service.Success(c, response)
	return
}

// ReportUsers 提交的销售报表列表
func ReportUsers(c *gin.Context) {
	req := &order.ReportUserList{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.OrderProvider.GetReportUsers(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	if userInfo.TelNum == "13773091883" || userInfo.TelNum == "15895559080" || userInfo.TelNum == "13862003100" {
		orderRead := &order.ReportReadRequest{
			UserId:   userInfo.ID,
			ReportId: req.ReportId,
			UserName: userInfo.NickName,
		}
		_, err = service.OrderProvider.ReportRead(c, orderRead)
		if err != nil {
			fmt.Println(err)
		}
	}
	getUserMap(c, res.Data)

	response := vo.PageResponse{
		Count: res.Count,
		Data:  serializer.BuildReportUsers(res.Data),
	}

	service.Success(c, response)
	return
}

// DownOrders 下载报表
func DownOrders(c *gin.Context) {
	StartDate := c.DefaultQuery("StartDate", "")
	EndDate := c.DefaultQuery("EndDate", "")
	SaleSite := c.DefaultQuery("SaleSite", "")
	IdsString := c.DefaultQuery("IDs", "")
	StartPayDate := c.DefaultQuery("StartPayDate", "")
	EndPayDate := c.DefaultQuery("EndPayDate", "")
	StartArrivalDate := c.DefaultQuery("StartArrivalDate", "")
	EndArrivalDate := c.DefaultQuery("EndArrivalDate", "")
	PayType := c.DefaultQuery("PayType", "")
	var ids []string
	if IdsString != "" {
		ids = strings.Split(IdsString, ",")
	}
	payTypeInt := 0
	if PayType != "" {
		payTypeInt, _ = strconv.Atoi(PayType)
	}
	req := &order.OrderList{
		Page:             1,
		PageSize:         999999,
		StartDate:        StartDate,
		EndDate:          EndDate,
		Ids:              ids,
		SaleSite:         SaleSite,
		StartPayDate:     StartPayDate,
		EndPayDate:       EndPayDate,
		StartArrivalDate: StartArrivalDate,
		EndArrivalDate:   EndArrivalDate,
		PayType:          uint32(payTypeInt),
	}

	fmt.Println(req)

	res, err := service.OrderProvider.GetOrders(c, req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	var data []interface{}
	if len(res.Data) > 0 {
		for i, v := range res.Data {
			var artworkTypeString = "一手画"
			var payTypeString = query.GetPayTypeString(v.PayType)
			var isOutSeller = "否"
			if v.ArtworkType == 2 {
				artworkTypeString = "二手画"
			}

			if v.IsOutSeller == 1 {
				isOutSeller = "是"
			}

			temp := query.DownOrderColumnName{
				Index:             fmt.Sprintf("%d", i+1),
				ClientName:        v.ClientName,
				ClientIdNum:       v.ClientIdNum,
				ArtistName:        v.ArtistName,
				BuyerName:         v.BuyerName,
				BuyerIdNum:        v.BuyerIdNum,
				OrderNum:          v.OrderNum,
				ArtworkNum:        v.ArtworkNum,
				ArtworkName:       v.ArtworkName,
				ArtworkTypeString: artworkTypeString,
				ArtworkSellNum:    v.ArtworkSellNum,
				EntryYear:         v.EntryYear,
				EntryMonth:        v.EntryMonth,
				SellTime:          timetool.GetYmdFromString(v.SellTime),
				PayDate:           v.PayDate,
				SignDate:          v.SignDate,
				ArrivalDate:       v.ArrivalDate,
				PayTypeString:     payTypeString,
				Bank:              v.Bank,
				ArtworkSize:       v.ArtworkSize,
				Price:             v.Price,
				CopyrightFee:      v.CopyrightFee,
				EntrustPrice:      v.EntrustPrice,
				PersonTax:         v.PersonTax,
				//Commission:        v.Commission,
				//AfterTaxIncome:    v.AfterTaxIncome,
				Commission:        "",
				AfterTaxIncome:    "",
				SaleSite:          v.SaleSite,
				SellerName:        v.SellerName,
				RecordCompany:     v.RecordCompany,
				ShowName:          v.ShowName,
				IsOutSellerString: isOutSeller,
				ShowRegion:        v.ShowRegion,
				CompanyRegion:     v.CompanyRegion,
				//EntrustStartDate:   v.EntrustStartDate,
				//EntrustEndDate:     v.EntrustEndDate,
				//RetrievalStartDate: v.RetrievalStartDate,
				//RetrievalEndDate:   v.RetrievalEndDate,
				MerchantNo: v.MerchantNo,
				Remark:     v.Remark,
			}
			data = append(data, &temp)
		}
	}
	fmt.Println(data)
	content := utils.ToExcel(query.OrderColumnName, data, "struct")

	utils.ResponseXls(c, content, query.OrderUserExcelName)
	return
}

// DownReportUsers 下载报表
func DownReportUsers(c *gin.Context) {
	id := c.Query("id")
	parseInt, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if parseInt == 0 {
		service.Error(c, e.Error, errors.New(e.GetMsg(e.InvalidParams)))
		return
	}

	req := &order.ReportUserList{
		ReportId: uint64(parseInt),
		Page:     1,
		PageSize: 999999,
	}

	res, err := service.OrderProvider.GetReportUsers(c, req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	getUserMap(c, res.Data)

	var data []interface{}
	if len(res.Data) > 0 {
		for _, v := range res.Data {
			remark := " "

			decAmount, err := decimal.NewFromString(v.Amount)
			if err == nil && decAmount.GreaterThanOrEqual(decimal.NewFromInt(150000)) {
				remark = "喜报"
			}

			temp := query.DownReportUser{
				IDNum:          v.SellerNum,
				Name:           v.SellerName,
				Amount:         v.Amount,
				DueAmount:      v.DueAmount,
				IncreaseAmount: v.IncreaseAmount,
				IncreaseRate:   v.IncreaseRate,
				Remark:         remark,
			}
			data = append(data, &temp)
		}
	}
	fmt.Println(data)
	content := utils.ToExcel(query.ReportUserColumnName, data, "struct")

	utils.ResponseXls(c, content, query.ReportUserExcelName)
	return
}

func getUserMap(c *gin.Context, list []*order.ReportUserRequest) {

	var userIds []uint64
	for _, tt := range list {
		userIds = append(userIds, tt.SellerID)
	}

	userMap := make(map[uint64]*account.AccountInfo)

	IdsReq := account.ListByIDsRequest{
		IDs:      userIds,
		PageSize: 999999,
		Page:     1,
	}

	userRes, userErr := service.AccountProvider.ListByIDs(c, &IdsReq)

	if userErr != nil || userRes == nil || len(userRes.Data) == 0 {
		return
	}

	for _, t := range userRes.Data {
		userMap[t.ID] = t
	}

	for index, t := range list {
		if _, ok := userMap[t.SellerID]; ok {
			list[index].SellerAvatar = userMap[t.SellerID].Avatar
			list[index].SellerNum = userMap[t.SellerID].JobNum
		}
	}
	return
}

func MakeReportSure(c *gin.Context, id uint64, status uint64) error {
	req := &order.SetStatusRequest{ID: id}
	req.Status = status

	_, err := service.OrderProvider.SetReportStatus(c, req)
	if err != nil {
		return err
	}
	return nil

}

// BeforeUser 未发布之前的业绩报表
func BeforeUser(c *gin.Context) {
	pageRes := vo.PageRes{
		Count: 0,
	}
	reqJson := &query.ReportCreateQuery{}
	if err := c.ShouldBindBodyWith(&reqJson, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	//todo 判断当前人员是否有出纳权限
	tellerRes, _ := service.PositionProvider.DoIHavaAuth(c, &position.DoIHavaAuthRequest{
		Domain:       "fontree",
		UserId:       userInfo.ID,
		Url:          e.SellerTellerKey,
		DepartmentID: reqJson.DepartmentId,
	})
	if tellerRes.Hava == false {
		service.Success(c, nil)
		return
	}
	////todo 李菲丽账号特殊处理 账号不存在吴江站 但要统计在吴江站总金额下 用户id写死 徐嘉鸿的奇怪需求
	//specialLi := false
	//if reqJson.DepartmentId == 74 {
	//	specialLi = true
	//}
	//0 获取当前提交的now数据
	report, err := GetNowDoingReport(c, reqJson.DepartmentName)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if report != nil {
		pageRes = vo.PageRes{
			Count: uint64(len(report.ReportUsers)),
			Data:  serializer.BuildReportUsers(report.ReportUsers),
		}

		service.Success(c, pageRes)
		return
	}
	ReportQuery := &order.ReportQueryRequest{
		EndDate:        reqJson.EndDate,
		StartDate:      reqJson.StartDate,
		EndDateDue:     reqJson.EndDateDue,
		StartDateDue:   reqJson.StartDateDue,
		DepartmentName: reqJson.DepartmentName,
		DepartmentId:   reqJson.DepartmentId,
	}
	repReq := &order.ReportList{
		SiteIds: []uint64{reqJson.DepartmentId},
	}
	reportRes, _ := service.OrderProvider.GetReports(c, repReq)
	if len(reportRes.Data) == 0 {
		ReportQuery.Success = true
	} else {
		ReportQuery.Success = false
	}
	reportQuery, _ := service.OrderProvider.GetReportQuery(c, ReportQuery)
	reqJson.EndDate = reportQuery.EndDate
	reqJson.StartDateDue = reportQuery.StartDateDue
	reqJson.EndDateDue = reportQuery.EndDateDue
	if ReportQuery.Success == false {
		reqJson.StartDate = reportQuery.StartDate
	}

	//1 没有now数据，实时获取数据
	req := &order.ReportCreateRequest{
		SaleSite:   reqJson.SaleSite,
		Status:     reqJson.Status,
		StartDate:  reqJson.StartDate,
		EndDate:    reqJson.EndDate,
		LeaderId:   reqJson.LeaderId,
		LeaderName: reqJson.LeaderName,
	}

	userReq := &rule.FindByUrlRequest{
		Url:           e.SellerStaffKey,
		Domain:        "fontree",
		DepartmentIds: []uint64{reqJson.DepartmentId},
	}

	user, err := service.RuleProvider.FindUsersByUrl(c, userReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	for _, i := range user.List {
		fmt.Println("================ service.RuleProvider.FindUsersByUrl =======================", i.UserName, i.UserId)
	}
	//if specialLi {
	//	user.List = append(user.List, &rule.UserInfo{
	//		UserId:   102,
	//		UserName: "李菲莉",
	//	})
	//}
	var staffs []*order.Staff
	var userIds []uint64
	for _, i := range user.List {
		temp := &order.Staff{
			ID:   i.UserId,
			Name: i.UserName,
		}
		staffs = append(staffs, temp)
		userIds = append(userIds, i.UserId)
	}

	if userIds == nil || len(userIds) == 0 {
		service.Success(c, pageRes)
		return
	}

	IdsReq := account.ListByIDsRequest{
		IDs:      userIds,
		PageSize: reqJson.PageSize,
		Page:     reqJson.Page,
	}

	userRes, userErr := service.AccountProvider.ListByIDs(c, &IdsReq)

	if userErr != nil {
		service.Error(c, e.Error, err)
		return
	}
	for _, i := range userRes.Data {
		fmt.Println("================ service.AccountProvider.ListByIDs=======================", i.NickName, i.ID)
	}
	req.Staffs = staffs
	req.LeaderId = userInfo.ID
	req.LeaderName = userInfo.NickName
	req.StartDateDue = reqJson.StartDateDue
	req.EndDateDue = reqJson.EndDateDue
	//depid := &department.DetailRequest{
	//	ID: int64(reqJson.DepartmentId),
	//}
	//siteUid, err := service.DepartmentProvider.Detail(c, depid)
	//req.SiteUid = siteUid.SyncID
	req.SaleSite = reqJson.DepartmentName
	res, err := service.OrderProvider.BeforeCreateUsers(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	for _, i := range res.Data {
		fmt.Println("================ service.AccountProvider.ListByIDs=======================", i.SellerName, i.ID)
	}
	reportUserMap := make(map[uint64]*order.ReportUserRequest)
	processedNames := make(map[string]bool) // 用于记录已经处理过的姓名
	sumAmount := float64(0)
	sumDueAmount := float64(0)
	//sumIncreaseAmount := float64(0)
	for _, i := range res.Data {
		//amount, _ := strconv.ParseFloat(i.Amount, 64)
		//sumAmount += amount
		if processedNames[i.SellerName] {
			continue // 如果姓名已存在，跳过当前记录
		}

		// 标记该姓名已处理
		processedNames[i.SellerName] = true
		sumDue, _ := strconv.ParseFloat(i.DueAmount, 64)
		sumDueAmount += sumDue
		//sumIncrease, _ := strconv.ParseFloat(i.IncreaseAmount, 64)
		//sumIncreaseAmount += sumIncrease
	}
	//if len(res.Data) >= 0 {
	//	data := &order.ReportUserRequest{
	//		SellerID:       0,
	//		Amount:         strconv.FormatFloat(sumAmount, 'f', -1, 64),
	//		DueAmount:      strconv.FormatFloat(sumDueAmount, 'f', -1, 64),
	//		IncreaseAmount: strconv.FormatFloat(sumIncreaseAmount, 'f', -1, 64),
	//		ReportID:       3,
	//		Color:          getColor(sumAmount, sumDueAmount),
	//	}
	//	res.Data = append(res.Data, data)
	//}
	for _, tt := range res.Data {
		reportUserMap[tt.SellerID] = tt
	}
	//列表
	var reportUsers []*vo.ReportUser

	//if len(userRes.Data) >= 0 {
	//	data := &account.AccountInfo{
	//		ID:       0,
	//		NickName: "团队",
	//	}
	//	userRes.Data = append(userRes.Data, data)
	//}
	fmt.Println("================ 销售宝 周报生成前用户=======================", userRes.Data)
	for _, tt := range userRes.Data {
		temp := &order.ReportUserRequest{
			SellerID:       tt.ID,
			SellerName:     tt.NickName,
			SellerNum:      tt.JobNum,
			Amount:         "0",
			DueAmount:      "0",
			IncreaseAmount: "0",
			IncreaseRate:   "1",
		}
		if tt.Status == "left" && reportUserMap[tt.ID].Amount == "0.00" {
			continue
		}
		//if tt.ID == 102 && specialLi {
		//	amli := reportUserMap[tt.ID].Amount
		//	amount, _ := strconv.ParseFloat(amli, 64)
		//	sumAmount += amount
		//	continue
		//}
		if _, ok := reportUserMap[tt.ID]; ok {
			temp.Amount = reportUserMap[tt.ID].Amount
			temp.DueAmount = reportUserMap[tt.ID].DueAmount
			temp.IncreaseRate = reportUserMap[tt.ID].IncreaseRate
			temp.IncreaseAmount = reportUserMap[tt.ID].IncreaseAmount
			temp.Color = reportUserMap[tt.ID].Color
			amount, _ := strconv.ParseFloat(temp.Amount, 64)
			sumAmount += amount
			//sumDue, _ := strconv.ParseFloat(temp.DueAmount, 64)
			//sumDueAmount += sumDue
			//sumIncrease, _ := strconv.ParseFloat(temp.IncreaseAmount, 64)
			//sumIncreaseAmount += sumIncrease
		}
		//sumIncreaseAmount = sumAmount - sumDueAmount
		reportUsers = append(reportUsers, serializer.BuildReportUserReq(temp))
	}

	fmt.Println("================ 销售宝 周报生成后用户=======================", reportUsers)
	reportUsers = append(reportUsers, serializer.BuildReportUserReq(&order.ReportUserRequest{
		SellerID:       0,
		SellerName:     "团队",
		Amount:         strconv.FormatFloat(sumAmount, 'f', -1, 64),
		DueAmount:      strconv.FormatFloat(sumDueAmount, 'f', -1, 64),
		IncreaseAmount: strconv.FormatFloat(sumAmount-sumDueAmount, 'f', -1, 64),
		ReportID:       3,
		Color:          getColor(sumAmount, sumDueAmount),
	}))
	pageRes = vo.PageRes{
		Count:        userRes.Count,
		EndDate:      reqJson.EndDate,
		StartDate:    reqJson.StartDate,
		EndDateDue:   reqJson.EndDateDue,
		StartDateDue: reqJson.StartDateDue,
		Data:         reportUsers,
		DepartmentId: reqJson.DepartmentId,
	}

	service.Success(c, pageRes)

	return
}

// ReportCreate 生成报表
func ReportCreate(c *gin.Context) {
	req := &order.ReportCreateRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)

	req.SaleSite = req.DepartmentName

	userReq := &department.UsersRequest{}

	userReq.ID = req.DepartmentId
	//siteid := &department.DetailRequest{
	//	ID: int64(req.DepartmentId),
	//}
	//siteUid, err := service.DepartmentProvider.Detail(c, siteid)
	//req.SiteUid = siteUid.SyncID

	ures, err := service.DepartmentProvider.Users(c, userReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	//specialLi := false
	//if req.DepartmentId == 74 {
	//	specialLi = true
	//}
	var userIds []uint64
	//if specialLi {
	//	userIds = append(userIds, 102)
	//}
	for _, tt := range ures.Users {
		positionRes, _ := service.PositionProvider.DoIHavaAuth(c, &position.DoIHavaAuthRequest{
			Domain:       "fontree",
			UserId:       tt.UserID,
			Url:          e.SellerStaffKey,
			DepartmentID: req.DepartmentId,
		})
		if positionRes.Hava == false {
			continue
		}
		userIds = append(userIds, tt.UserID)
	}
	if userIds == nil || len(userIds) == 0 {
		service.Error(c, e.Error, err)
		return
	}
	idsReq := &account.ListByIDsRequest{IDs: userIds}

	idRes, err := service.AccountProvider.ListByIDs(c, idsReq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	var staffs []*order.Staff
	for _, tt := range idRes.Data {
		temp := &order.Staff{
			ID:     tt.ID,
			Name:   tt.NickName,
			JobNum: tt.JobNum,
			Status: tt.Status,
		}
		staffs = append(staffs, temp)
	}

	req.Staffs = staffs
	req.LeaderId = userInfo.ID
	req.LeaderName = userInfo.NickName

	res, err := service.OrderProvider.ReportCreate(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	transactionsRes, err := service.OrderProvider.GetTransactions(c, &order.TransactionsRequest{
		Domain:    "fontree",
		StartDate: req.StartDate,
		EndDate:   req.EndDate,
		SaleSites: []string{req.DepartmentName},
		//SaleSiteUid: siteUid.SyncID,
	})
	var ids []uint64
	for _, i := range transactionsRes.Data {
		ids = append(ids, i.ID)
	}
	_, err = service.OrderProvider.UpdateTransactionStage(c, &order.UpdateTransactionStageReq{
		Ids:    ids,
		Status: 2,
	})
	service.Success(c, serializer.BuilderIDRes(res.ID))
	return
}

// ReportPublish 发布报表
func ReportPublish(c *gin.Context) {
	req := &order.ReportDetail{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.OrderProvider.ReportPublic(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

//GetNowDoingReport 获取流程中的报告

func GetNowDoingReport(c *gin.Context, departName string) (*order.ReportRequest, error) {
	// ReportsList 提交的报表列表
	req := &order.ReportList{}

	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	req.SaleSite = departName
	req.Status = []uint64{e.REPORT_NEED_CASHIER_SURE, e.REPORT_NEED_BOSS_SURE, e.REPORT_CASHIER_FINAL_OPTION}
	req.LeaderId = userInfo.ID

	res, err := service.OrderProvider.GetReports(c, req)
	if err != nil {
		return nil, err
	}

	if len(res.Data) > 0 {
		return res.Data[0], nil
	}

	return nil, nil

}

// CheckSalesAmount 查询销售员到期金额
func CheckSalesAmount(c *gin.Context) {
	req := &order.ReportCheckSales{}
	req.SalesmanName = c.Query("salesmanName")

	req.DepartmentName = c.Query("departmentName")
	req.StartDate = c.Query("startDate")
	req.EndDate = c.Query("endDate")
	//userInfoAny, _ := c.Get("jwtInfo")
	//userInfo := userInfoAny.(login.Info)
	//req.DepartmentName = userInfo.DepartmentName
	res, err := service.OrderProvider.GetCheckSalesAmount(c, req)
	//pageRes := vo.PageRes{
	//	Count: res.Money,
	//	//Data: res,
	//}
	if err != nil {
		//return res.Money, err
		service.Success(c, res)
	} else {
		service.Success(c, res)
	}
	//return 0, err
	//
	//service.Success(c, pageRes)
}
func NowReport(c *gin.Context) {
	// ReportsList 提交的报表列表
	depid := c.Query("departmentName")
	report, err := GetNowDoingReport(c, depid)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if report != nil {
		service.Success(c, report)
	} else {
		service.Success(c, struct{}{})
	}

	return
}

// FindDates 查询周报日期
func FindDates(c *gin.Context) {
	req := &order.ReportList{}
	req.SaleSite = c.Query("departmentName")
	req.Status = []uint64{e.REPORT_PUBLISH}
	res, err := service.OrderProvider.GetReports(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	if len(res.Data) == 0 {
		service.Success(c, "")
	}
	if len(res.Data) > 0 {
		lastElement := res.Data[0]
		date, err := time.Parse("2006-01-02", lastElement.EndDate)
		if err != nil {
			fmt.Println("日期解析错误:", err)
			return
		}
		nextDate := date.Add(24 * time.Hour).Format("2006-01-02")
		service.Success(c, nextDate)
	}
	return
}
func getColor(increase, rate float64) string {
	//到期 rate  //当此increase
	if rate == 0 {
		return "newValue"
	} else {
		increaseOverRate := increase / rate
		if increaseOverRate < 1 {
			return "red"
		} else if increaseOverRate < 1.3 && increaseOverRate > 1 {
			return "yellow"
		} else if increaseOverRate >= 1.3 {
			return "green"
		}
	}

	return "unknown"
}
func fetchUserMap(c *gin.Context, Tels *account.UsersByTelRequest) (map[uint64]string, error) {
	userList, err := service.AccountProvider.UsersByTel(c, Tels)
	if err != nil {
		return nil, err
	}

	userMap := make(map[uint64]string)
	if len(userList.Data) != 0 {
		for _, i := range userList.Data {
			userMap[i.ID] = i.NickName
		}
	}

	return userMap, nil
}