hongze_open_api/controllers/jinmencaijing.go

package controllers

import (
	"encoding/json"
	"fmt"
	jinmencaijingReq "hongze/hongze_open_api/models/request/jinmencaijing"
	reportSelectionResp "hongze/hongze_open_api/models/response/cygx_report_selection"
	"hongze/hongze_open_api/models/response/jinmencaijing"
	"hongze/hongze_open_api/models/tables/company"
	"hongze/hongze_open_api/models/tables/company_product"
	"hongze/hongze_open_api/models/tables/company_report_permission"
	cygxActivity "hongze/hongze_open_api/models/tables/cygx/cygx_activity"
	"hongze/hongze_open_api/models/tables/cygx/cygx_report_selection"
	"hongze/hongze_open_api/models/tables/cygx/cygx_three_api_log"
	"hongze/hongze_open_api/models/tables/wx_user"
	"hongze/hongze_open_api/services/alarm_msg"
	servicesCompany "hongze/hongze_open_api/services/company"
	cygxSeriesActivity "hongze/hongze_open_api/services/cygx_activity"
	servicesWxUser "hongze/hongze_open_api/services/wx_user"
	"hongze/hongze_open_api/utils"
	"strconv"
	"strings"
	"time"
)

// JinMenCaiJingControllerCommon 进门财经模块
type JinMenCaiJingController struct {
	BaseAuth
}

// 活动详情
// @Title 活动详情接口
// @Description 活动详情接口
// @router /activity/detail [get]
func (c *JinMenCaiJingController) ActivityDetail() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	activityId, _ := c.GetInt("activity_id")
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}
	//resp := new(*jinmencaijing.CygxActivityDetailResp)
	detail := new(jinmencaijing.CygxActivityResp)
	detail.ActivityID = activityInfo.ActivityId
	detail.PublishStatus = activityInfo.PublishStatus
	detail.ActivityName = activityInfo.ActivityName
	detail.Label = activityInfo.Label
	detail.ActivityTime = activityInfo.ActivityTime
	detail.ActivityTimeText = activityInfo.ActivityTimeText
	detail.ActivityTypeId = activityInfo.ActivityTypeId
	detail.ActivityTypeName = activityInfo.ActivityTypeName
	detail.ChartPermissionName = activityInfo.ChartPermissionName
	detail.IsLimitPeople = activityInfo.IsLimitPeople
	detail.LimitPeopleNum = activityInfo.LimitPeopleNum
	detail.Expert = activityInfo.Expert
	detail.Host = activityInfo.Host
	detail.Speaker = activityInfo.Speaker
	detail.City = activityInfo.City
	detail.Address = activityInfo.Address
	detail.Highlights = activityInfo.Highlights
	detail.DistinguishedGuest = activityInfo.DistinguishedGuest
	detail.MainlandTell = activityInfo.MainlandTell
	detail.HongKongTell = activityInfo.HongKongTell
	detail.TaiwanTell = activityInfo.TaiwanTell
	detail.AmericaTell = activityInfo.AmericaTell
	detail.ParticipationCode = activityInfo.ParticipationCode
	detail.OnlineParticipation = activityInfo.OnlineParticipation
	detail.TencentConferenceNumber = activityInfo.TencentConferenceNumber
	detail.LinkParticipants = activityInfo.LinkParticipants
	detail.VmpRobotMeetingId = activityInfo.VmpRobotMeetingId
	detail.ConferencePassword = activityInfo.ConferencePassword
	detail.ReportLink = activityInfo.ReportLink
	detail.Theme = activityInfo.Theme
	detail.Remarks = activityInfo.Remarks
	detail.SubjectName = cygxSeriesActivity.GetActivitySubjectNameList(activityId)
	//添加请求日志记录
	itemApiLog := new(cygx_three_api_log.CygxThreeApiLog)
	itemApiLog.CreateTime = time.Now()
	itemApiLog.Source = 2
	itemApiLog.Url = c.Ctx.Input.URI()

	jsonstr := strconv.Itoa(activityId)
	itemApiLog.Body = fmt.Sprint(jsonstr)
	itemApiLog.Result = fmt.Sprint(detail)
	_, errlog := cygx_three_api_log.AddCygxThreeApiLog(itemApiLog)
	if errlog != nil {
		go alarm_msg.SendAlarmMsg("进门财经活动详情接口 AddCygxThreeApiLog："+errlog.Error()+fmt.Sprint("activityId=", activityId), 3)
	}
	c.OkDetailed(detail, "获取成功")
}

