hongze_cygx/services/activity.go

package services

import (
	"context"
	"errors"
	"fmt"
	"github.com/tealeg/xlsx"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/utils"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

//修改活动状态
func UpdateActivitySattus(cont context.Context) (err error) {
	//defer func() {
	//	if err != nil {
	//		fmt.Println("同步失败，Err:", err.Error())
	//	}
	//}()
	go models.UpdateActivitySattusToHaveInHand()
	go models.UpdateActivitySattusToComplete()
	return
}

//推送会议开始消息提醒60分钟前
func SendActivityBeginMsg(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("60分钟会议消息提醒失败", 2)
			fmt.Println("发送失败，Err:", err.Error())
		}
	}()
	endDate := time.Now().Add(+time.Minute * 60).Format(utils.FormatDateTime)
	listActivity, err := models.GetActivitySendMsgListAll(endDate)
	fmt.Println(len(listActivity))
	if err != nil {
		fmt.Println("GetActivitySendMsgListAll Err:", err.Error())
		return
	}
	if len(listActivity) == 0 {
		return
	}
	var remark = "点击查看活动详情"
	var signupIds string
	for _, v := range listActivity {
		signupIds += strconv.Itoa(v.Id) + ","
		var reserveResults string
		var first string
		openIdItem := new(models.OpenIdList)
		openIdItem.OpenId = v.OpenId
		openIdItem.UserId = v.UserId
		openIdList := make([]*models.OpenIdList, 0)
		openIdList = append(openIdList, openIdItem)
		//if v.FailType == 0 {
		//	reserveResults = "成功"
		//} else if v.FailType == 1 {
		//	reserveResults = "失败（总人数已满）"
		//} else if v.FailType == 2 {
		//	reserveResults = "失败（单机构超限制）"
		//} else if v.FailType == 3 {
		//	reserveResults = "失败（爽约次数超限）"
		//}
		reserveResults = "--"
		first = "您有一场【" + v.ActivityTypeName + "】将在1小时后开始"
		SendWxMsgWithFrequency(first, v.ActivityName, reserveResults, v.ActivityTime, v.Address, remark, openIdList, v.ActivityId)
	}
	if len(signupIds) == 0 {
		return
	}
	signupIds = strings.TrimRight(signupIds, ",")
	err = models.UPdateSendedMsgStatus(signupIds)
	if err != nil {
		var msg string
		go utils.SendEmail("发送模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+err.Error(), utils.EmailSendToUsers)
		utils.FileLog.Info("发送模版消息失败,Err:%s", err.Error())
	}
	return
}

//推送会议开始消息提醒15分钟前
func SendActivityBeginMsgMeeting(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("15分钟会议消息提醒失败", 2)
			fmt.Println("发送失败，Err:", err.Error())
		}
	}()
	endDate := time.Now().Add(+time.Minute * 15).Format(utils.FormatDateTime)
	listActivity, err := models.GetActivitySendMsgListAllMeeting(endDate)
	if err != nil {
		fmt.Println("GetActivitySendMsgListAll Err:", err.Error())
		return
	}
	if len(listActivity) == 0 {
		return
	}
	var signupIds string
	var remark = "点击查看活动详情"
	for _, v := range listActivity {
		signupIds += strconv.Itoa(v.Id) + ","
		var reserveResults string
		var first string
		openIdItem := new(models.OpenIdList)
		openIdItem.OpenId = v.OpenId
		openIdItem.UserId = v.UserId
		openIdList := make([]*models.OpenIdList, 0)
		openIdList = append(openIdList, openIdItem)
		reserveResults = "--"
		first = "您有一场【" + v.ActivityTypeName + "】将在15分钟后开始"
		SendWxMsgWithFrequency(first, v.ActivityName, reserveResults, v.ActivityTime, "--", remark, openIdList, v.ActivityId)
	}
	if len(signupIds) == 0 {
		return
	}
	signupIds = strings.TrimRight(signupIds, ",")
	err = models.UPdateSendedMsgMeetingStatus(signupIds)
	if err != nil {
		var msg string
		go utils.SendEmail("发送模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+err.Error(), utils.EmailSendToUsers)
		utils.FileLog.Info("发送模版消息失败,Err:%s", err.Error())
	}
	return
}

//预约外呼名单，会前1小时自动发送邮件给专家组
func SendEmailFileToExpert(cont context.Context) (err error) {
	var msg string
	var touser string
	defer func() {
		if err != nil {
			fmt.Println("err：", err)
			go utils.SendAlarmMsg("发送附件模版消息失败", 2)
			go utils.SendEmail("发送附件模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+err.Error(), utils.EmailSendToUsers)
			utils.FileLog.Info("发送附件模版消息失败,Err:%s", err.Error())
		}
		if msg != "" {
			fmt.Println(msg)
			utils.FileLog.Info("发送模版消息失败,msg:%s", msg)
		}
	}()
	endDate := time.Now().Add(+time.Minute * 60).Format(utils.FormatDateTime)
	total, err := models.GetCountActivityIdToSendFile(endDate)

	if total == 0 {
		fmt.Println("发送附件完成0")
		return nil
	}
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}
	listActivity, err := models.GetActivityIdToSendFile(endDate)
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}

	for _, v := range listActivity {
		activityInfo, _ := models.GetAddActivityInfoById(v.ActivityId)
		if activityInfo == nil {
			msg = "活动不存在，Err:activityId：" + strconv.Itoa(v.ActivityId)
			return
		}
		list, errFile := models.GetSignupExport(v.ActivityId)
		if errFile != nil {
			msg = "获取失败，Err:" + errFile.Error()
			return
		}
		//创建excel
		dir, errFile := os.Executable()
		exPath := filepath.Dir(dir)
		downLoadnFilePath := exPath + "/" + time.Now().Format(utils.FormatDateTimeUnSpace) + utils.GetRandDigit(5) + ".xlsx"
		xlsxFile := xlsx.NewFile()
		if errFile != nil {
			msg = "生成文件失败Err:" + errFile.Error()
			return
		}
		style := xlsx.NewStyle()
		alignment := xlsx.Alignment{
			Horizontal: "center",
			Vertical:   "center",
			WrapText:   true,
		}
		style.Alignment = alignment
		style.ApplyAlignment = true
		sheet, errFile := xlsxFile.AddSheet("外呼名单")
		if errFile != nil {
			msg = "新增Sheet失败,Err:" + errFile.Error()
			return
		}
		//设置宽度
		_ = sheet.SetColWidth(1, 1, 15)
		_ = sheet.SetColWidth(3, 3, 30)
		//标头
		rowTitle := sheet.AddRow()
		cellA := rowTitle.AddCell()
		cellA.Value = "姓名"
		cellB := rowTitle.AddCell()
		cellB.Value = "外呼号码"
		cellC := rowTitle.AddCell()
		cellC.Value = "国际代码"
		cellD := rowTitle.AddCell()
		cellD.Value = "公司名称"
		cellE := rowTitle.AddCell()
		cellE.Value = "所属销售"

		for _, item := range list {
			row := sheet.AddRow()
			cellA := row.AddCell()
			cellA.Value = item.RealName
			cellB := row.AddCell()
			cellB.Value = item.OutboundMobile
			cellC := row.AddCell()
			if item.CountryCode == "" {
				cellC.Value = "86"
			} else {
				cellC.Value = item.CountryCode
			}
			cellD := row.AddCell()
			cellD.Value = item.CompanyName
			cellE := row.AddCell()
			cellE.Value = item.SellerName
		}
		errFile = xlsxFile.Save(downLoadnFilePath)
		if errFile != nil {
			msg = "保存文件失败Err:" + errFile.Error()
			return
		}
		title := activityInfo.ActivityName + "外呼名单"
		content := "外呼名单详情"
		fileName := downLoadnFilePath
		if activityInfo.ChartPermissionName == "科技" {
			touser = utils.EmailTechnology
		} else if activityInfo.ChartPermissionName == "医药" {
			touser = utils.EmailMedicine
		} else if activityInfo.ChartPermissionName == "消费" {
			touser = utils.EmailConsumption
		} else if activityInfo.ChartPermissionName == "智造" {
			touser = utils.EmailZhizao
		} else if activityInfo.ChartPermissionName == "策略" {
			touser = utils.EmailStrategy
		} else if strings.Contains(activityInfo.ChartPermissionName, "研选") {
			touser = utils.EmailExpert
		}
		sendResult := utils.SendEmailByHongze(title, content, touser, fileName, title+".xlsx")
		if sendResult {
			errFile = models.UPdateActivityIdToSendFile(v.ActivityId)
			if errFile != nil {
				msg = "获取失败，Err:" + errFile.Error()
				return
			}
			os.Remove(downLoadnFilePath)
		} else {
			go utils.SendEmail("发送附件模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+activityInfo.ActivityName, utils.EmailSendToUsers)
			utils.FileLog.Info("发送附件模版消息失败,Err:%s", activityInfo.ActivityName)
		}
	}
	return
}

