hongze_mobile_admin/controllers/message.go

package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"hongze/hongze_mobile_admin/models/response/message"
	"hongze/hongze_mobile_admin/models/tables/company_approval"
	"hongze/hongze_mobile_admin/models/tables/company_approval_message"
	"hongze/hongze_mobile_admin/models/tables/contract_approval"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	"hongze/hongze_mobile_admin/utils"
	"sort"
	"strconv"
	"strings"
)

//消息模块
type MessageCommon struct {
	BaseAuth
}

// @Title 消息列表汇总页
// @Description 消息列表汇总页接口
// @Success 200 {object} []message.SummaryMessage
// @router /summaryMessageList [get]
func (c *MessageCommon) SummaryMessageList() {
	sysUser := c.AdminWx
	sysUserId := sysUser.AdminId

	//SummaryMessageListResp := message.SummaryMessageListResp{}
	sourceTypeList := [...]int{1, 2, 3, 5, 6}
	messageMap := make(map[int]message.SummaryMessage)
	timeList := make([]int, 0)
	for _, sourceType := range sourceTypeList {
		//最近一条消息
		tmpMessage := ``
		messageInfo, err := company_approval_message.GetLastMessage(sysUserId, sourceType)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				continue
			}
			c.FailWithMessage("获取失败", "获取消息失败，Err:"+err.Error())
			return
		} else {
			tmpMessage = fmt.Sprint(messageInfo.RealName, " ", messageInfo.CreateTime.Format("2006.01.02"), " ", messageInfo.Content)
		}

		notReadTotal, err := company_approval_message.GetNotReadMessageTotal(sysUserId, sourceType)
		if err != nil {
			c.FailWithMessage("获取失败", "获取未读消息数失败，Err:"+err.Error())
			return
		}
		companyMessage := message.SummaryMessage{
			Message:    tmpMessage,
			Total:      int(notReadTotal),
			SourceType: sourceType,
		}

		timeInt := int(messageInfo.CreateTime.Unix())
		//这么做避免时间重复了
		timeStr := fmt.Sprintf("%d%d", timeInt, messageInfo.Id)
		timeInt, _ = strconv.Atoi(timeStr)

		messageMap[timeInt] = companyMessage
		timeList = append(timeList, timeInt)

		//switch sourceType {
		//case 1:
		//	SummaryMessageListResp.CompanyMessage = CompanyMessage
		//case 2:
		//	SummaryMessageListResp.ContractMessage = CompanyMessage
		//case 3:
		//	SummaryMessageListResp.SealMessage = CompanyMessage
		//}
	}

	///1,根据参数名称的ASCII码表的顺序排序
	sort.Ints(timeList)
	messageList := make([]message.SummaryMessage, 0)
	for _, currTime := range timeList {
		messageList = append(messageList, messageMap[currTime])
	}
	rotate(messageList)
	c.OkDetailed(messageList, "获取成功")
}

//切片数据反转
func rotate(s []message.SummaryMessage) {
	left, rigth := 0, 0
	if len(s)%2 == 0 { //判断长度是奇数还是偶数，根据这个来确定旋转的中心
		left = len(s)/2 - 1
		rigth = len(s) / 2
	} else {
		left = len(s)/2 - 1
		rigth = len(s)/2 + 1
	}
	for ; left >= 0 || rigth <= len(s)-1; left, rigth = left-1, rigth+1 {
		s[left], s[rigth] = s[rigth], s[left]
	}
}