// 活动报名
// @Title 活动报名接口
// @Description 活动报名接口
// @router /activity/signup/add [post]
func (c *JinMenCaiJingController) ActivitySignupAdd() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	var req jinmencaijingReq.ActivitySignupReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.FailWithMessage("参数解析异常")
		return
	}
	activityId := req.ActivityId
	mobile := req.Mobile
	countryCode := req.CountryCode
	realName := req.RealName
	companyName := req.CompanyName
	var dateTxt = []byte(mobile)
	resultDe := utils.DesBase64Decrypt(dateTxt)
	deMobile := string(resultDe)
	resp := new(jinmencaijing.CygxActivitySignupResp)
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}
	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if time.Now().After(resultTime.Add(-time.Minute * 60)) {
		resp.SignupStatus = 2
		c.OkDetailed(resp, "报名失败时间超时")
	}
	if activityInfo.LimitPeopleNum > 0 {
		totalSuccess, err := cygxActivity.GetActivitySignupSuccessCount(activityId)
		if err != nil {
			c.FailWithMessage("获取已报名的用户数量失败！" + err.Error())
			return
		}
		if activityInfo.LimitPeopleNum <= totalSuccess {
			resp.SignupStatus = 3
			c.OkDetailed(resp, "报名失败人数已满")
		}
	}
	userTotal, err := wx_user.GetWxUserCountByMobile(deMobile)
	if err != nil {
		c.FailWithMessage("根据手机号判断用户信息失败")
		return
	}
	var user *wx_user.WxUser
	if userTotal == 0 {
		userId, err := servicesWxUser.AddWxUserByMobile(deMobile, countryCode, realName)
		if err != nil {
			c.FailWithMessage("根据手机号录入用户信息失败")
			return
		}
		user, err = wx_user.GetByUserId(userId)
		if err != nil {
			c.FailWithMessage("获取用户信息失败")
			return
		}
	} else {
		user, err = wx_user.GetByUserMobile(deMobile)
		if err != nil {
			c.FailWithMessage("获取用户信息失败")
			return
		}
	}

	signupCount, err := cygxActivity.GetActivitySignupCountByUserId(int(user.UserId), activityId)
	if err != nil {
		c.FailWithMessage("获取用户是否报名信息失败")
		return
	}

	if signupCount == 0 {
		item := new(cygxActivity.CygxActivitySignup)
		item.UserId = int(user.UserId)
		item.RealName = user.RealName
		item.ActivityId = activityId
		item.CreateTime = time.Now()
		item.Email = user.Email
		item.CompanyId = user.CompanyId
		item.CompanyName = companyName
		item.SignupType = 3
		item.ThreeSource = 1
		item.Mobile = user.Mobile
		item.CountryCode = user.CountryCode
		item.OutboundMobile = user.OutboundMobile
		if user.OutboundMobile == "" {
			item.OutboundMobile = user.Mobile
		}
		if user.CountryCode == "" {
			item.CountryCode = "86"
		}
		_, err = cygxActivity.AddActivitySignup(item)
		if err != nil {
			c.OkDetailed(resp, "报名成功")
			return
		}
	}
	resp.SignupStatus = 1
	c.OkDetailed(resp, "报名成功")
}

// 活动取消报名
// @Title 活动取消报名接口
// @Description 活动取消报名接口
// @router /activity/signup/cancel [post]
func (c *JinMenCaiJingController) ActivitySignupCancel() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	var req jinmencaijingReq.ActivitySignupReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.FailWithMessage("参数解析异常")
		return
	}
	activityId := req.ActivityId
	mobile := req.Mobile
	var dateTxt = []byte(mobile)
	resultDe := utils.DesBase64Decrypt(dateTxt)
	deMobile := string(resultDe)
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}
	resp := new(jinmencaijing.CygxActivitySignupcancelResp)

	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if time.Now().After(resultTime.Add(-time.Minute * 60)) {
		resp.CancelStatus = 2
		c.OkDetailed(resp, "活动开始前1小时内无法取消报名")
	}

	var user *wx_user.WxUser
	user, err = wx_user.GetByUserMobile(deMobile)
	if err != nil {
		c.FailWithMessage("获取用户信息失败")
		return
	}
	item := new(cygxActivity.CygxActivitySignup)
	item.UserId = int(user.UserId)
	item.ActivityId = activityId
	item.CreateTime = time.Now()

	_, err = cygxActivity.CancelActivitySignup(item)
	if err != nil {
		c.OkDetailed(resp, "取消报名失败")
		return
	}
	resp.CancelStatus = 1
	c.OkDetailed(resp, "取消报名成功")
}