func EditOutboundMobile(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("发送失败，Err:", err.Error())
		}
	}()

	list, err := models.GetActivitySignupListAll()
	if err != nil {
		fmt.Println("GetActivitySendMsgListAll Err:", err.Error())
		return
	}
	for _, v := range list {
		err = models.UPdateSignup(v)
		fmt.Println("修改:", strconv.Itoa(v.Id))
		if err != nil {
			fmt.Println("发送失败，Err:", err.Error()+strconv.Itoa(v.Id))
		}
	}
	fmt.Println("修改完成")
	return
}

//同步用户绑定手机号以及区号
func EditUserOutboundMobile(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("发送失败，Err:", err.Error())
		}
	}()

	list, err := models.GetUserListAll()
	if err != nil {
		fmt.Println("GetActivitySendMsgListAll Err:", err.Error())
		return
	}
	for _, v := range list {
		err = models.UPdateUserCountryCode(v)
		fmt.Println("修改:", strconv.Itoa(v.UserId))
		if err != nil {
			fmt.Println("发送失败，Err:", err.Error()+strconv.Itoa(v.UserId))
		}
	}
	fmt.Println("修改完成")
	return
}

//获取 用户类型   //1、永续客户 //2、大套餐客户（4个行业全开通的正式客户） //3、分行业套餐客户（开通对应行业的正式客户） //4、仅开通专家套餐的正式客户 //5、开通对应行业套餐或专家套餐的试用客户;6、冻结客户；7、流失客户
func GetUserType(companyId int) (userType int, permissionStrnew string, err error) {

	var permissionStr, permissionZhengShiStr string
	if companyId <= 1 {
		userType = 0
	} else {
		total, errs := models.GetCountCompanyDetailByIdGroup(companyId)
		if errs != nil {
			err = errs
			return
		}
		if total == 0 {
			userType = 0
		} else {
			companyDetail, errs := models.GetCompanyDetailByIdGroup(companyId)
			if errs != nil {
				err = errs
				return
			}
			permissionStr, errs = models.GetCompanyPermissionByUserNoStatus(companyId)
			if errs != nil {
				err = errs
				return
			}
			permissionZhengShiStr, errs = models.GetCompanyPermissionByUserZhengShi(companyId)
			if errs != nil {
				err = errs
				return
			}

			//1、永续客户 //2、大套餐客户（4个行业全开通的正式客户） //3、分行业套餐客户（开通对应行业的正式客户） //4、仅开通专家套餐的正式客户 //5、开通对应行业套餐或专家套餐的试用客户
			//大套餐客户定义：医药、消费、科技、智造、策略。5个行业中任意4个及以上是正式权限的，属于大套餐客户（医药、消费、科技、智造需要主客观都开）
			if companyDetail.Status == "永续" {
				userType = 1
			} else if companyDetail.Status == "试用" {
				userType = 5
			} else if companyDetail.Status == "正式" {
				if permissionStr == "专家" {
					userType = 4
				} else if strings.Count(permissionZhengShiStr, "医药") == 2 && strings.Count(permissionZhengShiStr, "消费") == 2 && strings.Count(permissionZhengShiStr, "科技") == 2 && strings.Count(permissionZhengShiStr, "智造") == 2 {
					userType = 2
				} else {
					userType = 3
				}
				if userType == 3 {
					if !strings.Contains(permissionStr, "医药") && !strings.Contains(permissionStr, "消费") && !strings.Contains(permissionStr, "科技") && !strings.Contains(permissionStr, "智造") {
						userType = 4
					}
				}
			} else if companyDetail.Status == "冻结" {
				userType = 6
			} else if companyDetail.Status == "流失" {
				userType = 7
			}
			//大套餐客户定义：医药、消费、科技、智造、策略。5个行业中任意4个及以上是正式权限的，属于大套餐客户（医药、消费、科技、智造需要主客观都开）
			if userType == 3 {
				var permissionZhegnshiNum int
				if strings.Count(permissionZhengShiStr, "医药") == 2 {
					permissionZhegnshiNum++
				}
				if strings.Count(permissionZhengShiStr, "消费") == 2 {
					permissionZhegnshiNum++
				}
				if strings.Count(permissionZhengShiStr, "科技") == 2 {
					permissionZhegnshiNum++
				}
				if strings.Count(permissionZhengShiStr, "智造") == 2 {
					permissionZhegnshiNum++
				}
				if strings.Count(permissionZhengShiStr, "策略") == 1 {
					permissionZhegnshiNum++
				}
				if permissionZhegnshiNum >= 4 {
					userType = 2
				}
			}
		}
	}
	permissionStrnew = permissionStr
	return
}

// 校验被分享的用户是否有查看详情的权限
func GetShareNoPowe(activityInfo *models.ActivityDetail, permissionStr string, userType int) (noPower bool, err error) {
	//var noPower bool
	if (userType == 1 || userType == 4 || userType == 5) && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(userType)) {
		noPower = true
	}
	//1、永续客户 //2、大套餐客户（4个行业全开通的正式客户） //3、分行业套餐客户（开通对应行业的正式客户） //4、仅开通专家套餐的正式客户 //5、开通对应行业套餐或专家套餐的试用客户
	if userType == 2 && strings.Contains(permissionStr, "专家") && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(2)) && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(3)) && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(4)) {
		noPower = true
	}
	if userType == 2 && !strings.Contains(permissionStr, "专家") && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(2)) && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(3)) {
		noPower = true
	}
	if userType == 3 && strings.Contains(permissionStr, "专家") && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(3)) && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(4)) {
		noPower = true
	}
	if userType == 3 && !strings.Contains(permissionStr, "专家") && !strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(3)) {
		noPower = true
	}
	return
}

