package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/360EntSecGroup-Skylar/excelize/v2"
	"github.com/astaxie/beego"
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/web/beego/utils"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/suMoney/command"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/suMoney/query"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/suMoney/service"
	utils_tool "gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/utils"
	"os"
	"path"
	"strconv"
)

type SuMoneyController struct {
	beego.Controller
}

// 操作素币
func (controller *SuMoneyController) OperationSuMoney() {
	suMoneyService := service.NewSuMoneyService(nil)
	operationSuMoneyCommand := &command.OperationSuMoneyCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), operationSuMoneyCommand)
	data, err := suMoneyService.OperationSuMoney(operationSuMoneyCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 获取素币事务记录
func (controller *SuMoneyController) GetSuMoneyTransactionRecord() {
	suMoneyService := service.NewSuMoneyService(nil)
	getSuMoneyTransactionRecordQuery := &query.GetSuMoneyTransactionRecordQuery{}
	suMoneyTransactionRecordId, _ := controller.GetInt64(":suMoneyTransactionRecordId")
	getSuMoneyTransactionRecordQuery.SuMoneyTransactionRecordId = suMoneyTransactionRecordId
	data, err := suMoneyService.GetSuMoneyTransactionRecord(getSuMoneyTransactionRecordQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 兑换素币
func (controller *SuMoneyController) ExchangeSuMoney() {
	suMoneyService := service.NewSuMoneyService(nil)
	exchangeSuMoneyCommand := &command.ExchangeSuMoneyCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), exchangeSuMoneyCommand)
	data, err := suMoneyService.ExchangeSuMoney(exchangeSuMoneyCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 搜索素币事务
func (controller *SuMoneyController) SearchSuMoneyTransactionRecord() {
	suMoneyService := service.NewSuMoneyService(nil)
	searchSuMoneyTransactionRecordCommand := &command.SearchSuMoneyTransactionRecordCommand{}
	employeeMatchName := controller.GetString("employeeMatchName")
	searchSuMoneyTransactionRecordCommand.EmployeeMatchName =  employeeMatchName
	offset, _ := controller.GetInt("offset")
	searchSuMoneyTransactionRecordCommand.Offset = offset
	limit, _ := controller.GetInt("limit")
	searchSuMoneyTransactionRecordCommand.Limit = limit
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), searchSuMoneyTransactionRecordCommand)
	data, err := suMoneyService.SearchSuMoneyTransactionRecord(searchSuMoneyTransactionRecordCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 素币事务统计（个人素币收支）
func (controller *SuMoneyController) SuMoneyTransactionRecordStatistics() {
	suMoneyService := service.NewSuMoneyService(nil)
	suMoneyTransactionRecordStatisticsCommand := &command.SuMoneyTransactionRecordStatisticsCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), suMoneyTransactionRecordStatisticsCommand)
	data, err := suMoneyService.SuMoneyTransactionRecordStatistics(suMoneyTransactionRecordStatisticsCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 贡献值事务统计（个人贡献值收支）
func (controller *SuMoneyController) ContributionsTransactionRecordStatistics() {
	suMoneyService := service.NewSuMoneyService(nil)
	contributionsTransactionRecordStatisticsCommand := &command.ContributionsTransactionRecordStatisticsCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), contributionsTransactionRecordStatisticsCommand)
	data, err := suMoneyService.ContributionsTransactionRecordStatistics(contributionsTransactionRecordStatisticsCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 投入现金池
func (controller *SuMoneyController) CashInput() {
	cashPoolService := service.NewCashPoolService(nil)
	createCashPoolCommand := &command.CreateCashPoolCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), createCashPoolCommand)
	data, err := cashPoolService.CreateCashPool(createCashPoolCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回现金池
func (controller *SuMoneyController) GetCashPool() {
	cashPoolService := service.NewCashPoolService(nil)
	getCashPoolQuery := &query.GetCashPoolQuery{}
	companyId, _ := controller.GetInt64("companyId")
	getCashPoolQuery.CompanyId = companyId
	data, err := cashPoolService.GetCashPool(getCashPoolQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 新增兑换活动
func (controller *SuMoneyController) CreateExchangeActivities ()  {
	cashPoolService := service.NewCashPoolService(nil)
	createExchangeCashActivityCommand := &command.CreateExchangeCashActivityCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), createExchangeCashActivityCommand)
	data, err := cashPoolService.CreateExchangeCashActivity(createExchangeCashActivityCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换活动列表
func (controller *SuMoneyController) ListExchangeActivities () {
	cashPoolService := service.NewCashPoolService(nil)
	listExchangeCashActivityQuery := &query.ListExchangeCashActivityQuery{}
	companyId, _ := controller.GetInt64("companyId")
	listExchangeCashActivityQuery.CompanyId = companyId
	exchangeCashActivityNameMatch := controller.GetString("activityNameMatch")
	listExchangeCashActivityQuery.ActivityNameMatch = exchangeCashActivityNameMatch
	offset, _ := controller.GetInt("offset")
	listExchangeCashActivityQuery.Offset = offset
	limit, _ := controller.GetInt("limit")
	listExchangeCashActivityQuery.Limit = limit
	isEnd, _ := controller.GetBool("isEnd")
	listExchangeCashActivityQuery.IsEnd = isEnd
	data, err := cashPoolService.ListExchangeCashActivity(listExchangeCashActivityQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 搜索返回兑换活动列表
func (controller *SuMoneyController) SearchExchangeActivities () {
	cashPoolService := service.NewCashPoolService(nil)
	searchExchangeCashActivityCommand := &command.SearchExchangeCashActivityCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), searchExchangeCashActivityCommand)
	fmt.Printf("命令：%+v\n", searchExchangeCashActivityCommand)
	data, err := cashPoolService.SearchExchangeCashActivity(searchExchangeCashActivityCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换现金活动
func (controller *SuMoneyController) GetExchangeCashActivity () {
	cashPoolService := service.NewCashPoolService(nil)
	getExchangeCashActivityQuery := &query.GetExchangeCashActivityQuery{}
	activityId, _ := controller.GetInt64(":activityId")
	getExchangeCashActivityQuery.ExchangeCashActivityId = activityId
	data, err := cashPoolService.GetExchangeCashActivity(getExchangeCashActivityQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 更新兑换活动信息
func (controller *SuMoneyController) UpdateExchangeActivities () {
	cashPoolService := service.NewCashPoolService(nil)
	updateExchangeCashActivityCommand := &command.UpdateExchangeCashActivityCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), updateExchangeCashActivityCommand)
	activityId, _ := controller.GetInt64(":activityId")
	updateExchangeCashActivityCommand.ExchangeCashActivityId = activityId
	data, err := cashPoolService.UpdateExchangeCashActivity(updateExchangeCashActivityCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 移除兑换活动
func (controller *SuMoneyController) RemoveExchangeActivities () {
	cashPoolService := service.NewCashPoolService(nil)
	removeExchangeCashActivityCommand := &command.RemoveExchangeCashActivityCommand{}
	activityId, _ := controller.GetInt64(":activityId")
	beego.Info(activityId)
	removeExchangeCashActivityCommand.ActivityId = activityId
	data, err := cashPoolService.RemoveExchangeCashActivity(removeExchangeCashActivityCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换素币清单列表
func (controller *SuMoneyController) ListExchangeList () {
	cashPoolService := service.NewCashPoolService(nil)
	listExchangeCashListQuery := &query.ListExchangeCashPersonQuery{}
	activityId, _ := controller.GetInt64("activityId")
	listExchangeCashListQuery.ExchangeCashActivityId = activityId
	companyId, _ := controller.GetInt64("companyId")
	listExchangeCashListQuery.CompanyId = companyId
	exchangeCashPersonNameMatch := controller.GetString("personNameMatch")
	listExchangeCashListQuery.ExchangeCashPersonNameMatch = exchangeCashPersonNameMatch
	offset, _ := controller.GetInt("offset")
	listExchangeCashListQuery.Offset = offset
	limit, _ := controller.GetInt("limit")
	listExchangeCashListQuery.Limit = limit
	data, err := cashPoolService.ListExchangeCashPerson(listExchangeCashListQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 新增兑换素币清单
func (controller *SuMoneyController) CreateExchangeList () {
	cashPoolService := service.NewCashPoolService(nil)
	createExchangeCashPersonCommand := &command.CreateExchangeCashPersonCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), createExchangeCashPersonCommand)
	data, err := cashPoolService.CreateExchangeCashPerson(createExchangeCashPersonCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 更新兑换素币清单
func (controller *SuMoneyController) UpdateExchangeList ()  {
	cashPoolService := service.NewCashPoolService(nil)
	updateExchangeCashPersonCommand := &command.UpdateExchangeCashPersonCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), updateExchangeCashPersonCommand)
	personId, _ := controller.GetInt64(":listId")
	updateExchangeCashPersonCommand.ListId = personId
	data, err := cashPoolService.UpdateExchangeCashPerson(updateExchangeCashPersonCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 移除兑换素币清单
func (controller *SuMoneyController) RemoveExchangeCashPerson() {
	cashPoolService := service.NewCashPoolService(nil)
	removeExchangeCashPersonCommand := &command.RemoveExchangeCashPersonCommand{}
	personId, _ := controller.GetInt64(":listId")
	operatorId, _ := controller.GetInt64("operator")
	removeExchangeCashPersonCommand.ListId = personId
	removeExchangeCashPersonCommand.Operator = operatorId
	data, err := cashPoolService.RemoveExchangeCashPerson(removeExchangeCashPersonCommand)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换素币清单
func (controller *SuMoneyController) GetExchangeCashPerson () {
	cashPoolService := service.NewCashPoolService(nil)
	getExchangeCashPersonQuery := &query.GetExchangeCashPersonQuery{}
	listId, _ := controller.GetInt64(":listId")
	getExchangeCashPersonQuery.ExchangeCashPersonId = listId
	data, err := cashPoolService.GetExchangeCashPerson(getExchangeCashPersonQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换活动截止时间列表
func (controller *SuMoneyController) ListDeadline() {
	cashPoolService := service.NewCashPoolService(nil)
	listExchangeCashActivityDeadlineQuery := &query.ListExchangeCashActivityDeadlineQuery{}
	companyId, _ := controller.GetInt64("companyId")
	listExchangeCashActivityDeadlineQuery.CompanyId = companyId
	data, err := cashPoolService.ListExchangeCashActivityDeadline(listExchangeCashActivityDeadlineQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 返回兑换素币清单排行榜
func (controller *SuMoneyController) ExchangeCashListRanking() {
	cashPoolService := service.NewCashPoolService(nil)
	exchangeListRankingQuery := &query.ExchangeListRankingQuery{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), exchangeListRankingQuery)
	data, err := cashPoolService.ExchangeListRanking(exchangeListRankingQuery)
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
	} else {
		response = utils.ResponseData(controller.Ctx, data)
	}
	controller.Data["json"] = response
	controller.ServeJSON()
}

// 导入兑换素币清单
func (controller *SuMoneyController) ImportExchangeList () {
	cashPoolService := service.NewCashPoolService(nil)
	where := controller.GetString("where")
	file, h, _ := controller.GetFile("file")
	jsonMap := make(map[string]interface{})
	_ = json.Unmarshal([]byte(where), &jsonMap)

	// 错误信息返回
	var response utils.JsonResponse

	// 返回字段定义
	ret := map[string]interface{}{}

	// 返回信息表头定义
	var tableHeader = [...]string{"员工姓名", "手机号", "已兑换素币", "错误详情"}

	// 文件后缀名校验
	ext := path.Ext(h.Filename)
	AllowExtMap := map[string]bool{
		".xlsx":true,
	}
	if _,ok:=AllowExtMap[ext];!ok{
		err := &application.ServiceError{
			Code: 500,
			Message: "后缀名不符合上传要求",
		}
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
		return
	}

	// 打开文件
	xlsx, err := excelize.OpenReader(file)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 文件行数校验
	rows, _ := xlsx.GetRows("Sheet1")
	fmt.Print(len(rows), "\n")
	if len(rows) > 302 {
		err := &application.ServiceError{
			Code: 500,
			Message: "导入的文件超过300行",
		}
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
		return
	}

	// 空表格判断
	if len(rows) < 4 {
		err := &application.ServiceError{
			Code: 500,
			Message: "当前导入的为空表格",
		}
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
		return
	}

	// 单元格校验
	newstr := []string{"null"}
	//nullChar := []string{"单元格包含空字符"}
	nullLine := make([]interface{}, 0)
	for i, row := range rows {
		if i > 2 {
			fmt.Print(len(row), "\n")

			// 头部、中间空
			if len(row) == 3 {
				for j, cell := range row {
					fmt.Print(cell, "\n")
					if cell == "" {
						utils_tool.InsertSlice(j, newstr, row)
						row = append(row, "单元格包含空字符")
						nullLine = append(nullLine, row)
					}
				}
			}

			// 尾空
			if len(row) < 3 {
				for j, cell := range row {
					fmt.Print(cell, "\n")
					if cell == "" {
						utils_tool.InsertSlice(j, row, newstr)
						row = append(row, "单元格包含空字符")
						nullLine = append(nullLine, row)
					}
				}
			}
		}
	}

	if len(nullLine) > 0 {
		ret = map[string]interface{}{
			"successCount": 0,
			"fail": map[string]interface{}{
				"tableHeader": tableHeader,
				"tableData": nullLine,
			},
		}
		response = utils.ResponseData(controller.Ctx, ret)
		controller.Data["json"] = response
		controller.ServeJSON()
		return
	}

	// 新增失败记录
	failureDataList := make([]interface{}, 0)

	// 新增成功计数
	var successDataCount int64

	// 导入命令
	var createExchangeCashPersonCommands []*command.CreateExchangeCashPersonCommand

	for i, row := range rows {
		if i > 2 && len(row) > 1 {
			// 创建兑换清单命令
			createExchangeCashPersonCommand := &command.CreateExchangeCashPersonCommand{}
			createExchangeCashPersonCommand.ExchangeCashActivityId, _ = strconv.ParseInt(jsonMap["activityId"].(string), 10, 64 )
			createExchangeCashPersonCommand.Operator  = int64(jsonMap["uid"].(float64))
			createExchangeCashPersonCommand.PersonName = row[0]
			createExchangeCashPersonCommand.PersonAccount = row[1]
			r2, _ := strconv.ParseFloat(row[2], 64)
			createExchangeCashPersonCommand.ExchangedSuMoney = r2
			createExchangeCashPersonCommands = append(createExchangeCashPersonCommands, createExchangeCashPersonCommand)
		}
	}

	// 创建兑换素币清单
	failureDataList, err = cashPoolService.ImportCreateExchangeCashPerson(createExchangeCashPersonCommands, failureDataList)
	if err != nil { // 导入失败处理
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
		return
	} else {
		if len(failureDataList) > 0 {  // 导入失败返回
			successDataCount = 0
			ret = map[string]interface{}{
				"successCount": successDataCount,
				"fail": map[string]interface{}{
					"tableHeader": tableHeader,
					"tableData": failureDataList,
				},
			}
		} else {  // 导入成功返回
			successDataCount = int64(len(rows) - 3 - len(failureDataList))
			if successDataCount == int64(len(rows) - 3) {
				ret = map[string]interface{}{
					"successCount": successDataCount,
					"fail": nil,
				}
			}
		}
	}

	response = utils.ResponseData(controller.Ctx, ret)
	controller.Data["json"] = response
	controller.ServeJSON()
	return
}

// 下载日志
func (controller *SuMoneyController) LogFile() {
	controller.Ctx.Output.Download("logs/app.log","app.log")
}

// 导出素币兑换清单，选择导出(ids)，增加导出失败信息
func (controller *SuMoneyController) ExportExchangeList() {
	cashPoolService := service.NewCashPoolService(nil)
	exportExchangeCashListCommand := &command.ExportExchangeCashListCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), exportExchangeCashListCommand)
	// 列标题
	titles := []string{
		"姓名","手机账号","已兑换现金","已兑换素币",
	}
	// 列单元
	cells := []string{
		"A","B","C","D",
	}
	// 数据源
	var data []map[string]interface{}
	people, err := cashPoolService.ListExchangeCashPersonById(exportExchangeCashListCommand)
	for _, person := range people {
		p := map[string]interface{} {
			"name": person.EmployeeInfo.EmployeeName,
			"account": person.EmployeeInfo.EmployeeAccount,
			"exchanged_cash": person.ExchangedCash,
			"exchanged_su_money": person.ExchangedSuMoney,
		}
		data = append(data, p)
	}
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
	} else {
		// 新建文件
		f := excelize.NewFile()
		// 新建工作簿
		index := f.NewSheet("Sheet1")
		//列标题赋值
		for column, v := range titles {
			f.SetCellValue("Sheet1", cells[column] + "1", v)
		}
		for lineNum, v := range data {   //行数 lineNum  行内容 v
			for columnNum := 0; columnNum < len(v); columnNum ++ {
				cell := cells[columnNum]
				row := strconv.Itoa(lineNum + 2)
				switch cell {
				case "A":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["name"])
					break
				case "B":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["account"])
					break
				case "C":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["exchanged_cash"])
					break
				case "D":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["exchanged_su_money"])
					break
				}
			}
		}

		f.SetActiveSheet(index)

		// 创建下载文件夹
		mkErr :=os.Mkdir("download", os.ModePerm)
		if err!=nil{
			fmt.Println(mkErr)
		}

		//保存为文件
		f.Path="download/素币兑换清单.xlsx"
		if err := f.Save(); err != nil {
			fmt.Println(err)
		}

		controller.Ctx.Output.Download(f.Path,"素币兑换清单.xlsx")

		// 下载完成删除文件
		removeErr := os.Remove(f.Path)
		if err != nil {
			fmt.Println(removeErr)
		}
	}
}

// 导出素币流水
func (controller *SuMoneyController) ExportSuMoney() {
	suMoneyService := service.NewSuMoneyService(nil)
	exportSuMoneyCommand := &command.ExportSuMoneyCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), exportSuMoneyCommand)
	// 列标题
	titles := []string{
		"员工姓名","手机账号","当前素币",
	}
	// 列单元
	cells := []string{
		"A","B","C",
	}
	var response utils.JsonResponse
	var data []map[string]interface{}
	records, err := suMoneyService.ListSuMoneyById(exportSuMoneyCommand)
	for _, record := range records {
		p := map[string]interface{} {
			"name": record.EmployeeInfo.EmployeeName,
			"account": record.EmployeeInfo.EmployeeAccount,
			"current_su_money": record.SuMoney,
		}
		data = append(data, p)
	}
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
	} else {
		// 新建文件
		f := excelize.NewFile()

		// 新建工作簿
		index := f.NewSheet("Sheet1")

		//列标题赋值
		for column, v := range titles {
			f.SetCellValue("Sheet1", cells[column]+"1", v)
		}

		for lineNum, v := range data {   //行数 lineNum  行内容 v
			for columnNum := 0; columnNum < len(v); columnNum ++ {
				cell := cells[columnNum]
				row := strconv.Itoa(lineNum + 2)
				switch cell {
				case "A":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["name"])
					break
				case "B":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["account"])
					break
				case "C":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["current_su_money"])
					break
				}
			}
		}

		f.SetActiveSheet(index)

		// 创建下载文件夹
		mkErr :=os.Mkdir("download", os.ModePerm)
		if err!=nil{
			fmt.Println(mkErr)
		}

		//保存为文件
		f.Path="download/素币流水.xlsx"
		if err := f.Save(); err != nil {
			fmt.Println(err)
		}

		controller.Ctx.Output.Download(f.Path,"素币流水.xlsx")

		// 下载完成删除文件
		removeErr := os.Remove(f.Path)
		if err != nil {
			fmt.Println(removeErr)
		}
	}
}

// 导出素币流水记录
func (controller *SuMoneyController) ExportSuMoneyTransactionRecord() {
	suMoneyService := service.NewSuMoneyService(nil)
	exportTransactionRecordCommand := &command.ExportTransactionRecordCommand{}
	json.Unmarshal(controller.Ctx.Input.GetData("requestBody").([]byte), exportTransactionRecordCommand)
	// 列标题
	titles := []string{
		"员工姓名","当前素币","素币流水","操作时间","操作人",
	}
	// 列单元
	cells := []string{
		"A","B","C","D","E",
	}
	var response utils.JsonResponse
	var data []map[string]interface{}
	records, err := suMoneyService.ListSuMoneyTransactionRecordById(exportTransactionRecordCommand)
	for _, record := range records {
		p := map[string]interface{}{}
		if record.RecordType == 2 || record.RecordType == 3 || record.RecordType == 6 {
			p = map[string]interface{} {
				"name": record.Employee.EmployeeName,
				"current_su_money": record.CurrentSuMoney,
				"record": "+" + fmt.Sprintf("%.2f", record.SuMoney),
				"create_time": record.CreateTime.Local().Format("2006/01/02 15:04:05"),
				"operator": record.Operator.EmployeeName,
			}
		} else {
			p = map[string]interface{} {
				"name": record.Employee.EmployeeName,
				"current_su_money": record.CurrentSuMoney,
				"record": "-" + fmt.Sprintf("%.2f", record.SuMoney),
				"create_time": record.CreateTime.Local().Format("2006/01/02 15:04:05"),
				"operator": record.Operator.EmployeeName,
			}
		}
		data = append(data, p)
	}
	if err != nil {
		response = utils.ResponseError(controller.Ctx, err)
		controller.Data["json"] = response
		controller.ServeJSON()
	} else {
		// 新建文件
		f := excelize.NewFile()
		// 新建工作簿
		index := f.NewSheet("Sheet1")
		//列标题赋值
		for column, v := range titles {
			f.SetCellValue("Sheet1", cells[column]+"1", v)
		}
		for lineNum, v := range data {   //行数 lineNum  行内容 v
			for columnNum := 0; columnNum < len(v); columnNum ++ {
				cell := cells[columnNum]
				row := strconv.Itoa(lineNum + 2)
				switch cell {
				case "A":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["name"])
					break
				case "B":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["current_su_money"])
					break
				case "C":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["record"])
					break
				case "D":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["create_time"])
					break
				case "E":
					sheetPosition := cell + row
					f.SetCellValue("Sheet1", sheetPosition, v["operator"])
					break
				}
			}
		}
		f.SetActiveSheet(index)
		// 创建下载文件夹
		mkErr :=os.Mkdir("download", os.ModePerm)
		if err!=nil{
			fmt.Println(mkErr)
		}
		//保存为文件
		f.Path="download/素币流水记录.xlsx"
		if err := f.Save(); err != nil {
			fmt.Println(err)
		}
		controller.Ctx.Output.Download(f.Path,"素币流水记录.xlsx")
		// 下载完成删除文件
		removeErr := os.Remove(f.Path)
		if err != nil {
			fmt.Println(removeErr)
		}
	}
}