// 活动白名单校验
// @Title 活动白名单校验接口
// @Description 活动白名单校验接口
// @router /activity/white/check [post]
func (c *JinMenCaiJingController) ActivityWhiteCheck() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	var req jinmencaijingReq.ActivitySignupReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.FailWithMessage("参数解析异常")
		return
	}
	activityId := req.ActivityId
	mobile := req.Mobile
	var dateTxt = []byte(mobile)
	resultDe := utils.DesBase64Decrypt(dateTxt)
	deMobile := string(resultDe)
	userTotal, err := wx_user.GetWxUserCountByMobile(deMobile)
	if err != nil {
		c.FailWithMessage("根据手机号判断用户信息失败")
		return
	}
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}
	var user *wx_user.WxUser
	resp := new(jinmencaijing.CygxActivityWhiteCheckResp)
	if userTotal == 0 {
		c.OkDetailed(resp, "获取成功")
		return
	} else {
		user, err = wx_user.GetByUserMobile(deMobile)
		if err != nil {
			c.FailWithMessage("获取用户信息失败")
			return
		}
	}
	companyInfo, err := company.GetCompanyById(user.CompanyId)
	if err != nil {
		c.FailWithMessage("获取客户信息失败")
		return
	}
	resp.RealName = user.RealName
	resp.Position = user.Position
	resp.CompanyName = companyInfo.CompanyName
	if activityInfo.LimitPeopleNum > 0 {
		total, err := company_product.CheckUserAaiPerssionByMobile(deMobile)
		if err != nil {
			c.FailWithMessage("校验失败！" + err.Error())
			return
		}
		if total > 0 {
			resp.IsWhite = true
		}
	} else {
		listPermissionName, err := company_report_permission.GetPermissionListNameByCompanyIdAndProductId(user.CompanyId, 2)
		if err != nil {
			c.FailWithMessage("获取用户权限信息失败：" + strconv.Itoa(activityId))
			return
		}
		if len(listPermissionName) > 0 {
			listPermissionName = append(listPermissionName, &company_report_permission.ChartPermissionNameResp{ChartPermissionName: "宏观"})
		}
		for _, v := range listPermissionName {
			if v.ChartPermissionName == activityInfo.ChartPermissionName {
				resp.IsWhite = true
				break
			}
		}
	}
	//添加请求日志记录
	itemApiLog := new(cygx_three_api_log.CygxThreeApiLog)
	itemApiLog.CreateTime = time.Now()
	itemApiLog.Source = 2
	itemApiLog.Url = c.Ctx.Input.URI()
	data, _ := json.Marshal(req)
	jsonstr := string(data)
	itemApiLog.Body = fmt.Sprint(jsonstr, "deMobile=", deMobile)
	itemApiLog.Result = fmt.Sprint(resp)
	_, errlog := cygx_three_api_log.AddCygxThreeApiLog(itemApiLog)
	if errlog != nil {
		go alarm_msg.SendAlarmMsg("进门财经活动白名单接口 AddCygxThreeApiLog："+errlog.Error()+fmt.Sprint("activityId=", activityId), 3)
	}
	c.OkDetailed(resp, "获取成功")
}

// 活动用户报名信息回显（自己是否报名，以及已经报名的人数）
// @Title 活动用户报名信息回显接口
// @Description 活动用户报名信息回显接口
// @router /activity/signup/detail [post]
func (c *JinMenCaiJingController) ActivitySignupDetail() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	var req jinmencaijingReq.ActivitySignupReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.FailWithMessage("参数解析异常")
		return
	}
	activityId := req.ActivityId
	mobile := req.Mobile
	var dateTxt = []byte(mobile)
	resultDe := utils.DesBase64Decrypt(dateTxt)
	deMobile := string(resultDe)
	userTotal, err := wx_user.GetWxUserCountByMobile(deMobile)
	if err != nil {
		c.FailWithMessage("根据手机号判断用户信息失败")
		return
	}
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}
	resp := new(jinmencaijing.CygxActivitySignupCheckResp)
	var user *wx_user.WxUser
	if userTotal == 0 {
		c.OkDetailed(resp, "获取成功")
	} else {
		user, err = wx_user.GetByUserMobile(deMobile)
		if err != nil {
			c.FailWithMessage("获取用户信息失败")
			return
		}
	}

	if activityInfo.LimitPeopleNum > 0 {
		total, err := cygxActivity.GetActivitySignupSuccessCount(activityId)
		if err != nil {
			c.FailWithMessage("获取已报名的用户数量失败！" + err.Error())
			return
		}
		resp.SignupNum = total
	}
	totalUser, err := cygxActivity.GetActivitySignupCountByUserIdeffective(int(user.UserId), activityId)
	if err != nil {
		c.FailWithMessage("获取已报名的用户数量失败！" + err.Error())
		return
	}
	resp.IsSignup = totalUser
	c.OkDetailed(resp, "获取成功")
}