// 校验用户报名的权限
func GetHavePower(activityInfo *models.ActivityDetail, permissionStr, companyDetailStatus string, userType int) (havePower bool, err error) {
	if (activityInfo.ActivityTypeId == 1 || activityInfo.ActivityTypeId == 3) && strings.Contains(permissionStr, "专家") && activityInfo.LimitPeopleNum == 0 {
		havePower = true
	} else if activityInfo.ActivityTypeId == 3 && strings.Contains(permissionStr, "专家") && companyDetailStatus == "正式" && strings.Contains(activityInfo.CustomerTypeIds, "4") {
		havePower = true
	} else if activityInfo.ActivityTypeId == 3 && strings.Contains(permissionStr, "专家") && companyDetailStatus == "试用" && strings.Contains(activityInfo.CustomerTypeIds, "5") {
		havePower = true
		//} else if strings.Contains(permissionStr, activityInfo.ChartPermissionName) && strings.Contains(activityInfo.CustomerTypeIds, strconv.Itoa(userType)) {
		//	havePower = true
		//} else if strings.Contains(permissionStr, activityInfo.ChartPermissionName) {
		//	havePower = true
	} else if (activityInfo.ActivityTypeId == 1 || activityInfo.ActivityTypeId == 3 || activityInfo.ActivityTypeId == 4 || activityInfo.ActivityTypeId == 5) && strings.Contains(permissionStr, "专家") {
		havePower = true
	}
	if activityInfo.ActivityTypeId == 2 || activityInfo.ActivityTypeId == 6 || activityInfo.ActivityTypeId == 7 {
		if strings.Contains(permissionStr, activityInfo.ChartPermissionName+"(主观)") {
			havePower = true
		}
	} else {
		if strings.Contains(permissionStr, activityInfo.ChartPermissionName+"(客观)") {
			havePower = true
		}
	}
	if (strings.Contains(activityInfo.ChartPermissionName, "研选") || activityInfo.ChartPermissionName == "策略") && strings.Contains(permissionStr, activityInfo.ChartPermissionName) {
		havePower = true
	}
	//如果是易董的活动且属于研选类型，只要开通任何权限就可以查看详情
	if activityInfo.YidongActivityId != "" && permissionStr != "" && strings.Contains(activityInfo.ChartPermissionName, utils.CHART_PERMISSION_NAME_YANXUAN) {
		havePower = true
	}
	return
}

//获取活动列表查询权限的SQL
// @Param   ChartPermissionIds   query   string  false     "行业id 多个用 , 隔开"
// @Param   ActivityTypeIds   query   string  false     "活动类型id 多个用 , 隔开"
// @Param   ActiveState   query   string  false       "活动进行状态 未开始：1、进行中2、已结束3"
// @Param   WhichDay   query   string  false       "哪一天 今天：1、明天:2，多个用 , 隔开"
// @Param   IsPower   query   int  false       "是否选择有权限行业 ，1是 0 否 默认0"
// @Param   Label   query   string  false       "搜索主题 多个用 , 隔开"
// @Param   PlayBack   query   int  false       "是否仅展示回放 1：是、0：否 默认0"
// @Param   KeyWord   query   string  false       "搜索关键词 多个用 , 隔开"
func GetActivityonditionList(user *models.WxUserItem, activityTypeId, chartPermissionIds, whichDay, activeState, label string, isPower, source int, keyWord string) (conditionActivity string, err error) {
	adminIds, err := models.GetSelleridWhichGroup(user.CompanyId, 2)
	if err != nil {
		return
	}
	userType, permissionStr, err := GetUserType(user.CompanyId)
	if err != nil {
		return
	}
	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	isMaker := user.IsMaker
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	var permissionNameStr string
	for _, v := range slicePer {
		if userType == 1 {
			//研选权限处理
			if !strings.Contains(v, utils.CHART_PERMISSION_NAME_YANXUAN) {
				permissionNameStr += "'" + v + "',"
			}
		} else {
			permissionNameStr += "'" + v + "',"
		}
	}
	permissionNameStr = strings.Replace(permissionNameStr, "(主观)", "", -1)
	permissionNameStr = strings.Replace(permissionNameStr, "(客观)", "", -1)
	permissionNameStr = strings.TrimRight(permissionNameStr, ",")
	var condition string
	var conditionAdmin string
	var sqlExport string // 专家权限处理
	permissionSqlStr = `  AND art.chart_permission_name  IN (` + permissionNameStr + `)`
	sqlExport = ` AND (art.customer_type_ids LIKE '%` + strconv.Itoa(userType) + `%' `
	if userType == 2 {
		sqlExport += ` OR  art.customer_type_ids LIKE '%3%' `
	}
	if (userType == 2 || userType == 3) && strings.Contains(permissionStr, "专家") {
		sqlExport += ` OR  art.customer_type_ids LIKE '%4%' `
	}
	sqlExport += `) `
	// 如果是C类电话会就不展示内容，且合并到分析师电话会
	if activityTypeId != "" {
		if activityTypeId == strconv.Itoa(utils.ANALYST_TELL_ACTIVITY_TYPE_ID) {
			condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.activity_type_id IN (` + activityTypeId + "," + strconv.Itoa(utils.C_CLASS_ACTIVITY_TYPE_ID) + `)`
		} else {
			condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.activity_type_id = ` + activityTypeId
		}
	}
	//活动仅决策人可见
	if isMaker == 0 {
		condition += ` AND art.is_maker_show = 0  `
	}
	//主题
	if label != "" {
		condition = ` AND art.label  LIKE '%` + label + `%' `
	}

	if isPower == 1 {
		condition += permissionSqlStr
	}
	//行业名称
	if len(chartPermissionIds) > 0 {
		condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
	}
	//如果是PC的，则不看易董的
	if source == 1 {
		condition += ` AND art.yidong_activity_id = '' `
	}

	var conditionOr string
	if whichDay != "" {
		var startDate string
		var endDate string
		if whichDay == "1" {
			startDate = time.Now().Format(utils.FormatDate)
			endDate = startDate
		} else if whichDay == "2" {
			startDate = time.Now().AddDate(0, 0, +1).Format(utils.FormatDate)
			endDate = startDate
		} else {
			startDate = time.Now().Format(utils.FormatDate)
			endDate = time.Now().AddDate(0, 0, +1).Format(utils.FormatDate)
		}
		condition += ` AND art.activity_time >= ` + "'" + startDate + " 00:00:00'"
		condition += ` AND art.activity_time <= ` + "'" + endDate + " 23:59:59'"
	}

	//有搜索条件传过来时，不判进行状态条件
	if keyWord != "" {
		condition += ` AND (art.label  LIKE '%` + keyWord + `%' OR art.activity_name  LIKE '%` + keyWord + `%' ) `
		if activeState == "2" {
			condition += ` AND art.active_state  = 2 `
		}
	} else {
		if activeState != "" {
			// 默认查看未开始跟进行中
			if activeState == "1" {
				condition += ` AND art.active_state  IN (1,2)`
			} else {
				condition += ` AND art.active_state  IN (` + activeState + `)`
			}
		} else {
			condition += ` AND art.active_state  IN (1,2)`
		}
	}

	//查询全部可见的数据（是否全部客户可见）
	condition += ` AND art.visible_range != 1  AND art.publish_status = 1 `

	if (userType == 2 || userType == 3 || userType == 4) && strings.Contains(permissionStr, "专家") {
		conditionOr += ` OR (  art.is_limit_people = 1 AND art.customer_type_ids LIKE '%4%'	 ` + condition + `) `
	}
	if (userType == 5) && strings.Contains(permissionStr, "专家") {
		conditionOr += ` OR (  art.is_limit_people = 1 AND art.customer_type_ids LIKE '%5%'	 ` + condition + `) `
	}
	if userType == 1 {
		conditionOr += ` OR ( art.is_limit_people = 0 ` + condition + permissionSqlStr + `) `
	} else {
		conditionOr += ` OR ( art.is_limit_people = 0 ` + condition + `) `
	}
	if userType == 6 || userType == 7 {
		conditionOr += ` OR (   art.customer_type_ids LIKE '%` + strconv.Itoa(userType) + `%'	 ` + condition + `) `
	}
	if companyProduct != nil {
		if companyProduct.Scale != "" {
			conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
		}
	}
	conditionAdmin = condition
	if adminIds != "" {
		conditionOr += ` OR (  art.customer_type_ids LIKE '%` + strconv.Itoa(userType) + `%' ` + ` AND  art.admin_id IN (` + adminIds + `) ` + conditionAdmin + `) `
		if companyProduct != nil {
			if companyProduct.Scale != "" {
				conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'` + ` AND  art.admin_id IN (` + adminIds + `) ` + conditionAdmin + `) `
			}
		}
	}

	conditionActivity = condition + permissionSqlStr + sqlExport + conditionOr
	return
}