// @Title 消息列表
// @Description 消息列表接口
// @Param   SourceType   query   int  true       "消息类型"
// @Param   CurrentIndex   query   int  true       "当前页码"
// @Param   pageSize   query   int  true       "每页数量"
// @Success 200 {object} message.CompanyApprovalMessageListResp
// @router /list [get]
func (c *MessageCommon) MessageList() {
	sysUser := c.AdminWx
	sysUserId := sysUser.AdminId
	sourceType, err := c.GetInt("SourceType", 1)
	if err != nil {
		c.FailWithMessage("获取失败", "获取消息类型失败，Err:"+err.Error())
		return
	}
	pageSize, _ := c.GetInt("PageSize")
	currentIndex, _ := c.GetInt("CurrentIndex")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	total, err := company_approval_message.GetCompanyApprovalMessageCount(sysUserId, sourceType)
	if err != nil {
		c.FailWithMessage("获取失败", "获取消息总数失败，Err:"+err.Error())
		return
	}
	list, err := company_approval_message.GetCompanyApprovalMessageList(sysUserId, sourceType, startSize, pageSize)
	if err != nil {
		c.FailWithMessage("获取失败", "获取消息列表失败，Err:"+err.Error())
		return
	}

	//将所有未读消息标记为已读
	_ = company_approval_message.ModifyAllCompanyApprovalMessageStatus(sysUserId, sourceType)

	companyApprovalIds := make([]string, 0)
	newApprovalRecordIds := make([]string, 0)
	companyApprovalMap := make(map[int]*company_approval.CompanyApproval)
	newApprovalMap := make(map[int]*contract_approval.ContractApproval)
	for _, messageInfo := range list {
		if messageInfo.SourceType == 1 {
			companyApprovalIds = append(companyApprovalIds, strconv.Itoa(messageInfo.CompanyApprovalId))
		} else {
			//如果不是文字消息
			newApprovalRecordIds = append(newApprovalRecordIds, strconv.Itoa(messageInfo.CompanyApprovalId))
		}
	}
	//客户信息
	if len(companyApprovalIds) > 0 {
		companyApprovalList, err := company_approval.GetApprovalListByApprovalIds(strings.Join(companyApprovalIds, ","))
		if err != nil {
			c.FailWithMessage("获取失败", "获取申请列表信息失败，Err:"+err.Error())
		}
		for _, companyApproval := range companyApprovalList {
			companyApprovalMap[companyApproval.CompanyApprovalId] = companyApproval
		}
	}
	//新的审批单信息
	if len(newApprovalRecordIds) > 0 {
		//审批流程单信息
		contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordByIds(strings.Join(newApprovalRecordIds, ","))
		if err != nil {
			c.FailWithMessage("获取失败", "获取申请列表信息失败，Err:"+err.Error())
		}
		newApprovalIds := make([]string, 0)

		approvalRecordMap := make(map[int][]int)
		for _, contractApprovalRecord := range contractApprovalRecordList {
			newApprovalIds = append(newApprovalIds, strconv.Itoa(contractApprovalRecord.ContractApprovalId))
			if _, ok := approvalRecordMap[contractApprovalRecord.ContractApprovalId]; ok {
				approvalRecordMap[contractApprovalRecord.ContractApprovalId] = append(approvalRecordMap[contractApprovalRecord.ContractApprovalId], contractApprovalRecord.ContractApprovalRecordId)
			} else {
				tmpContractApprovalRecordIdList := make([]int, 0)
				tmpContractApprovalRecordIdList = append(tmpContractApprovalRecordIdList, contractApprovalRecord.ContractApprovalRecordId)
				approvalRecordMap[contractApprovalRecord.ContractApprovalId] = tmpContractApprovalRecordIdList
			}
		}

		//审批单信息
		if len(newApprovalIds) > 0 {
			contractApprovalList, err := contract_approval.GetContractApprovalByIds(strings.Join(newApprovalIds, ","))
			if err != nil {
				c.FailWithMessage("获取失败", "获取申请列表信息失败，Err:"+err.Error())
			}
			for _, contractApproval := range contractApprovalList {
				if _, ok := approvalRecordMap[contractApproval.ContractApprovalId]; ok {
					for _, contractApprovalRecordId := range approvalRecordMap[contractApproval.ContractApprovalId] {
						newApprovalMap[contractApprovalRecordId] = contractApproval
					}
				}
			}
		}
	}

	for _, messageInfo := range list {
		approvalInfo := company_approval_message.ApprovalInfo{}
		if messageInfo.SourceType == 1 {
			if companyApproval, ok := companyApprovalMap[messageInfo.CompanyApprovalId]; ok {
				//申请类型：1:试用->正式,2:冻结—>试用,3:试用延期,4:原销售申请领取流失客户，5:正式客户申请服务更新，6：正式客户补充协议
				switch companyApproval.ApplyMethod {
				case 1:
					approvalInfo.Type = "申请转正"
				case 2:
					approvalInfo.Type = "冻结转试用"
				case 3:
					approvalInfo.Type = "试用延期"
				case 4:
					approvalInfo.Type = "原销售申请领取流失客户"
				case 5:
					approvalInfo.Type = "续约申请"
				case 6:
					approvalInfo.Type = "补充协议"
				}
				approvalInfo.ApplyName = companyApproval.ApplyRealName
				approvalInfo.ApplyTime = companyApproval.CreateTime
				approvalInfo.ApprovalTime = companyApproval.ApproveTime
			}
		} else {
			if newApproval, ok := newApprovalMap[messageInfo.CompanyApprovalId]; ok {
				approvalInfo.Type = newApproval.ApplyContent
				approvalInfo.ApplyName = newApproval.ApplyUserName
				approvalInfo.ApplyTime = newApproval.CreateTime
				approvalInfo.ApprovalTime = newApproval.ModifyTime
			}
		}
		messageInfo.ApprovalInfo = approvalInfo
	}
	//
	resp := message.CompanyApprovalMessageListResp{
		List:  list,
		Total: total,
	}
	c.OkDetailed(resp, "获取成功")
}

func getMessageItem(source int) {

}

// @Title 消息已读
// @Description 消息已读接口
// @Param	request	body company.CompanyApprovalMessageReadReq true "type json string"
// @Success Ret=200 申请成功
// @router /read [post]
func (c *MessageCommon) MessageRead() {
	//sysUser := c.AdminWx
	var req company_approval_message.CompanyApprovalMessageReadReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())

		return
	}
	if req.Id <= 0 {
		c.FailWithMessage("参数错误", "参数错误，客户id小于等于0")
		return
	}
	err = company_approval_message.ModifyCompanyApprovalMessageStatus(req.Id)
	if err != nil {
		c.FailWithMessage("修改失败！", "修改已读失败，Err:"+err.Error())
		return
	}
	c.OkWithMessage("已读成功")
}