//func init() {
//	mobile := "15557270777"
//	encryptMobile := string(utils.DesBase64Encrypt([]byte(mobile)))
//	fmt.Println(encryptMobile)
//}

// 重点公司详情接口
// @Title 重点公司详情接口
// @Description 重点公司详情接口
// @router /report_selection/detail [get]
func (c *JinMenCaiJingController) ReportSelectionDetail() {
	//回调中url参数要做签名（get请求中的参数，按照自己的方式签名，避免链接被别人拿去随意请求）
	articleId, _ := c.GetInt("article_id")
	resp := new(reportSelectionResp.ReportSelectionLetailResp)
	detail, err := cygx_report_selection.GetCygxReportSelectionInfoById(articleId)
	if err != nil {
		c.FailWithMessage("报告ID异常：" + strconv.Itoa(articleId))
		return
	}
	detail.PublishDate = utils.StrTimeToTime(detail.PublishDate).Format("2006-01-02")
	existMap := make(map[int]int)
	var items []*reportSelectionResp.ReportSelectionChartPermission
	var itemsSubject []*reportSelectionResp.ReportSelectionChartLogPermission
	listLog, err := cygx_report_selection.GetReportSelectionlogListAll(articleId)
	if err != nil {
		c.FailWithMessage("获取信息失败")
		return
	}

	//获取行业核心逻辑汇总
	listChartLog, err := cygx_report_selection.GetCygxReportSelectionChartLogRepList(articleId)
	if err != nil {
		c.FailWithMessage("获取信息失败")
		return
	}
	mapChartLog := make(map[string]string)
	for _, v := range listChartLog {
		mapChartLog[v.ChartPermissionName] = v.BodyChartSummary
	}

	PermissionNameMap, err := servicesCompany.GetPermissionNameMap()
	if err != nil {
		c.FailWithMessage("获取信息失败：")
		return
	}
	for _, v := range listLog {
		v.PermissionName = PermissionNameMap[v.ChartPermissionId]
		item := new(reportSelectionResp.ReportSelectionChartPermission)
		itemSubject := new(reportSelectionResp.ReportSelectionChartLogPermission)
		itemSubject.PermissionName = v.PermissionName
		if existMap[v.ChartPermissionId] == 0 {
			item.PermissionName = v.PermissionName
			listSonLog, err := cygx_report_selection.GetReportSelectionlogSonListAll(articleId, v.ChartPermissionId)
			if err != nil {
				c.FailWithMessage("获取信息失败")
				return
			}
			for k2, v2 := range listSonLog {
				if v2.IndustrialManagementId != "" {
					listIndustrial, err := cygx_report_selection.GetIndustrialByIds(v2.IndustrialManagementId)
					if err != nil {
						c.FailWithMessage("获取信息失败")
						return
					}
					listSonLog[k2].List = listIndustrial
					if v2.SubjectName == "" {
						v2.ShowName = v2.IndustrialManagementNames
					} else {
						v2.ShowName = v2.SubjectName
					}
				}
				if v2.Label != "" {
					CompanyLabelSlice := strings.Split(v2.Label, "{|}")
					for _, vCompanyLabel := range CompanyLabelSlice {
						v2.CompanyLabel = append(v2.CompanyLabel, "#"+vCompanyLabel+"#")
					}
				}
				if v2.ThirdName != "" {
					v2.ShowName = v2.ThirdName
				}
				subjectItem := new(reportSelectionResp.ReportSelectionChartLogSubjectName)
				subjectItem.SubjectName = v2.SubjectName
				subjectItem.IsNew = v2.IsNew
				if v2.ThirdName != "" {
					subjectItem.SubjectName = v2.ThirdName
				} else {
					if subjectItem.SubjectName == "" {
						subjectItem.SubjectName = v2.IndustrialManagementNames
					}
				}
				subjectItem.UniqueString = utils.MD5(fmt.Sprint("IN_ID", v2.IndustrialManagementId, "S_ID", v2.IndustrialSubjectId, "T_ID", v2.ThirdId))
				v2.UniqueString = subjectItem.UniqueString
				itemSubject.ListSubject = append(itemSubject.ListSubject, subjectItem)
			}
			item.BodyChartSummary = mapChartLog[v.PermissionName]

			for _, vs := range listSonLog {
				listItem := new(reportSelectionResp.CygxReportSelectionLogDetail)
				listItem.IsNew = vs.IsNew
				listItem.Body = vs.Body
				listItem.CompanyLabel = vs.CompanyLabel
				listItem.UniqueString = vs.UniqueString
				listItem.ShowName = vs.ShowName
				item.List = append(item.List, listItem)
			}
			item.PermissionName = PermissionNameMap[v.ChartPermissionId]
			items = append(items, item)
			itemsSubject = append(itemsSubject, itemSubject)
		}
		existMap[v.ChartPermissionId] = v.ChartPermissionId
	}

	resp.List = items
	resp.ListPermissionSubject = itemsSubject
	detailItem := new(reportSelectionResp.DetailCygxReportSelectionRep)
	detailItem.ArticleId = detail.ArticleId
	detailItem.Title = detail.Title
	detailItem.Department = detail.Department
	detailItem.PublishDate = detail.PublishDate
	detailItem.ProductDescription = detail.ProductDescription
	detailItem.MarketStrategy = detail.MarketStrategy
	detailItem.Disclaimer = utils.CYGX_DISCLAIMER
	detailItem.PermissionName = "宏观策略"
	resp.Detail = detailItem
	c.OkDetailed(resp, "获取成功")
}