//研选系列专家电话会，会前1小时将问题列表发送给邮箱
func SendEmailFileForAskMsgResearch(cont context.Context) (err error) {
	var msg string
	//var touser string
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("发送附件模版消息失败", 2)
			go utils.SendEmail("发送附件模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+err.Error(), utils.EmailSendToUsers)
		}
		if msg != "" {
			go utils.SendAlarmMsg(msg, 2)
			utils.FileLog.Info("发送模版消息失败,msg:%s", msg)
		}
	}()
	endDate := time.Now().Add(+time.Minute * 60).Format(utils.FormatDateTime)
	condition := `AND  a.activity_type_id = 1 AND a.chart_permission_id = 31 `
	total, err := models.GetCountActivityResearchToSendFile(condition, endDate)
	if total == 0 {
		fmt.Println("发送附件完成0")
		return nil
	}
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}
	listActivity, err := models.GetActivityResearchToSendFile(condition, endDate)
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}
	for _, v := range listActivity {
		activityInfo, _ := models.GetAddActivityInfoById(v.ActivityId)
		if activityInfo == nil {
			msg = "活动不存在，Err:activityId：" + strconv.Itoa(v.ActivityId)
			return
		}
		list, errFile := models.GetActivityMsgExport(v.ActivityId)
		if errFile != nil {
			msg = "获取失败，Err:" + errFile.Error()
			return
		}

		for _, v2 := range list {
			user, err := models.GetWxUserItemByUserId(v2.UserId)
			if err != nil && err.Error() != utils.ErrNoRow() {
				return err
			}
			//获取销售信息
			sellerItem, err := models.GetSellerByCompanyIdCheckFicc(v2.CompanyId, 2)
			if err != nil && err.Error() != utils.ErrNoRow() {
				return err
			}
			//给研究员推送消息
			if sellerItem != nil {
				openIpItem, _ := models.GetUserRecordByMobile(4, utils.ActSendMsgMobile)
				if openIpItem != nil && openIpItem.OpenId != "" {
					//SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", v2.CreateTime, v2.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
					SendActivityAskApplyTemplateMsgV2(user.RealName+"——"+user.CompanyName, "所属销售："+sellerItem.RealName, time.Now().Format(utils.FormatDateTime), v2.Content, activityInfo.ActivityName, openIpItem, activityInfo)
				}
			}
			//给所属销售推送消息
			if sellerItem != nil {
				openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
				if openIpItem != nil && openIpItem.OpenId != "" {
					//SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", v2.CreateTime, v2.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
					SendActivityAskApplyTemplateMsgV2(user.RealName+"——"+user.CompanyName, "所属销售："+sellerItem.RealName, time.Now().Format(utils.FormatDateTime), v2.Content, activityInfo.ActivityName, openIpItem, activityInfo)
				}
			}
		}
		errFile = models.UPdateActivityMsgToSendFile(v.ActivityId)
		if errFile != nil {
			msg = "获取失败，Err:" + errFile.Error()
			return
		}
	}
	return
}

//非研选系列专家电话会，根据主持人姓名，会前15分钟将问题列表发送给至该主持人对应邮箱
func SendEmailFileForAskMsg(cont context.Context) (err error) {
	var msg string
	//var touser string
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("发送附件模版消息失败", 2)
			go utils.SendEmail("发送附件模版消息失败"+"【"+utils.APPNAME+"】"+time.Now().Format(utils.FormatDateTime), msg+";Err:"+err.Error(), utils.EmailSendToUsers)
		}
		if msg != "" {
			go utils.SendAlarmMsg(msg, 2)
			utils.FileLog.Info("发送模版消息失败,msg:%s", msg)
		}
	}()
	endDate := time.Now().Add(+time.Minute * 15).Format(utils.FormatDateTime)
	condition := `AND  a.activity_type_id = 1 AND  a.chart_permission_id != 31 `
	total, err := models.GetCountActivityResearchToSendFile(condition, endDate)
	if total == 0 {
		fmt.Println("发送附件完成0")
		return nil
	}
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}
	listActivity, err := models.GetActivityResearchToSendFile(condition, endDate)
	if err != nil {
		msg = "发送附件模版消息失败 Err:" + err.Error()
		return
	}
	listEmail, errEmail := models.GetAskEmail()
	if errEmail != nil {
		msg = "获取失败，Err:" + errEmail.Error()
		return
	}

	for _, v := range listActivity {
		activityInfo, _ := models.GetAddActivityInfoById(v.ActivityId)
		if activityInfo == nil {
			msg = "活动不存在，Err:activityId：" + strconv.Itoa(v.ActivityId)
			return
		}
		list, errFile := models.GetActivityMsgExport(v.ActivityId)
		if errFile != nil {
			msg = "获取失败，Err:" + errFile.Error()
			return
		}

		for _, v2 := range list {
			user, err := models.GetWxUserItemByUserId(v2.UserId)
			if err != nil && err.Error() != utils.ErrNoRow() {
				return err
			}
			var sendMobile string
			for _, vEmail := range listEmail {
				if strings.Index(activityInfo.Host, vEmail.Name) > 0 {
					sendMobile = vEmail.Mobile
				}
			}
			//获取销售信息
			sellerItem, err := models.GetSellerByCompanyIdCheckFicc(v2.CompanyId, 2)
			if err != nil && err.Error() != utils.ErrNoRow() {
				return err
			}
			//给研究员推送模板消息
			if sellerItem != nil {
				openIpItem, _ := models.GetUserRecordByMobile(4, sendMobile)
				if openIpItem != nil && openIpItem.OpenId != "" {
					//SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", v2.CreateTime, v2.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
					SendActivityAskApplyTemplateMsgV2(user.RealName+"——"+user.CompanyName, "所属销售："+sellerItem.RealName, time.Now().Format(utils.FormatDateTime), v2.Content, activityInfo.ActivityName, openIpItem, activityInfo)
				}
			}
			//给销售推送模板消息
			if sellerItem != nil {
				openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
				if openIpItem != nil && openIpItem.OpenId != "" {
					//SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", v2.CreateTime, v2.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
					SendActivityAskApplyTemplateMsgV2(user.RealName+"——"+user.CompanyName, "所属销售："+sellerItem.RealName, time.Now().Format(utils.FormatDateTime), v2.Content, activityInfo.ActivityName, openIpItem, activityInfo)
				}
			}
		}
		errFile = models.UPdateActivityMsgToSendFile(v.ActivityId)
		if errFile != nil {
			msg = "获取失败，Err:" + errFile.Error()
			return
		}
	}
	return
}

//活动标签字符串处理
func LabelStr(label string) (labelNew string) {
	slicebr := strings.Split(label, "-")
	if len(slicebr) < 2 {
		labelNew = label
	} else {
		labelNew = slicebr[1]
	}
	return labelNew
}

//5.3版本活动标签字符串处理
func LabelStrV5(label string, isShowSubjectName int, temporaryLabel string) (labelNew string) {
	slicebr := strings.Split(label, "-")
	if len(slicebr) > 1 {
		if isShowSubjectName == 1 {
			labelNew = slicebr[1]
		} else {
			labelNew = slicebr[0]
		}
	} else {
		labelNew = label
	}
	if temporaryLabel != "" {
		labelNew = temporaryLabel
	}
	return labelNew
}

func ActivityAttendanceDetail(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("ActivityAttendanceDetail Err:" + err.Error())
			go utils.SendAlarmMsg("同步进门财经数据失败", 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ActivityAttendanceDetail ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()

	configCode := "jin_meng_activity_id"
	detail, err := models.GetConfigByCode(configCode)
	if err != nil {
		return err
	}
	fmt.Println(detail.ConfigValue)
	mapActivityId := make(map[string]string)
	sliceValue := strings.Split(detail.ConfigValue, ",")
	for _, v := range sliceValue {
		mapActivityId[v] = v
	}

	var activityIds string
	var activityIdsLongTime string //可回放的会议，到会详情持续更新加入到不做14天限制的活动中
	fmt.Println("开始同步")
	dateTime := time.Now().AddDate(0, 0, -14).Format(utils.FormatDate)
	dateNow := time.Now().AddDate(0, 0, 0).Format(utils.FormatDate)
	startDate := dateTime + " 00:00:00"
	endDate := dateNow + " 23:59:59"
	//获取进门财经需要处理的活动
	listActivityRoadshow, err := models.GetRoadshowDataListByDateTime(startDate, endDate)
	if err != nil {
		fmt.Println("GetRoadshowDataListByDateTime Err:", err.Error())
		return err
	}
	for _, vAct := range listActivityRoadshow {
		doTime := utils.TimeRemoveHms2(vAct.RoadshowBeginTime)
		findStartDate := doTime + " 00:00:00"
		findEndDate := doTime + " 23:59:59"
		var roadshowTitle string
		roadshowTitle = vAct.RoadshowTitle
		vAct.RoadshowTitle = strings.Replace(vAct.RoadshowTitle, "【", "", -1)
		vAct.RoadshowTitle = strings.Replace(vAct.RoadshowTitle, "】", "", -1)
		vAct.RoadshowTitle = strings.Replace(vAct.RoadshowTitle, " ", "", -1)
		vAct.RoadshowTitle = strings.Replace(vAct.RoadshowTitle, "-", "", -1)
		vAct.RoadshowTitle = strings.Replace(vAct.RoadshowTitle, ":", "", -1)
		nameSlice := strings.Split(vAct.RoadshowTitle, "|")
		//fmt.Println(timeSlice[0])
		//对于手动匹配到的活动数据也要更新
		var activityName string
		if len(nameSlice) >= 1 {
			//if vAct.JmcjRoadshowTitle != "" {
			//	activityName = vAct.JmcjRoadshowTitle
			//} else {
			//	activityName = nameSlice[len(nameSlice)-1]
			//}
			activityName = nameSlice[len(nameSlice)-1]
			if activityName != "" {
				//通过名称去找匹配的活动
				activityDetail, _ := models.GetAddActivityInfoByTitle(activityName, findStartDate, findEndDate)
				if activityDetail == nil {
					continue
				} else {
					activityIds += strconv.Itoa(activityDetail.ActivityId) + ","
				}
				list, err := models.GetRoadshowDataList(roadshowTitle, findStartDate, findEndDate)
				if err != nil {
					fmt.Println("GetTacticsList Err:", err.Error())
					return err
				}
				var isPlayback bool // 是否包含回放
				needAddAttendanc := make([]*models.CygxActivityAttendanceDetail, 0)
				var mobileStr string
				if len(list) > 0 {
					fmt.Println("原来的", vAct.RoadshowTitle)
					fmt.Println("处理的", activityName)
					for _, v := range list {
						if v.UserPhone != "" {
							item := new(models.CygxActivityAttendanceDetail)
							item.ActivityId = activityDetail.ActivityId
							item.RealName = v.UserName
							item.Mobile = v.UserPhone
							item.CompanyName = v.Company
							//item.SellerName = sellerName
							item.FirstMeetingTime = v.FirstWatchTime
							item.LastMeetingTime = v.LastWatchTime
							item.Duration = utils.GetAttendanceDetailSeconds(v.JoinTime)
							if v.JoinType == 1 {
								item.MeetingTypeStr = "网络"
							} else {
								item.MeetingTypeStr = "电话"
							}
							item.MeetingAuthentication = v.AuthInfo
							if v.DataType == 1 {
								item.MeetingStatusStr = "直播"
							} else {
								item.MeetingStatusStr = "回放"
								isPlayback = true
							}
							item.Position = v.Occupation
							item.UseridEntity = v.UseridEntity
							item.ActivityTime = activityDetail.ActivityTime
							item.CrmCompanyMapStatusId = v.CrmCompanyMapStatusId
							item.CreateTime = time.Now()
							mobileStr += "'" + v.UserPhone + "'" + ","
							needAddAttendanc = append(needAddAttendanc, item)
						}
					}
					if isPlayback && mapActivityId[strconv.Itoa(activityDetail.ActivityId)] == "" {
						activityIdsLongTime += strconv.Itoa(activityDetail.ActivityId) + ","
					}
					mobileStr = strings.TrimRight(mobileStr, ",")
					if mobileStr == "" {
						mobileStr = "1"
					}
					listUser, err := models.GetWxUserOutboundMobile(mobileStr)
					if err != nil {
						fmt.Println("GetWxUserOutboundMobile Err:", err.Error())
						return err
					}
					for k, v := range needAddAttendanc {
						for _, v2 := range listUser {
							if v2.OutboundMobile == v.Mobile || v2.Mobile == v.Mobile {
								if needAddAttendanc[k].CompanyId == 0 {
									needAddAttendanc[k].CompanyId = v2.CompanyId
									needAddAttendanc[k].SellerName = v2.SellerName
									needAddAttendanc[k].CompanyName = v2.CompanyName
									needAddAttendanc[k].IsMeetingStr = 1
								}
							}
						}
					}
					//fmt.Println(mobileStr)
					//参会记录
					err = models.AddAttendancDetail(needAddAttendanc, activityDetail.ActivityId, mobileStr)
					if err != nil {
						fmt.Println("AddAttendancDetail Err:", err.Error())
						return err
					}
					////处理是否限制报名
					err = AddCygxActivityRestrictSignupByAdmin(activityDetail.ActivityId)
					if err != nil {
						fmt.Println("AddCygxActivityRestrictSignupByAdmin Err:", err.Error())
						return err
					}
				}
			}
		}
	}

	//获取需要处理的活动
	listActivity, err := models.GetActivityListByDateTime(startDate, endDate, activityIds, detail.ConfigValue)
	if err != nil {
		fmt.Println("GetTacticsList Err:", err.Error())
		return err
	}
	//通过本地去找进门财经的数据
	for _, vAct := range listActivity {
		doTime := utils.TimeRemoveHms2(vAct.ActivityTime)
		findStartDate := doTime + " 00:00:00"
		findEndDate := doTime + " 23:59:59"
		nameSlice := strings.Split(vAct.ActivityName, "】")
		//对于手动匹配到的活动数据也要更新
		var activityName string
		if len(nameSlice) > 1 {
			if vAct.JmcjRoadshowTitle != "" {
				activityName = vAct.JmcjRoadshowTitle
			} else {
				activityName = nameSlice[len(nameSlice)-1]
			}
			//activityName = nameSlice[len(nameSlice)-1]
			if activityName != "" {
				list, err := models.GetRoadshowDataList(activityName, findStartDate, findEndDate)
				if err != nil {
					fmt.Println("GetTacticsList Err:", err.Error())
					return err
				}
				var isPlayback bool // 是否包含回放
				needAddAttendanc := make([]*models.CygxActivityAttendanceDetail, 0)
				var mobileStr string
				if len(list) > 0 {
					fmt.Println("原来的1", vAct.ActivityName)
					fmt.Println("处理的2", activityName)
					for _, v := range list {
						if v.UserPhone != "" {
							item := new(models.CygxActivityAttendanceDetail)
							item.ActivityId = vAct.ActivityId
							item.RealName = v.UserName
							item.Mobile = v.UserPhone
							item.CompanyName = v.Company
							//item.SellerName = sellerName
							item.FirstMeetingTime = v.FirstWatchTime
							item.LastMeetingTime = v.LastWatchTime
							item.Duration = utils.GetAttendanceDetailSeconds(v.JoinTime)
							if v.JoinType == 1 {
								item.MeetingTypeStr = "网络"
							} else {
								item.MeetingTypeStr = "电话"
							}
							item.MeetingAuthentication = v.AuthInfo
							if v.DataType == 1 {
								item.MeetingStatusStr = "直播"
							} else {
								item.MeetingStatusStr = "回放"
								isPlayback = true
							}
							item.Position = v.Occupation
							item.UseridEntity = v.UseridEntity
							item.ActivityTime = vAct.ActivityTime
							item.CrmCompanyMapStatusId = v.CrmCompanyMapStatusId
							item.CreateTime = time.Now()
							mobileStr += "'" + v.UserPhone + "'" + ","
							needAddAttendanc = append(needAddAttendanc, item)
						}
					}
					if isPlayback && mapActivityId[strconv.Itoa(vAct.ActivityId)] == "" {
						activityIdsLongTime += strconv.Itoa(vAct.ActivityId) + ","
					}
					mobileStr = strings.TrimRight(mobileStr, ",")
					if mobileStr == "" {
						mobileStr = "1"
					}
					listUser, err := models.GetWxUserOutboundMobile(mobileStr)
					if err != nil {
						fmt.Println("GetWxUserOutboundMobile Err:", err.Error())
						return err
					}
					for k, v := range needAddAttendanc {
						for _, v2 := range listUser {
							if v2.OutboundMobile == v.Mobile || v2.Mobile == v.Mobile {
								if needAddAttendanc[k].CompanyId == 0 {
									needAddAttendanc[k].CompanyId = v2.CompanyId
									needAddAttendanc[k].SellerName = v2.SellerName
									needAddAttendanc[k].CompanyName = v2.CompanyName
									needAddAttendanc[k].IsMeetingStr = 1
								}
							}
						}
					}
					////参会记录
					err = models.AddAttendancDetail(needAddAttendanc, vAct.ActivityId, mobileStr)
					if err != nil {
						fmt.Println("AddAttendancDetail Err:", err.Error())
						return err
					}
					////处理是否限制报名
					err = AddCygxActivityRestrictSignupByAdmin(vAct.ActivityId)
					if err != nil {
						fmt.Println("AddCygxActivityRestrictSignupByAdmin Err:", err.Error())
						return err
					}
					activityIds += strconv.Itoa(vAct.ActivityId) + ","
				}
			}
		}
	}
	if activityIdsLongTime != "" {
		activityIdsLongTime = strings.TrimRight(activityIdsLongTime, ",")
		activityIdsLongTime = detail.ConfigValue + "," + activityIdsLongTime
		go models.UpdateConfigByCode(activityIdsLongTime, configCode)
	}

	activityIds = strings.TrimRight(activityIds, ",")
	if activityIds != "" {
		detailList, err := models.GetActivityAttendanceDetailList(activityIds)
		if err != nil {
			fmt.Println("GetActivityAttendanceDetailList Err:", err.Error())
			return err
		}
		//添加报名日志 (下载使用)
		err = models.AddCygxActivityMeetDetailLogOnlineByList(detailList, activityIds)
		if err != nil {
			fmt.Println("AddCygxActivityMeetDetailLogOnline Err:", err.Error())
			return err
		}
	}
	fmt.Println("结束路演同步")
	return
}

//判断是否加入黑名单
func AddCygxActivityRestrictSignupByAdmin(activityId int) (err error) {
	total, err := models.GetActivitySignupNomeetingCount(activityId)
	if err != nil {
		utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
		fmt.Println(" Err:", err.Error())
		return err
	}
	if total == 0 {
		return err
	}
	mobileList, _ := models.GetUserMeetingMobile(activityId)
	if len(mobileList) >= 0 {
		for _, v := range mobileList {
			totalRestrict, err := models.GetRestrictSignupCountByUid(v.UserId)
			if err != nil {
				fmt.Println(" Err:", err.Error())
				utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
				return err
			}
			totalNomeet, err := models.GetActivitySignupNomeetingCountByUid(v.UserId)
			if err != nil {
				fmt.Println(" Err:", err.Error())
				utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
				return err
			}
			if totalRestrict > 0 && totalNomeet < 3 {
				err = models.DeleteCygxActivityRestrictSignup(v.UserId)
				if err != nil {
					fmt.Println(" Err:", err.Error())
					utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
					return err
				}
			}
		}
	}

	list, err := models.GetActivitySignupNomeetingCountList(activityId)
	if err != nil {
		utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
		fmt.Println(" 用户限制报名失败 Err:", err.Error())
		return err
	}
	for _, v := range list {
		totalRestrict, err := models.GetRestrictSignupCountByUid(v.UserId)
		if err != nil {
			fmt.Println(" Err:", err.Error())
			utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
			return err
		}
		totalNomeet, err := models.GetActivitySignupNomeetingCountByUid(v.UserId)
		if err != nil {
			fmt.Println(" Err:", err.Error())
			utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
			return err
		}
		if totalNomeet >= 3 {
			if totalRestrict == 0 {
				infoUser, err := models.GetUserAndCompanyNameList(v.UserId)
				if err != nil {
					fmt.Println(" Err:", err.Error())
					utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
					return err
				}
				if infoUser != nil {
					item := new(models.CygxActivityRestrictSignup)
					item.UserId = infoUser.UserId
					item.CreateTime = time.Now()
					item.Mobile = infoUser.Mobile
					item.Email = infoUser.Email
					item.CompanyId = infoUser.CompanyId
					item.CompanyName = infoUser.CompanyName
					item.IsRestrict = 1
					err = models.AddCygxActivityRestrictSignup(item)
					if err != nil {
						fmt.Println(" Err:", err.Error())
						utils.FileLog.Info("用户限制报名失败,Err:%s,%s", err.Error())
						return err
					}
				}
			}
		}
	}
	return
}

//判断预约纪要按钮是否显示
func IsShowAppointment(activityTypeId int, chartPermissionName string) (isShowAppointment bool) {
	if activityTypeId == 1 || activityTypeId == 2 || activityTypeId == 3 || activityTypeId == 4 {
		isShowAppointment = true
	}
	if activityTypeId == 5 && chartPermissionName == "医药" {
		isShowAppointment = true
	}
	return
}

//判断预约纪要按钮是否显示
func IsShowAppointmentByactivityInfo(item *models.ActivityDetail, chartPermissionName string) (isShowAppointment bool) {
	activityTypeId := item.ActivityTypeId
	if activityTypeId == 1 || activityTypeId == 3 || activityTypeId == 4 {
		isShowAppointment = true
	}
	if activityTypeId == 5 && chartPermissionName == "医药" {
		isShowAppointment = true
	}
	if activityTypeId == 2 && item.IsLimitPeople == 0 {
		isShowAppointment = true
	}
	return
}

//用户报告操作行为，模板消息推送 （先放在活动模块下，避免代码冲突）
func ArticleUserRemind(user *models.WxUserItem, articleDetail *models.ArticleDetail, source int) (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("同步策略平台阅读数据失败", 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "GetCeLueArticlePv ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	countUser, err := models.GetUserRemind(user.UserId)
	if err != nil {
		return err
	}
	if countUser == 0 {
		return err
	}
	var sourceMsg string
	if source == 1 {
		sourceMsg = "阅读报告"
	} else {
		sourceMsg = "收藏报告"
	}

	//获取销售手机号
	sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return err
	}
	if sellerItemQy != nil {
		openIdList, err := models.GetUserRecordListByMobile(4, sellerItemQy.Mobile)
		if err != nil {
			fmt.Println(err)
			return err
		}
		var keyword1 string
		var keyword2 string

		keyword1 = fmt.Sprint(user.RealName, "--", user.CompanyName, ",有新的互动：", sourceMsg)
		keyword2 = articleDetail.Title
		SendWxMsgWithArticleUserRemind(keyword1, keyword2, openIdList, articleDetail.ArticleId)
	}
	return
}

//用户活动操作行为，模板消息推送
func ActivityUserRemind(user *models.WxUserItem, activityDetail *models.ActivityDetail, source int) (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("同步策略平台阅读数据失败", 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "GetCeLueArticlePv ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	countUser, err := models.GetUserRemind(user.UserId)
	if err != nil {
		return err
	}
	if countUser == 0 {
		return err
	}
	var sourceMsg string
	if source == 1 {
		sourceMsg = "预约外呼"
	} else if source == 2 {
		sourceMsg = "设置会议提醒"
	} else if source == 3 {
		sourceMsg = "预约纪要"
	} else if source == 4 {
		sourceMsg = "活动报名"
	}

	//获取销售手机号
	sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return err
	}
	if sellerItemQy != nil {
		openIdList, err := models.GetUserRecordListByMobile(4, sellerItemQy.Mobile)
		if err != nil {
			fmt.Println(err)
			return err
		}
		var keyword1 string
		var keyword2 string
		keyword1 = fmt.Sprint(user.RealName, "--", user.CompanyName, ",有新的互动：", sourceMsg)
		keyword2 = activityDetail.ActivityName
		SendWxMsgWithActivityUserRemind(keyword1, keyword2, openIdList, activityDetail.ActivityId)
	}
	return
}

//用户专项调研操作行为，模板消息推送
func SpecialActivityUserRemind(user *models.WxUserItem, activityDetail *models.CygxActivitySpecialDetail, source int) (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("同步策略平台阅读数据失败", 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "GetCeLueArticlePv ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	countUser, err := models.GetUserRemind(user.UserId)
	if err != nil {
		return err
	}
	if countUser == 0 {
		return err
	}
	var sourceMsg string
	if source == 1 {
		sourceMsg = "预报名调研"
	}
	//获取销售手机号
	sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return err
	}
	if sellerItemQy != nil {
		openIdList, err := models.GetUserRecordListByMobile(4, sellerItemQy.Mobile)
		if err != nil {
			fmt.Println(err)
			return err
		}
		var keyword1 string
		var keyword2 string
		keyword1 = fmt.Sprint(user.RealName, "--", user.CompanyName, ",有新的互动：", sourceMsg)
		keyword2 = activityDetail.ResearchTheme
		SendWxMsgWithSpecialActivityUserRemind(keyword1, keyword2, openIdList, activityDetail.ActivityId)
	}
	return
}

//func init() {
//	DoActivityOnenIdWxTemplateMsg()
//}

//周日下午四点半推送全部活动
func DoActivityOnenIdWxTemplateMsg(cont context.Context) (err error) {
	var msg string
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("周日下午四点半推送全部活动失败，DoActivityOnenIdWxTemplateMsg ErrMsg:"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "DoActivityOnenIdWxTemplateMsg ErrMsg:"+err.Error(), utils.EmailSendToUsers)
			fmt.Println(err)
		}
		if msg != "" {
			utils.FileLog.Info("发送模版消息失败,msg:%s", msg)
		}
	}()
	var condition string
	var pars []interface{}
	openidPowerList, err := models.GetCygxUserRecordPower(condition, pars)
	if err != nil {
		return err
	}
	first := "近期所有行业活动预告，欢迎参与"
	keyword1 := "下周活动预告"
	keyword2 := "已发布"
	keyword3 := ""
	keyword4 := "点击查看下周活动列表"
	SendActivityOnenIdWxTemplateMsg(first, keyword1, keyword2, keyword3, keyword4, openidPowerList)
	return
}