// 活动音视频详情
// @Title 活动音视频详情接口
// @Description 活动音视频详情接口
// @router /activity/vivo_detail [get]
func (c *JinMenCaiJingController) ActivityVivoDetail() {
	activityId, _ := c.GetInt("activity_id")
	activityInfo, err := cygxActivity.GetAddActivityInfoByActivityId(activityId)
	if err != nil {
		c.FailWithMessage("会议id异常：" + strconv.Itoa(activityId))
		return
	}

	totalVoiceCount, err := cygxActivity.GetCygxActivityVoiceCount(activityId)
	if err != nil {
		c.FailWithMessage("获取信息失败！" + err.Error())
		return
	}

	totalVideoCount, err := cygxActivity.GetCygxActivityVideoCount(activityId)
	if err != nil {
		c.FailWithMessage("获取信息失败！" + err.Error())
		return
	}
	resp := new(jinmencaijing.CygxActivityVivoDetailResp)
	detail := new(jinmencaijing.CygxActivityVivoResp)
	if totalVoiceCount > 0 {
		voiceDetail, err := cygxActivity.GetCygxActivityVoiceReq(activityId)
		if err != nil {
			c.FailWithMessage("获取信息失败！" + err.Error())
			return
		}
		detail.FileType = 1
		detail.FileUrl = voiceDetail.Url
		detail.FileName = voiceDetail.Name
		detail.PlaySeconds = voiceDetail.PlaySeconds
	} else if totalVideoCount > 0 {
		videoDetail, err := cygxActivity.GetCygxActivityVideoReq(activityId)
		if err != nil {
			c.FailWithMessage("获取信息失败！" + err.Error())
			return
		}
		detail.FileType = 2
		detail.FileUrl = videoDetail.Url
		detail.FileName = videoDetail.Name
		detail.PlaySeconds = videoDetail.PlaySeconds
	} else {
		c.FailWithMessage("获取信息失败,该活动不存在音视频文件！")
		return
	}

	detail.ActivityId = activityInfo.ActivityId
	detail.Label = activityInfo.Label
	detail.ActivityTime = activityInfo.ActivityTime
	detail.ActivityTimeText = activityInfo.ActivityTimeText
	detail.ChartPermissionName = activityInfo.ChartPermissionName
	//detail.SubjectName = cygxSeriesActivity.GetActivitySubjectNameList(activityId)
	resp.Detail = detail
	c.OkDetailed(resp, "获取成功")
}