func ActivityButtonShow(item *models.ActivityDetail) (articleDetail *models.ActivityDetail) {
	articleDetail = item
	//IsShowAppointment       bool                       `description:"是否展示预约纪要"`
	//IsShowOutboundCall      bool                       `description:"是否展示预约外呼"`
	//IsShowMeetingReminder   bool                       `description:"是否展示会议提醒"`
	//IsShowHelpSsk           bool                       `description:"是否展示帮我带问"`
	//IsShowSignup            bool                       `description:"是否展示我要报名"`

	//如果后台在添加活的时候，关联的报告类型不隐藏预约纪要按钮，而且满足以下展示预约纪要按钮类型就展示
	//if articleDetail.IsHideAppointment == 0 {
	//	articleDetail.IsShowAppointment = IsShowAppointmentByactivityInfo(articleDetail, articleDetail.ChartPermissionName)
	//}
	articleDetail.IsShowAppointment = false
	//易董的操作按钮都隐藏
	if articleDetail.YidongActivityId != "" {
		articleDetail.IsShowSignup = false
		return
	}
	//新的是否展示规则
	if articleDetail.IsCanAppointmentMinutes == 1 {
		articleDetail.IsShowAppointment = true
	} else {
		articleDetail.IsShowAppointment = false
	}

	//专家电话会 1
	if articleDetail.ActivityTypeId == 1 {
		articleDetail.IsShowOutboundCall = true
		if articleDetail.LimitPeopleNum == 0 {
			articleDetail.IsShowMeetingReminder = true
			articleDetail.IsShowHelpSsk = true
		}
	}

	//分析师电话会 2
	if articleDetail.ActivityTypeId == 2 {
		articleDetail.IsShowOutboundCall = true
		if articleDetail.LimitPeopleNum == 0 {
			articleDetail.IsShowMeetingReminder = true
		}
	}

	//公司调研电话会 3
	if articleDetail.ActivityTypeId == 3 {
		if articleDetail.LimitPeopleNum == 0 {
			articleDetail.IsShowMeetingReminder = true
			articleDetail.IsShowOutboundCall = true
		} else {
			articleDetail.IsShowSignup = true
		}
	}

	//公司线下调研 4
	if articleDetail.ActivityTypeId == 4 {
		articleDetail.IsShowSignup = true
	}

	//专家线下沙龙 5
	if articleDetail.ActivityTypeId == 5 {
		articleDetail.IsShowSignup = true
	}

	//分析师线下沙龙 6
	if articleDetail.ActivityTypeId == 6 {
		articleDetail.IsShowSignup = true
	}

	//分析师电话会（C类） 7
	if articleDetail.ActivityTypeId == 7 {
		articleDetail.IsShowSignup = true
	}

	return
}

//GetActivityVoiceResp 处理活动音频回放
func GetActivityVoiceResp(mapActivityId []int) (mapItem map[int]*models.CygxActivityVoiceReq, err error) {
	activityVoiceList, err := models.GetCygxActivityVoiceReqList(mapActivityId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}

	mapActivityVoice := make(map[int]*models.CygxActivityVoiceReq)
	if len(activityVoiceList) > 0 {
		for _, v := range activityVoiceList {
			mapActivityVoice[v.ActivityId] = v
		}
	}
	mapItem = mapActivityVoice
	return
}

//AddActivitykeyWordSearch 添加活动搜索记录
func AddActivitykeyWordSearch(keyWordSearch string, user *models.WxUserItem) {
	if keyWordSearch != "" {
		keyWordItem := new(models.CygxUserSearchKeyWord)
		keyWordItem.UserId = user.UserId
		keyWordItem.KeyWord = keyWordSearch
		keyWordItem.PageType = "ActivitSearch"
		keyWordItem.CreateTime = time.Now()
		go models.AddUserSearchKeyWord(keyWordItem)

		cacheKey := fmt.Sprint("Search_uid:", user.UserId, "_KeyWord:", keyWordSearch, "_Source:", 6)
		isExist := utils.Rc.IsExist(cacheKey)
		if !isExist {
			setNX := utils.Rc.SetNX(cacheKey, keyWordSearch, time.Minute*1)
			if !setNX {
				go utils.SendAlarmMsg("记录用户搜索活动关键词失败，设置Redis Key 过期时间失败：key"+cacheKey, 3)
			}
			go AddUserSearchLog(user, keyWordSearch, 6)
		}
	}
}

// GetActivityNewLabelMap 获取活动【新】标签Map
func GetActivityNewLabelMap(activityIds []int) (labelMap map[int]bool, err error) {
	labelMap = make(map[int]bool, 0)
	if len(activityIds) == 0 {
		return
	}

	// 获取活动关联的产业
	var groupCond string
	var groupPars []interface{}
	groupCond += ` AND a.activity_id IN (` + utils.GetOrmInReplace(len(activityIds)) + `)`
	groupPars = append(groupPars, activityIds)
	groups, e := models.GetActivityIndustryRelationList(groupCond, groupPars)
	if e != nil {
		err = errors.New("获取活动产业关联列表失败, Err: " + e.Error())
		return
	}
	activityIndustryMap := make(map[int][]int, 0)
	industryIds := make([]int, 0)
	for i := range groups {
		industryIds = append(industryIds, groups[i].IndustrialManagementId)
		activityIndustryMap[groups[i].ActivityId] = append(activityIndustryMap[groups[i].ActivityId], groups[i].IndustrialManagementId)
	}
	industryIdLen := len(industryIds)

	// 获取产业关联的报告最早发布时间及最近的发布时间
	var timeCond string
	var timePars []interface{}
	timeCond += ` AND b.publish_status = 1`
	if industryIdLen > 0 {
		timeCond += ` AND a.industrial_management_id IN (` + utils.GetOrmInReplace(industryIdLen) + `)`
		timePars = append(timePars, industryIds)
	}
	industryTimeList, e := models.GetIndustryArticleMinMaxPublishTime(timeCond, timePars)
	if e != nil {
		err = errors.New("获取产业文章最大最小发布时间失败, Err: " + e.Error())
		return
	}

	// 判断产业是否为新
	nowTime := time.Now().Local()
	threeMonthBefore := nowTime.AddDate(0, -3, 0)
	nullTime, _ := time.Parse(utils.FormatDateTime, "0001-01-01 00:00:00")
	for i := range industryTimeList {
		// 最早发布时间为空 / 最早发布时间在三个月前之后
		if industryTimeList[i].MinPublishTime == nullTime || (industryTimeList[i].MinPublishTime.After(threeMonthBefore)) {
			for k, v := range activityIndustryMap {
				if labelMap[k] {
					continue
				}
				if utils.InArrayByInt(v, industryTimeList[i].IndustrialManagementId) {
					labelMap[k] = true
				}
			}
		}
	}

	return
}