hongze_cygx/controllers/activity.go

package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/medivhzhan/weapp/v2"
	"github.com/rdlucklib/rdluck_tools/paging"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/services"
	"hongze/hongze_cygx/utils"
	"sort"
	"strconv"
	"strings"
	"time"
)

//活动
type ActivityCoAntroller struct {
	BaseAuthController
}

type ActivityABaseController struct {
	BaseCommonController
}

// @Title 活动类型列表
// @Description活动类型列表接口
// @Success 200 {object} models.ActivityTypeListResp
// @router /activityTypelist [get]
func (this *ActivityCoAntroller) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	resp := new(models.ActivityTypeListResp)
	list, err := models.GetActivityTypeList()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 活动列表
// @Description 获取活动列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ChartPermissionIds   query   string  false     "行业id 多个用 , 隔开"
// @Param   ActivityTypeIds   query   string  false     "活动类型id 多个用 , 隔开"
// @Param   KeyWord   query   string  false       "搜索关键词 多个用 , 隔开"
// @Param   ActiveState   query   string  false       "活动进行状态 未开始：1、进行中2、已结束3"
// @Param   WhichDay   query   string  false       "哪一天 今天：1、明天:2，多个用 , 隔开"
// @Param   IsShowJurisdiction   query   int  false       "是否仅展示有权限的，1是，2否 默认为零"
// @Param   Label   query   string  false       "搜索主题 多个用 , 隔开"
// @Success 200 {object} models.GetCygxActivityListRep
// @router /list [get]
func (this *ActivityCoAntroller) ActivityList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	uid := user.UserId
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	activityTypeIds := this.GetString("ActivityTypeIds")
	whichDay := this.GetString("WhichDay")
	isShowJurisdiction, _ := this.GetInt("IsShowJurisdiction")
	keyWord := this.GetString("KeyWord")
	keyWordSearch := this.GetString("KeyWord")
	activeState := this.GetString("ActiveState")
	label := this.GetString("Label")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if activityTypeIds == "undefined" {
		activityTypeIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" {
		activeState = ""
	}
	if label == "undefined" {
		label = ""
	}
	//更新用户的搜索信息
	itemSearch := new(models.CygxActivityUserSearchContent)
	itemSearch.UserId = uid
	itemSearch.CreateTime = time.Now()
	itemSearch.Mobile = user.Mobile
	itemSearch.Email = user.Email
	itemSearch.CompanyId = user.CompanyId
	itemSearch.CompanyName = user.CompanyName
	itemSearch.ModifyTime = time.Now()
	itemSearch.ChartPermissionids = chartPermissionIds
	itemSearch.ActivityTypeids = activityTypeIds
	itemSearch.ActiveState = activeState
	itemSearch.IsShowJurisdiction = isShowJurisdiction
	//并发缓存校验
	cacheKey := fmt.Sprint("xygx:activity_user_search:add:", uid)
	ttlTime := utils.Rc.GetRedisTTL(cacheKey)
	_, errSearch := models.AddUserSearchContent(itemSearch, ttlTime)
	if errSearch != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errSearch.Error()
		return
	}
	utils.Rc.SetNX(cacheKey, user.Mobile, time.Second*10)
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if isShowJurisdiction == 1 && chartPermissionIds == "" && userType == 4 {
		activityTypeIds = "1,3"
	}

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)
	var condition string
	var pars []interface{}
	//活动可见限制
	var sqlExport string
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionSqlStr += "'" + v + "',"
			}
		} else {
			permissionSqlStr += "'" + v + "',"
		}
	}
	permissionSqlStr = strings.TrimRight(permissionSqlStr, ",")
	permissionSqlStr = strings.Replace(permissionSqlStr, "(主观)", "", -1)
	permissionSqlStr = strings.Replace(permissionSqlStr, "(客观)", "", -1)
	permissionSqlStr = ` AND art.chart_permission_name  IN (` + permissionSqlStr + `)`
	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 += `) `
	if keyWord != "" {
		var mirrorword string
		var mirrorwordSql string
		slicemirrorword := strings.Split(keyWord, ",")
		for _, v := range slicemirrorword {
			mirrorwordSql += "'" + v + "'" + ","
		}
		mirrorwordSql = strings.TrimRight(mirrorwordSql, ",")
		total, err := models.GetActivityMirrorWordCount(mirrorwordSql)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if total > 0 {
			mirrorword, err = models.GetMirrorWord(mirrorwordSql)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "关系词映射获取失败,Err:" + err.Error()
				return
			}
		}
		keyWord = keyWord + "," + mirrorword
		slicekeyWord := strings.Split(keyWord, ",")
		var sqlKeyOr string
		if len(slicekeyWord) >= 2 {
			for _, v := range slicekeyWord {
				if v != "" {
					sqlKeyOr += `  OR art.activity_name LIKE '%` + v + `%' `
				}
			}
			condition += ` AND (art.activity_name LIKE '%` + keyWord + `%' ` + sqlKeyOr + ` )`
		} else {
			condition += ` AND (art.activity_name LIKE '%` + keyWord + `%' )`
		}
	}
	//主题
	if label != "" {
		sliceLabel := strings.Split(label, ",")
		var labelSqlStr string
		for _, v := range sliceLabel {
			labelSqlStr += "'" + v + "',"
		}
		labelSqlStr = strings.TrimRight(labelSqlStr, ",")
		condition = ` AND art.label  IN (` + labelSqlStr + `)`
	}
	//行业名称
	if len(chartPermissionIds) > 0 {
		condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
	}
	if activityTypeIds != "" {
		condition += ` AND art.activity_type_id  IN (` + activityTypeIds + `)`
	}
	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 activeState != "" {
		condition += ` AND art.active_state  IN (` + activeState + `)`
	}
	condition += ` AND art.publish_status = 1 `
	var conditionOr string
	// 有专家权限的这几种用户，不做行业权限校验
	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 + `) `
	}

	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}

	if companyProduct != nil {
		if companyProduct.Scale != "" {
			conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
		}
	}

	condition += ` AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
	total, err := models.GetActivityCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if activeState == "2" || activeState == "3" {
		condition += ` ORDER BY art.activity_time DESC  `
	} else {
		condition += ` ORDER BY art.active_state ASC, art.activity_time ASC  `
	}
	list, errList := models.GetActivityListAll(condition, pars, uid, startSize, pageSize)
	if errList != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + errList.Error()
		return
	}
	var isShow bool
	isShow = services.GetShowSustainable()
	detail, err := models.GetConfigByCode("city_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	detailChart, err := models.GetConfigByCode("chart_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
		return
	}

	addressList := strings.Split(detail.ConfigValue, "{|}")
	mapAddress := make(map[string]string)
	chartList := strings.Split(detailChart.ConfigValue, "{|}")
	mapChart := make(map[string]string)
	var cityName string
	var chartName string
	var imgUrl string
	var imgUrlChart string
	for _, v := range addressList {
		vslice := strings.Split(v, "_")
		cityName = vslice[0]
		imgUrl = vslice[len(vslice)-1]
		mapAddress[cityName] = imgUrl
	}
	for _, v := range chartList {
		vslice := strings.Split(v, "_")
		chartName = vslice[0]
		imgUrlChart = vslice[len(vslice)-1]
		mapChart[chartName] = imgUrlChart
	}
	for k, v := range list {
		if strings.Contains(v.ActivityName, "【") {
			list[k].IsBrackets = 1
		}
		if v.SignupNum > v.LimitPeopleNum {
			list[k].SignupNum = v.LimitPeopleNum
		}
		if isShow && strings.Contains(v.ChartPermissionName, "研选") {
			list[k].IsShowSustainable = true
		}
		if strings.Contains(v.ChartPermissionName, "研选") && v.ActivityTypeId == 1 {
			list[k].ActivityTypeName = "买方研选电话会"
			list[k].ImgUrlText = "https://hongze.oss-cn-shanghai.aliyuncs.com/static/images/202112/20211221/bIdfv8t86xrFRpDOeGGHXOmKEuKl.png"
		}
		if v.ActivityType == 0 {
			if mapAddress[v.City] != "" {
				list[k].ImgUrl = mapAddress[v.City]
			} else {
				list[k].ImgUrl = mapAddress["其它"]
			}
		} else {
			if mapChart[v.ChartPermissionName] != "" {
				list[k].ImgUrl = mapChart[v.ChartPermissionName]
			}
		}
		expertTxt, _ := services.GetReportContentTextSub(v.Expert)
		list[k].Expert = expertTxt
	}
	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 services.AddUserSearchLog(user, keyWordSearch, 6)
		}
	}
	resp := new(models.GetCygxActivityListRep)
	//处理列表的标签是否展示逻辑
	for _, v := range list {
		resp.List = append(resp.List, services.ActivityButtonShow(v))
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.List = list
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp

}

// @Title 我的日程
// @Description 我的日程列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Success 200 {object} models.GetCygxActivityListRep
// @router /scheduleList [get]
func (this *ActivityCoAntroller) ScheduleList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	uid := user.UserId
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)
	var condition string
	var conditionCount string
	var pars []interface{}
	condition += ` AND art.publish_status = 1    `
	total, err := models.GetScheduleCount(conditionCount, uid)
	page := paging.GetPaging(currentIndex, pageSize, total)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	conditionCount = ` 	AND art.active_state = 2 `
	totalCount, err := models.GetScheduleCount(conditionCount, uid) //获取正在进行中的活动数量
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	var list []*models.ActivityDetail
	//全部都是进行中的活动
	if totalCount > currentIndex*pageSize {
		condition += ` AND art.active_state IN(2) `
		listHave, errList := models.GetScheduleList(condition, pars, uid, startSize, pageSize)
		list = listHave
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
	} else if totalCount > currentIndex-1*pageSize && totalCount < currentIndex*pageSize { //部分是进行中的活动
		condition = `  AND art.publish_status = 1 AND art.active_state IN(2) `
		listHave, errList := models.GetScheduleList(condition, pars, uid, startSize, pageSize)
		list = listHave
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
		pageSize = pageSize - len(listHave)
		condition = ` AND art.publish_status = 1 AND art.active_state IN(1,3) `
		listOther, errList := models.GetScheduleList(condition, pars, uid, startSize, pageSize)
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
		if len(listOther) > 0 {
			for _, v := range listOther {
				list = append(list, v)
			}
		}
	} else {
		condition += ` AND art.active_state IN(1,3)` //全部都不是进行中的活动
		listOther, errList := models.GetScheduleList(condition, pars, uid, startSize, pageSize)
		list = listOther
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
	}
	var isShow bool
	isShow = services.GetShowSustainable()
	detail, err := models.GetConfigByCode("city_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	detailChart, err := models.GetConfigByCode("chart_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
		return
	}

	addressList := strings.Split(detail.ConfigValue, "{|}")
	mapAddress := make(map[string]string)
	chartList := strings.Split(detailChart.ConfigValue, "{|}")
	mapChart := make(map[string]string)
	var cityName string
	var chartName string
	var imgUrl string
	var imgUrlChart string
	for _, v := range addressList {
		vslice := strings.Split(v, "_")
		cityName = vslice[0]
		imgUrl = vslice[len(vslice)-1]
		mapAddress[cityName] = imgUrl
	}
	for _, v := range chartList {
		vslice := strings.Split(v, "_")
		chartName = vslice[0]
		imgUrlChart = vslice[len(vslice)-1]
		mapChart[chartName] = imgUrlChart
	}
	for k, v := range list {
		if strings.Contains(v.ActivityName, "【") {
			list[k].IsBrackets = 1
		}
		if v.SignupNum > v.LimitPeopleNum {
			list[k].SignupNum = v.LimitPeopleNum
		}
		//是否展示限免标签
		if isShow && strings.Contains(v.ChartPermissionName, "研选") {
			list[k].IsShowSustainable = true
		}
		if strings.Contains(v.ChartPermissionName, "研选") && v.ActivityTypeId == 1 {
			list[k].ActivityTypeName = "买方研选电话会"
			list[k].ImgUrlText = "https://hongze.oss-cn-shanghai.aliyuncs.com/static/images/202112/20211221/bIdfv8t86xrFRpDOeGGHXOmKEuKl.png"
		}
		if v.ActivityType == 0 {
			if mapAddress[v.City] != "" {
				list[k].ImgUrl = mapAddress[v.City]
			} else {
				list[k].ImgUrl = mapAddress["其它"]
			}
		} else {
			if mapChart[v.ChartPermissionName] != "" {
				list[k].ImgUrl = mapChart[v.ChartPermissionName]
			}
		}
		expertTxt, _ := services.GetReportContentTextSub(v.Expert)
		list[k].Expert = expertTxt
		if v.IsHideAppointment == 0 {
			list[k].IsShowAppointment = services.IsShowAppointment(v.ActivityTypeId, v.ChartPermissionName)
		}
		if v.ActivityTypeId == utils.C_CLASS_ACTIVITY_TYPE_ID {
			list[k].IsCClassMeeting = true
		}
	}
	//添加我的日程访问记录
	item := new(models.CygxPageHistoryRecord)
	item.UserId = user.UserId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.PageType = "MySchedule"
	go models.AddCygxPageHistoryRecord(item)
	resp := new(models.GetCygxActivityListRep)
	//处理列表的标签是否展示逻辑
	for _, v := range list {
		resp.List = append(resp.List, services.ActivityButtonShow(v))
	}
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title  活动详情
// @Description 获取活动详情接口
// @Param   ActivityId   query   int  true       "活动ID"
// @Success Ret=200 {object} models.CygxActivityResp
// @router /detail [get]
func (this *ActivityCoAntroller) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	activityId, _ := this.GetInt("ActivityId")
	if activityId < 1 {
		br.Msg = "请输入活动ID"
		return
	}
	resp := new(models.CygxActivityResp)
	hasPermission := 0
	var companyDetailStatus string
	activityInfo, err := models.GetAddActivityInfoByIdShow(uid, activityId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取活动详情信息失败，Err:" + err.Error()
		return
	}
	if activityInfo == nil {
		br.Msg = "活动不存在"
		br.ErrMsg = "活动ID错误，Err:" + "activityId：" + strconv.Itoa(activityId)
		return
	}
	if activityInfo.ActivityTypeId == utils.C_CLASS_ACTIVITY_TYPE_ID {
		activityInfo.IsCClassMeeting = true
	}
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//获取FICC销售信息 如果是FICC的客户类型，则默认他申请过
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}
	if user.CompanyId <= 1 {
		companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.HasPermission = hasPermission
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
		companyDetailStatus = companyDetail.Status
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	if activityInfo.IsLimitPeople > 0 {
		noPower, err := services.GetShareNoPowe(activityInfo, permissionStr, userType)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}

		//获取用户的产业规模，判断是否允许可见
		companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}
		if companyProduct != nil {
			if companyProduct.Scale != "" {
				if strings.Count(activityInfo.Scale, companyProduct.Scale) > 0 {
					noPower = false
				}
			}
		}
		if noPower {
			br.Msg = "您暂无查看该活动权限"
			br.ErrMsg = "被分享客户不可见，获取信息失败"
			return
		}
	}

	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}

	detail, errDetail := models.GetActivityTypeDetailById(activityInfo.ActivityTypeId)
	if errDetail != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + errDetail.Error()
		return
	}
	if activityInfo.IsSignup > 0 {
		detail, errDetail := models.GetActivitySignupDetail(activityId, uid)
		if errDetail != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + errDetail.Error()
			return
		}
		activityInfo.SignupType = detail.SignupType
	}
	activityInfo.ShowType = detail.ShowType

	//判断是否已经申请过

	if user.CompanyId > 1 {
		permissionStr, err := models.GetCompanyPermissionByUser(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户权限信息失败,Err:" + err.Error()
			return
		}
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
						sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
						if err != nil && err.Error() != utils.ErrNoRow() {
							br.Msg = "获取信息失败"
							br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
							return
						}
						if sellerItemQy != nil {
							hasPermission = 2
							resp.SellerMobile = sellerItemQy.Mobile
							resp.SellerName = sellerItemQy.RealName
						} else {
							hasPermission = 3
						}
					}
				}
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}
		havePower, err := services.GetHavePower(activityInfo, permissionStr, companyDetailStatus, userType)
		if havePower {
			hasPermission = 1
			resp.HaqveJurisdiction = true
		} else {
			if permissionStr == "专家" {
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				resp.MsgType = "Type"
			} else {
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				resp.MsgType = "Industry"
			}
			if companyItem.ProductId == 2 {
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.OperationMode = "Call"
				hasPermission = 2
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	if hasPermission == 1 {
		//是否展示限免标签
		if services.GetShowSustainable() && strings.Contains(activityInfo.ChartPermissionName, "研选") {
			activityInfo.IsShowSustainable = true
		}
		configCode := "description_of_research"
		detail, err := models.GetConfigByCode(configCode)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "获取数据失败，Err:" + err.Error()
			return
		}
		activityInfo.Description = detail.ConfigValue
		if activityInfo.SignupNum > activityInfo.LimitPeopleNum {
			activityInfo.SignupNum = activityInfo.LimitPeopleNum
		}
		if activityInfo.ChartPermissionNames != "" {
			activityInfo.ChartPermissionName = activityInfo.ChartPermissionNames
		}
		if activityInfo.IsHideAppointment == 0 {
			activityInfo.IsShowAppointment = services.IsShowAppointment(activityInfo.ActivityTypeId, activityInfo.ChartPermissionName)
		}
		if activityInfo.ReportLink != "" {
			artList := strings.Split(activityInfo.ReportLink, "{|}")
			if len(artList) > 0 {
				for _, v := range artList {
					artitem := new(models.ActivityArticleResp)
					artitem.ReportLink = v
					artIdSlice := strings.Split(v, "/")
					if len(artIdSlice) > 0 {
						articleId, _ := strconv.Atoi(artIdSlice[len(artIdSlice)-1])
						artitem.ArticleId = articleId
					}
					activityInfo.ArticleList = append(activityInfo.ArticleList, artitem)
				}
			}
		} else {
			activityInfo.ArticleList = make([]*models.ActivityArticleResp, 0)
		}
		activityInfo.ActivityTypeName = strings.Replace(activityInfo.ActivityTypeName, "（C类）", "", -1)

		//处理活动关联的产业
		industrialList, err := models.GetIndustrialActivityGroupManagementList(activityId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取活动关联的产业列表信息失败，Err:" + err.Error() + "activityId：" + strconv.Itoa(activityId)
			return
		}
		if activityInfo.TemporaryLabel != "" {
			industrialList = make([]*models.IndustrialManagementRep, 0)
			item := new(models.IndustrialManagementRep)
			item.IndustryName = activityInfo.Label
			industrialList = append(industrialList, item)
		} else {
			var industrialManagementId string
			for k, v := range industrialList {
				if v.ChartPermissionId == utils.CHART_PERMISSION_ID_YANXUAN {
					industrialList[k].IsResearch = true
				}
				industrialManagementId += strconv.Itoa(v.IndustrialManagementId) + ","
			}
			//判断产业下是否有关联的报告，并处理是否跳转
			industrialManagementId = strings.TrimRight(industrialManagementId, ",")
			if industrialManagementId != "" {
				var condition string
				condition = ` AND m.industrial_management_id IN (` + industrialManagementId + `)`
				listIndustrialGrop, err := models.GetSearchResourceList(condition)
				if err != nil && err.Error() != utils.ErrNoRow() {
					br.Msg = "获取信息失败"
					br.ErrMsg = "GetSearchResourceList，Err:" + err.Error() + "activityId：" + strconv.Itoa(activityId)
					return
				}
				mapIndustrial := make(map[int]int)
				if len(listIndustrialGrop) > 0 {
					for _, v := range listIndustrialGrop {
						mapIndustrial[v.IndustrialManagementId] = v.IndustrialManagementId
					}
				}
				for k, v := range industrialList {
					if mapIndustrial[v.IndustrialManagementId] > 0 {
						industrialList[k].IsJump = true
					}
				}
			}
		}
		activityInfo.Listndustrial = industrialList
		//处理按钮是否展示问题
		resp.Detail = services.ActivityButtonShow(activityInfo)
	}
	resp.HasPermission = hasPermission
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 活动报名
// @Description 活动报名接口
// @Param	request	body models.ActivitySingnupRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /signup/add [post]
func (this *ActivityCoAntroller) SignupAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	signupStatus := ""
	var req models.ActivitySingnupRep
	resp := new(models.SignupStatus)
	var total int
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	signupType := req.SignupType
	hasPermission := 0
	if signupType == 1 && user.Mobile == "" && user.OutboundMobile == "" {
		resp.GoBindEmail = true
	}
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}

	//获取FICC销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}

	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//SignupStatus "报名状态：人数已满：FullStarffed、单机构超过两人：TwoPeople、爽约次数过多：BreakPromise、超时：Overtime 、成功：Success"`
	//HasPermission "1:有该行业权限,正常展示，2：无该行业权限，3：潜在客户，未提交过申请，4：潜在客户,已提交过申请"`
	var companyDetailStatus string
	if user.CompanyId <= 1 {
		companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.HasPermission = hasPermission
			resp.ActivityId = activityId
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
		companyDetailStatus = companyDetail.Status
	}
	var userType int
	var permissionStr string
	userType, permissionStr, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}

	item := new(models.CygxActivitySignup)
	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						hasPermission = 3
					}
				}
				resp.ActivityId = activityId
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}
		//1专家电话会、2分析师电话会、3公司调研电话会、4公司线下调研、5专家线下沙龙、6分析师线下沙龙
		//OperationMode     string `description:"操作方式 Apply:立即申请、Call:拨号 为空则为有权限"`
		havePower, err := services.GetHavePower(activityInfo, permissionStr, companyDetailStatus, userType)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if havePower {
			hasPermission = 1
			signupStatus = "Success"
			resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
			if time.Now().After(resultTime.Add(-time.Minute * 60)) {
				signupStatus = "Overtime"
				resp.SignupType = signupType
				resp.SignupStatus = signupStatus
				resp.HasPermission = hasPermission
				br.Ret = 200
				br.Success = true
				br.Msg = ""
				br.Data = resp
				return
			}
			var sellerName string
			sellerName, err = models.GetCompanySellerName(user.CompanyId)
			if err != nil {
				br.Msg = "报名失败！"
				br.ErrMsg = "获取对应销售失败，Err:" + err.Error()
				return
			}
			//人数已满：FullStarffed、单机构超过两人：TwoPeople、爽约次数过多：BreakPromise、超时：Overtime 、成功：Success"`
			//如果是下面几种情况则对报名信息做判断限制 （公司调研电话会（限制人数）、公司线下调研、专家/分析师线下沙龙）
			//if (activityInfo.ActivityTypeId == 3 && activityInfo.IsLimitPeople == 1) || activityInfo.ActivityTypeId > 3 {
			if activityInfo.IsLimitPeople == 1 {
				//判断优先级：总人数限制→单机构2人限制→爽约3次限制
				totalRestrict, err := models.GetUserRestrictCount(user.Mobile)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
					return
				}
				if totalRestrict >= 1 {
					signupStatus = "BreakPromise"
					item.FailType = 3
				}
				totalSignupCompany, err := models.GetActivitySignupCompanyCount(activityId, user.CompanyId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
					return
				}
				if totalSignupCompany >= 2 {
					signupStatus = "TwoPeople"
					item.FailType = 2
				}
				totaSignupPeopleNum, err := models.GetActivitySignupSuccessCount(activityId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
					return
				}
				if totaSignupPeopleNum >= activityInfo.LimitPeopleNum {
					signupStatus = "FullStarffed"
					item.FailType = 1
				}
				totalUserRestrictCount, err := models.GetActivitySignupByUserRestrictCount(uid, activityId)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败，Err:" + err.Error()
					return
				}
				//解除报名限制之后二次报名相同活动
				if totalUserRestrictCount > 0 && totalRestrict == 0 && resp.GoBindEmail != true {
					item.UserId = uid
					item.RealName = user.RealName
					item.SellerName = sellerName
					item.ActivityId = activityId
					item.CreateTime = time.Now()
					item.Mobile = user.Mobile
					item.Email = user.Email
					item.CompanyId = user.CompanyId
					item.CompanyName = user.CompanyName
					item.SignupType = signupType
					item.FailType = 0
					item.DoFailType = 0
					_, errSignup := models.AddActivitySignupByRestrict(item)
					if errSignup != nil {
						br.Msg = "操作失败"
						br.ErrMsg = "操作失败,Err:" + errSignup.Error()
						return
					}
					resp.HaqveJurisdiction = true
					resp.SignupType = signupType
					resp.SignupStatus = "Success"
					resp.HasPermission = hasPermission
					resp.ActivityId = activityId
					total, err = models.GetUserMeetingReminderCount(user.UserId)
					if err != nil {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取日程数量信息失败,Err:" + err.Error()
						return
					}
					if total == 0 {
						resp.GoFollow = true
					}
					br.Ret = 200
					br.Success = true
					br.Msg = "操作成功"
					br.Data = resp
					return
				}
				totalMy, err := models.GetActivitySignupByUserCount(uid, activityId)
				if err != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取失败，Err:" + err.Error()
					return
				}

				if signupStatus != "Success" && totalMy == 0 && resp.GoBindEmail != true {
					item.UserId = uid
					item.RealName = user.RealName
					item.SellerName = sellerName
					item.ActivityId = activityId
					item.CreateTime = time.Now()
					item.Mobile = user.Mobile
					item.Email = user.Email
					item.CompanyId = user.CompanyId
					item.CompanyName = user.CompanyName
					item.SignupType = signupType
					item.DoFailType = item.FailType
					if user.OutboundMobile != "" {
						item.OutboundMobile = user.OutboundMobile
						if user.OutboundCountryCode == "" {
							item.CountryCode = "86"
						} else {
							item.CountryCode = user.OutboundCountryCode
						}
					} else {
						item.OutboundMobile = user.Mobile
						if user.CountryCode == "" {
							item.CountryCode = "86"
						} else {
							item.CountryCode = user.CountryCode
						}
					}
					//添加报名信息，但是不加入日程
					_, errSignup := models.AddActivitySignupNoSchedule(item)
					if errSignup != nil {
						br.Msg = "操作失败"
						br.ErrMsg = "操作失败,Err:" + errSignup.Error()
						return
					}
				}
			}
			totalMySuccess, err := models.GetActivitySignupCount(uid, activityId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败，Err:" + err.Error()
				return
			}
			if totalMySuccess > 0 {
				br.Msg = "您已报名这个活动"
				return
			}
			if signupStatus == "Success" && resp.GoBindEmail != true {
				item.UserId = uid
				item.RealName = user.RealName
				item.SellerName = sellerName
				item.ActivityId = activityId
				item.CreateTime = time.Now()
				item.Mobile = user.Mobile
				item.Email = user.Email
				item.CompanyId = user.CompanyId
				item.CompanyName = user.CompanyName
				item.SignupType = signupType
				item.FailType = 0
				item.DoFailType = 0
				item.OutboundMobile = user.Mobile
				if user.OutboundMobile != "" {
					item.OutboundMobile = user.OutboundMobile
					if user.OutboundCountryCode == "" {
						item.CountryCode = "86"
					} else {
						item.CountryCode = user.OutboundCountryCode
					}
				} else {
					item.OutboundMobile = user.Mobile
					if user.CountryCode == "" {
						item.CountryCode = "86"
					} else {
						item.CountryCode = user.CountryCode
					}
				}
				_, errSignup := models.AddActivitySignup(item)
				if errSignup != nil {
					br.Msg = "操作失败"
					br.ErrMsg = "操作失败,Err:" + errSignup.Error()
					return
				}
				resp.HaqveJurisdiction = true
				//1：预约外呼 、2：设置会议提醒 、 3：预约纪要 、4：活动报名
				if signupType == 1 {
					go services.ActivityUserRemind(user, activityInfo, 1)
				} else {
					go services.ActivityUserRemind(user, activityInfo, 4)
				}

			}
		} else {
			if companyItem.ProductId == 2 {
				hasPermission = 2
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.MsgType = "Type"
				resp.OperationMode = "Call"
				if permissionStr == "专家" {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ActivityTypeName + "】类型活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Type"
				} else {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ChartPermissionName + "】行业活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Industry"
				}
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	if signupType == 1 && user.IsMsgOutboundMobile == 0 {
		resp.GoOutboundMobile = true
		if user.Mobile != "" || user.OutboundMobile != "" {
			go models.ModifyWxUserIsMsgOutboundMobile(user.UserId)
		}
	}
	if user.OutboundMobile == "" {
		resp.Mobile = user.Mobile
		if user.CountryCode == "" && len(user.Mobile) == 11 {
			resp.CountryCode = "86"
		} else {
			resp.CountryCode = user.CountryCode
		}
	} else {
		resp.Mobile = user.OutboundMobile
		resp.CountryCode = user.OutboundCountryCode
	}
	//如果用户有绑定手机号，但是没有绑定外呼手机号
	if signupType == 1 && user.Mobile != "" && user.OutboundMobile == "" {
		var countryCode string
		if len(user.Mobile) == 8 {
			countryCode = "852"
		} else if len(user.Mobile) == 9 {
			countryCode = "886"
		} else if len(user.Mobile) == 10 {
			countryCode = "1"
		} else if len(user.Mobile) >= 11 {
			countryCode = "86"
		}
		models.BindUserOutboundMobileByMobile(user.Mobile, countryCode, uid)
	}
	resp.SignupType = signupType
	resp.SignupStatus = signupStatus
	resp.HasPermission = hasPermission
	//if signupStatus == "Success" {
	resp.ActivityId = activityId
	//}
	total, err = models.GetUserSignupCount(user.UserId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取日程数量信息失败,Err:" + err.Error()
		return
	}
	if total <= 1 {
		resp.GoFollow = true
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	br.Data = resp
}

// @Title 活动取消报名
// @Description 活动取消报名接口
// @Param	request	body models.ActivitySingnupRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /signup/cancel [post]
func (this *ActivityCoAntroller) SignupCancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ActivitySingnupRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	signupType := req.SignupType
	item := new(models.CygxActivitySignup)
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if time.Now().After(resultTime.Add(-time.Minute * 60)) {
		if signupType == 1 {
			br.Msg = "活动开始前1小时内无法取消预约外呼，请联系对口销售处理"
		} else {
			br.Msg = "活动开始前1小时内无法取消报名，请联系对口销售处理"
		}
		return
	}
	total, err := models.GetActivitySignupCount(uid, activityId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if total == 0 {
		br.Msg = "您暂未报名这个活动"
		return
	}
	item.UserId = uid
	item.ActivityId = activityId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	resp := new(models.SignupStatus)
	resp.ActivityId = activityId
	_, errSignup := models.CancelActivitySignup(item)
	if errSignup != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errSignup.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	br.Data = resp
}

// @Title  用户搜索详情
// @Description 获取用户搜索详情接口
// @Param   IsShowJurisdiction   query   int  true       "是否仅展示有权限的，默认为0，1是，2否 "
// @Success Ret=200 {object} models.ActivityUserSearchContentList
// @router /getUserSearchContent [get]
func (this *ActivityCoAntroller) GetUserSearchContent() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	detailSeearch := new(models.CygxActivityUserSearchContent)
	detailSeearch.IsShowJurisdiction = 0
	detailSeearch.ChartPermissionids = ""
	detailSeearch.ActiveState = ""
	resp := new(models.ActivityUserSearchContentList)
	detail, _ := models.GetUserSearchContentByUid(uid)
	if detail == nil {
		detail = detailSeearch
	}
	isShowJurisdiction, _ := this.GetInt("IsShowJurisdiction")
	listActivityType, errActivityType := models.GetActivityTypeList()
	if errActivityType != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + errActivityType.Error()
		return
	}
	var listChartPermissionid []*models.ActivityChartPermission
	var errChart error
	if isShowJurisdiction == 1 {
		listChartPermissionidAll, errChartAll := models.GetUserCompanyPermission(user.CompanyId)
		listChartPermissionid = listChartPermissionidAll
		errChart = errChartAll
	} else if isShowJurisdiction == 2 {
		listChartPermissionidAll, errChartAll := models.GetChartPermissionActivity()
		listChartPermissionid = listChartPermissionidAll
		errChart = errChartAll
	} else {
		if detail.IsShowJurisdiction == 1 {
			listChartPermissionidAll, errChartAll := models.GetUserCompanyPermission(user.CompanyId)
			listChartPermissionid = listChartPermissionidAll
			errChart = errChartAll
		} else {
			listChartPermissionidAll, errChartAll := models.GetChartPermissionActivity()
			listChartPermissionid = listChartPermissionidAll
			errChart = errChartAll
		}
	}

	if errChart != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + errChart.Error()
		return
	}
	if detail.IsShowJurisdiction == 1 {
		resp.IsShowJurisdiction = true
	}
	if isShowJurisdiction == 1 || detail.IsShowJurisdiction == 1 {
		resp.IsShowJurisdiction = true
		for k, _ := range listChartPermissionid {
			listChartPermissionid[k].IsChoose = true
		}
	}
	if isShowJurisdiction == 2 {
		resp.IsShowJurisdiction = false
	}
	activeStateList := []models.ActivityStaus{models.ActivityStaus{Id: 1, StatusName: "未开始", IsChoose: true}, models.ActivityStaus{Id: 2, StatusName: "进行中"}, models.ActivityStaus{Id: 3, StatusName: "已结束"}}
	list2, err := models.GetChartPermissionActivity()
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}

	if activeStateList[1].IsChoose == activeStateList[2].IsChoose == false {
		activeStateList[0].IsChoose = true
	}
	var userType int
	userType, _, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	var listChartPermissionidNew2 []*models.ActivityChartPermission
	for _, v := range list2 {
		if userType == 1 {
			//if v.PermissionName != "研选" {
			if !strings.Contains(v.PermissionName, "研选") {
				listChartPermissionidNew2 = append(listChartPermissionidNew2, v)
			}
		} else {
			listChartPermissionidNew2 = append(listChartPermissionidNew2, v)
		}
	}
	resp.ListChartPermission2 = listChartPermissionidNew2
	var listChartPermissionidNew []*models.ActivityChartPermission
	for _, v := range listChartPermissionid {
		if userType == 1 {
			if !strings.Contains(v.PermissionName, "研选") {
				listChartPermissionidNew = append(listChartPermissionidNew, v)
			}
		} else {
			listChartPermissionidNew = append(listChartPermissionidNew, v)
		}
	}
	resp.ListActivityType = listActivityType
	resp.ListChartPermission = listChartPermissionidNew
	resp.ListActivityStaus = activeStateList
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 添加会议提醒
// @Description 添加会议提醒接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /meetingReminder/add [post]
func (this *ActivityCoAntroller) MeetingReminderAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	//var signupStatus string
	signupStatus := "Success"
	var req models.ActivityIdRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}

	//获取销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}

	//SignupStatus string `description:"报名状态：人数已满：FullStarffed、单机构超过两人：TwoPeople、爽约次数过多：BreakPromise、超时：Overtime 、成功：Success"`
	item := new(models.CygxActivityMeetingReminder)
	resp := new(models.SignupStatus)
	hasPermission := 0
	var companyDetailStatus string
	if user.CompanyId <= 1 {
		companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.ActivityId = activityId
			resp.HasPermission = hasPermission
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
		companyDetailStatus = companyDetail.Status
	}
	var userType int
	var permissionStr string
	userType, permissionStr, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}
	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if time.Now().After(resultTime.Add(-time.Minute * 15)) {
		br.Msg = "活动开始前15分钟无法设置会议提醒"
		return
	}
	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				//如果是FICC的客户类型，则默认他申请过
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						hasPermission = 3
					}
				}
				resp.ActivityId = activityId
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}

		havePower, err := services.GetHavePower(activityInfo, permissionStr, companyDetailStatus, userType)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if havePower {
			hasPermission = 1
			signupStatus = "Success"
			totalMeeting, errMeeting := models.GetActivityMeetingReminderCount(uid, activityId)
			if errMeeting != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败，Err:" + errMeeting.Error()
				return
			}
			if totalMeeting > 0 {
				br.Msg = "您已预约，请勿重复预约"
				return
			}
			item.UserId = uid
			item.ActivityId = activityId
			item.CreateTime = time.Now()
			item.Mobile = user.Mobile
			item.Email = user.Email
			item.CompanyId = user.CompanyId
			item.CompanyName = user.CompanyName
			_, errSignup := models.AddActivityMeetingReminder(item)
			if errSignup != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "操作失败,Err:" + errSignup.Error()
				return
			}
			resp.HaqveJurisdiction = true
			//1：预约外呼 、2：设置会议提醒 、 3：预约纪要 、4：活动报名
			go services.ActivityUserRemind(user, activityInfo, 2)
		} else {
			if companyItem.ProductId == 2 {
				hasPermission = 2
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.MsgType = "Type"
				resp.OperationMode = "Call"
				if permissionStr == "专家" {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ActivityTypeName + "】类型活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Type"
				} else {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ChartPermissionName + "】行业活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Industry"
				}
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	resp.HasPermission = hasPermission
	resp.SignupStatus = signupStatus
	resp.ActivityId = activityId
	var total int
	total, err = models.GetUserActivityMeetingReminderCount(user.UserId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取日程数量信息失败,Err:" + err.Error()
		return
	}
	if total <= 1 {
		resp.GoFollow = true
	}
	br.Ret = 200
	br.Success = true
	if hasPermission == 1 {
		br.Msg = "设置成功，会前15分钟会为您推送微信消息提醒"
	}
	br.Data = resp
}

// @Title 取消会议提醒
// @Description 取消会议提醒接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /meetingReminder/cancel [post]
func (this *ActivityCoAntroller) MeetingReminderCancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ActivityIdRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	signupStatus := "Success"
	item := new(models.CygxActivityMeetingReminder)
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}

	//if signupStatus == "Success" {
	total, err := models.GetActivityMeetingReminderCount(uid, activityId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if total == 0 {
		br.Msg = "您暂未添加该活动会议提醒"
		return
	}
	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if time.Now().After(resultTime.Add(-time.Minute * 15)) {
		br.Msg = "活动开始前15分钟无法取消会议提醒"
		return
	}
	item.UserId = uid
	item.ActivityId = activityId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	_, errSignup := models.CancelActivityMeetingReminder(item)
	if errSignup != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errSignup.Error()
		return
	}
	//}
	resp := new(models.SignupStatus)
	resp.SignupStatus = signupStatus
	resp.ActivityId = activityId
	br.Ret = 200
	br.Success = true
	br.Msg = "会议提醒已取消"
	br.Data = resp
}

// @Title 敏捷搜索关键词的列表
// @Description 获取敏捷搜索关键词的列表接口
// @Success 200 {object} models.ActivityFastsearchKeywordsListResp
// @router /fastSearchKeWord [get]
func (this *ActivityABaseController) FastSearch() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	resp := new(models.ActivityFastsearchKeywordsListResp)
	list, err := models.GetActivityFastsearchKeywordsList()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 主题列表
// @Description 获取活动主题列表接口
// @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   Label   query   string  false       "搜索主题 多个用 , 隔开 （空为活动主题，非空为更多主题）"
// @Success 200 {object} models.GetCygxActivityLabelListRep
// @router /labelList_deltest [get]
func (this *ActivityCoAntroller) LabelList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	activityTypeIds := this.GetString("ActivityTypeIds")
	whichDay := this.GetString("WhichDay")
	isShowJurisdiction, _ := this.GetInt("IsShowJurisdiction")
	activeState := this.GetString("ActiveState")
	label := this.GetString("Label")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if activityTypeIds == "undefined" {
		activityTypeIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" {
		activeState = ""
	}
	if label == "undefined" {
		label = ""
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if isShowJurisdiction == 1 && chartPermissionIds == "" && userType == 4 {
		activityTypeIds = "1,3"
	}
	var startSize int
	pageSize = 15
	var condition string
	var sortTime string
	var pars []interface{}
	//活动可见限制
	var sqlExport string
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionSqlStr += "'" + v + "',"
			}
		} else {
			permissionSqlStr += "'" + v + "',"
		}
	}
	permissionSqlStr = strings.TrimRight(permissionSqlStr, ",")
	permissionSqlStr = strings.Replace(permissionSqlStr, "(主观)", "", -1)
	permissionSqlStr = strings.Replace(permissionSqlStr, "(客观)", "", -1)
	permissionSqlStr = ` AND art.chart_permission_name  IN (` + permissionSqlStr + `)`
	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 += `) `
	condition += ` AND art.publish_status = 1  AND art.label != '' `
	var conditionOr string
	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 + `) `
	}
	condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
	resp := new(models.GetCygxActivityLabelListRep)
	//主题
	if label != "" {
		sortTime = ` timesort DESC `
		listAll, errList := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, 32)
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
		sortTime = ` mintimesort ASC `
		condition += ` AND art.active_state = 1 `
		list1, errList := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, 16)
		if errList != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + errList.Error()
			return
		}
		for _, v := range listAll {
			var isHAve bool
			for _, v2 := range list1 {
				if v2.KeyWord == v.KeyWord {
					isHAve = true
				}
			}
			if !isHAve {
				resp.List = append(resp.List, v)
			}
		}
		resp.Label = label
		resp.ImgUrl = ""
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		return
	} else {
		//行业名称
		condition = ` AND art.publish_status = 1  AND art.label != '' `
		if len(chartPermissionIds) > 0 {
			condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
		}
		if activityTypeIds != "" {
			condition += ` AND art.activity_type_id  IN (` + activityTypeIds + `)`
		}
		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 activeState != "" {
			condition += ` AND art.active_state  IN (` + activeState + `)`
		} else {
			condition += ` AND art.active_state  IN (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 + `) `
		}
		condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
	}
	sortTime = ` mintimesort ASC `
	list, errList := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
	if errList != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + errList.Error()
		return
	}
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 活动带问
// @Description 新增活动带问接口
// @Param	request	body models.AddCygxActivityHelpAsk true "type json string"
// @Success Ret=200 新增成功
// @router /askAdd [post]
func (this *ActivityCoAntroller) AskAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.CygxActivityHelpAsk
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.Content == "" {
		br.Msg = "建议内容不可为空"
		return
	}
	content := req.Content
	itemToken, err := services.WxGetToken()
	if err != nil {
		br.Msg = "GetWxAccessToken Err:" + err.Error()
		return
	}
	if itemToken.AccessToken == "" {
		br.Msg = "accessToken is empty"
		return
	}
	commerr, err := weapp.MSGSecCheck(itemToken.AccessToken, content)
	if err != nil {
		br.Msg = "内容校验失败！"
		br.ErrMsg = "内容校验失败，Err:" + err.Error()
		return
	}
	if commerr.ErrCode != 0 {
		br.Msg = "内容违规,请重新提交！"
		br.ErrMsg = "颜文字内容违规，Err:" + commerr.ErrMSG
		return
	}
	activityId := req.ActivityId
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	//if activityInfo.ActivityTypeId == 1 && activityInfo.ChartPermissionId != 31 {
	//	if time.Now().After(resultTime.Add(-time.Minute * 15)) {
	//		br.Msg = "活动开始前15分钟内无法提交问题"
	//		return
	//	}
	//} else {
	//	if time.Now().After(resultTime.Add(-time.Minute * 60)) {
	//		br.Msg = "活动开始前1小时内无法提交问题"
	//		return
	//	}
	//}

	companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
	if err != nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if companyDetail == nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId)
		return
	}
	item := new(models.CygxActivityHelpAsk)
	item.UserId = user.UserId
	item.ActivityId = req.ActivityId
	item.CompanyId = user.CompanyId
	item.CompanyName = companyDetail.CompanyName
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.Content = content
	_, err = models.AddActivityHelpAsk(item)
	if err != nil {
		br.Msg = "提交失败"
		br.ErrMsg = "提交带问失败,Err:" + err.Error()
		return
	}

	var isSendMsg bool
	resultTime := utils.StrTimeToTime(activityInfo.ActivityTime) //时间字符串格式转时间格式
	if activityInfo.ActivityTypeId == 1 && activityInfo.ChartPermissionId != 31 {
		if time.Now().After(resultTime.Add(-time.Minute * 15)) {
			isSendMsg = true
		}
	} else {
		if time.Now().After(resultTime.Add(-time.Minute * 60)) {
			isSendMsg = true
		}
	}
	if isSendMsg {
		listEmail, err := models.GetAskEmail()
		if err != nil {
			br.Msg = "提交失败"
			br.ErrMsg = "提交带问失败,Err:" + err.Error()
			return
		}
		var sendMobile string
		for _, v := range listEmail {
			if strings.Index(activityInfo.Host, v.Name) > 0 {
				sendMobile = v.Mobile
			}
		}
		if activityInfo.ChartPermissionId == 31 {
			sendMobile = utils.ActSendMsgMobile
		}

		//获取销售信息
		sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "提交失败"
			br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
			return
		}
		//给研究员发送消息
		if sendMobile != "" {
			openIpItem, _ := models.GetUserRecordByMobile(4, sendMobile)
			if openIpItem != nil && openIpItem.OpenId != "" {
				if sellerItem != nil {
					services.SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", time.Now().Format(utils.FormatDateTime), req.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
				}
			}
		}
		// 给所属销售发送消息
		if sellerItem != nil {
			openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
			if openIpItem != nil && openIpItem.OpenId != "" {
				services.SendActivityAskApplyTemplateMsg(user.RealName+"——"+user.CompanyName+"(所属销售："+sellerItem.RealName+"）", time.Now().Format(utils.FormatDateTime), req.Content, activityInfo.ActivityName, activityInfo.ActivityId, openIpItem)
			}
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "提交成功"
}

// @Title 活动类型下的主题列表（4.3版本）
// @Description 获取活动类型下的主题列表接口（4.3版本）
// @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"
// @Success 200 {object} models.ActivityTypeListHomeResp
// @router /labelTypeList_deltest [get]
func (this *ActivityCoAntroller) LabelTypeList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	isPower, _ := this.GetInt("IsPower")
	//currentIndex, _ := this.GetInt("CurrentIndex")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	//activityTypeIds := this.GetString("ActivityTypeIds")
	whichDay := this.GetString("WhichDay")
	activeState := this.GetString("ActiveState")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" || activeState == "" {
		activeState = "1"
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	var startSize int
	pageSize = 40
	var sortTime string
	var pars []interface{}
	//活动可见限制
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	var permissionNameStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionNameStr += "'" + v + "',"
			}
		} else {
			permissionNameStr += "'" + v + "',"
		}
	}
	permissionNameStr = strings.Replace(permissionNameStr, "(主观)", "", -1)
	permissionNameStr = strings.Replace(permissionNameStr, "(客观)", "", -1)
	permissionNameStr = strings.TrimRight(permissionNameStr, ",")
	list, err := models.GetActivityTypeHomeList()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ActivityTypeListHomeResp)
	for k, v := range list {
		var sqlExport string
		var condition 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 += `) `
		condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.activity_type_id = ` + strconv.Itoa(v.ActivityTypeId)
		if isPower == 1 {
			condition += permissionSqlStr
		}
		//行业名称
		if len(chartPermissionIds) > 0 {
			condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
		}
		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 activeState != "" {
			condition += ` AND art.active_state  IN (` + activeState + `)`
		} else {
			condition += ` AND art.active_state  IN (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 + `) `
		}
		//判断客户规模是否属于可见范围的活动
		companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}

		if companyProduct != nil {
			if companyProduct.Scale != "" {
				conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
			}
		}

		condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr

		sortTime = ` mintimesort ASC `
		labelList, err := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		//标签字段关联的产业与标签处理
		for k2, v2 := range labelList {
			labelList[k2].KeyWord = services.LabelStr(v2.KeyWord)
			labelList[k2].ImgUrlBg = v.ImgUrlBgs
		}
		list[k].List = labelList
	}
	//获取对应活动的数量并排序
	intArr := make([]int, 0)
	var items []*models.ActivityTypeHome
	for _, v := range list {
		item := new(models.ActivityTypeHome)
		if len(v.List) > 0 {
			item.List = v.List
			item.ActivityTypeName = v.ActivityTypeName
			item.ActivityTypeId = v.ActivityTypeId
			item.ImgUrlBg = v.ImgUrlBg
			item.ImgUrl = v.ImgUrl
			items = append(items, item)
			intArr = append(intArr, len(v.List))
		}
	}
	sort.Sort(sort.Reverse(sort.IntSlice(intArr)))
	var itemsNew []*models.ActivityTypeHome
	activityMap := make(map[int]int)
	for _, v := range intArr {
		for _, v2 := range items {
			item := new(models.ActivityTypeHome)
			if len(v2.List) > 0 && v == len(v2.List) && activityMap[v2.ActivityTypeId] == 0 {
				item.List = v2.List
				item.ActivityTypeName = v2.ActivityTypeName
				item.ActivityTypeId = v2.ActivityTypeId
				item.ImgUrlBg = v2.ImgUrlBg
				item.ImgUrl = v2.ImgUrl
				itemsNew = append(itemsNew, item)
				activityMap[v2.ActivityTypeId] = len(v2.List)
			}
		}
	}
	//如果第三个活动数量比第四个多，则两者调换
	if len(itemsNew) > 3 {
		if len(itemsNew[2].List) > len(itemsNew[3].List) {
			var itemsNewCopy []*models.ActivityTypeHome
			for _, v := range itemsNew {
				itemsNewCopy = append(itemsNewCopy, v)
			}
			itemsNew[2] = itemsNewCopy[3]
			itemsNew[3] = itemsNewCopy[2]
		}
	}

	//记录用户搜索的筛选条件

	item := new(models.CygxActivitySearchHistory)
	item.UserId = user.UserId
	item.Mobile = user.Mobile
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.CreateTime = time.Now()
	item.ChartPermissionIds = chartPermissionIds
	item.IsPower = isPower
	item.WhichDay = whichDay
	go models.AddCygxActivitySearchHistory(item)

	resp.List = itemsNew
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 更多主题列表（4.3版本）
// @Description 获取活动更多主题列表接口（4.3版本）
// @Success 200 {object} models.GetCygxActivityLabelListRep
// @router /labelMoreList [get]
func (this *ActivityCoAntroller) LabelMoreList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	var startSize, pageSize int
	pageSize = 24
	var condition string
	var sortTime string
	//var conditionStatus string
	var pars []interface{}
	//活动可见限制
	var sqlExport string
	resp := new(models.GetCygxActivityLabelListRep)
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionSqlStr += "'" + v + "',"
			}
		} else {
			permissionSqlStr += "'" + v + "',"
		}
	}
	permissionSqlStr = strings.TrimRight(permissionSqlStr, ",")
	permissionSqlStr = strings.Replace(permissionSqlStr, "(主观)", "", -1)
	permissionSqlStr = strings.Replace(permissionSqlStr, "(客观)", "", -1)
	permissionSqlStr = ` AND art.chart_permission_name  IN (` + permissionSqlStr + `)`
	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 += `) `

	//进行中的活动
	condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.active_state = 2 `
	var conditionOr string
	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 + `) `
	}
	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}

	if companyProduct != nil {
		if companyProduct.Scale != "" {
			conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
		}
	}
	condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr

	//进行中的活动
	sortTime = ` mintimesort ASC `
	list, errList := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
	if errList != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + errList.Error()
		return
	}

	//已结束的活动
	conditionOr = ""
	condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.active_state = 3 `
	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 + `) `
	}
	condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
	startSize = 0
	pageSize = 24 - len(list)

	//已结束的活动
	sortTime = ` timesort DESC `
	listEnd, err := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	for _, v := range listEnd {
		list = append(list, v)
	}
	//标签字段关联的产业与标签处理
	for k, v := range list {
		list[k].KeyWord = services.LabelStr(v.KeyWord)
	}
	//添加更多主题访问记录
	item := new(models.CygxPageHistoryRecord)
	item.UserId = user.UserId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.PageType = "LabelMore"
	go models.AddCygxPageHistoryRecord(item)
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 活动列表（4.3版本）
// @Description 获取活动列表接口（4.3版本）
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   Label   query   string  false       "搜索主题 多个用 , 隔开"
// @Param   ChartPermissionIds   query   string  false     "行业id 多个用 , 隔开"
// @Param   WhichDay   query   string  false       "哪一天 今天：1、明天:2，多个用 , 隔开"
// @Param   ActiveState   query   string  false       "活动进行状态 未开始：1、进行中2、已结束3"
// @Param   ActivityTypeId   query   string  false     "活动类型id 多个用 , 隔开"
// @Success 200 {object} models.GetCygxActivityListRep
// @router /listNew [get]
func (this *ActivityCoAntroller) ActivityListNew() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	uid := user.UserId
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	label := this.GetString("Label")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	whichDay := this.GetString("WhichDay")
	activeState := this.GetString("ActiveState")
	activityTypeId := this.GetString("ActivityTypeId")
	if label == "undefined" {
		label = ""
	}
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" {
		activeState = ""
	}
	if activityTypeId == "undefined" {
		activityTypeId = ""
	}
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)
	//userType, permissionStr, err := services.GetUserType(user.CompanyId)
	var condition string
	var pars []interface{}
	//活动可见限制
	conditionActivity, err := services.GetActivityonditionList(user, activityTypeId, chartPermissionIds, whichDay, activeState, label, 0)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取活动权限数据失败，Err:" + err.Error()
		return
	}
	condition += ` AND art.is_limit_people = 1 ` + conditionActivity
	total, err := models.GetActivityCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if activeState == "2" || activeState == "3" {
		condition += ` ORDER BY art.activity_time DESC  `
	} else if activeState == "2,3" {
		condition += ` ORDER BY art.active_state ASC, art.activity_time DESC  `
	} else {
		condition += ` ORDER BY art.activity_time ASC ,  art.active_state ASC   `
	}
	list, errList := models.GetActivityListAll(condition, pars, uid, startSize, pageSize)
	if errList != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + errList.Error()
		return
	}
	var isShow bool
	isShow = services.GetShowSustainable()
	detail, err := models.GetConfigByCode("city_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	detailChart, err := models.GetConfigByCode("chart_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
		return
	}

	addressList := strings.Split(detail.ConfigValue, "{|}")
	mapAddress := make(map[string]string)
	chartList := strings.Split(detailChart.ConfigValue, "{|}")
	mapChart := make(map[string]string)
	var cityName string
	var chartName string
	var imgUrl string
	var imgUrlChart string
	for _, v := range addressList {
		vslice := strings.Split(v, "_")
		cityName = vslice[0]
		imgUrl = vslice[len(vslice)-1]
		mapAddress[cityName] = imgUrl
	}
	for _, v := range chartList {
		vslice := strings.Split(v, "_")
		chartName = vslice[0]
		imgUrlChart = vslice[len(vslice)-1]
		mapChart[chartName] = imgUrlChart
	}

	for k, v := range list {
		if strings.Contains(v.ActivityName, "【") {
			list[k].IsBrackets = 1
		}
		if v.SignupNum > v.LimitPeopleNum {
			list[k].SignupNum = v.LimitPeopleNum
		}
		if isShow && strings.Contains(v.ChartPermissionName, "研选") {
			list[k].IsShowSustainable = true
		}
		if strings.Contains(v.ChartPermissionName, "研选") && v.ActivityTypeId == 1 {
			list[k].ActivityTypeName = "买方研选电话会"
			list[k].ImgUrlText = "https://hongze.oss-cn-shanghai.aliyuncs.com/static/images/202112/20211221/bIdfv8t86xrFRpDOeGGHXOmKEuKl.png"
		}
		if v.ActivityType == 0 {
			if mapAddress[v.City] != "" {
				list[k].ImgUrl = mapAddress[v.City]
			} else {
				list[k].ImgUrl = mapAddress["其它"]
			}
		} else {
			if mapChart[v.ChartPermissionName] != "" {
				list[k].ImgUrl = mapChart[v.ChartPermissionName]
			}
		}
		expertTxt, _ := services.GetReportContentTextSub(v.Expert)
		list[k].Expert = expertTxt
		if v.IsHideAppointment == 0 {
			list[k].IsShowAppointment = services.IsShowAppointment(v.ActivityTypeId, v.ChartPermissionName)
		}
		if v.ActivityTypeId == utils.C_CLASS_ACTIVITY_TYPE_ID {
			list[k].IsCClassMeeting = true
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.GetCygxActivityListRep)
	resp.Label = label
	if activityTypeId != "" {
		activityTypeIdint, err := strconv.Atoi(activityTypeId)
		if err == nil {
			detail, errDetail := models.GetActivityTypeDetailById(activityTypeIdint)
			if errDetail != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + errDetail.Error()
				return
			}
			resp.ImgUrl = detail.OnlineIco
			resp.Label = detail.ActivityTypeName
		}
	}
	//处理列表的标签是否展示逻辑
	for _, v := range list {
		resp.List = append(resp.List, services.ActivityButtonShow(v))
	}
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 活动类型下的主题列表Pc端
// @Description 获取活动类型下的主题列表接口Pc端
// @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"
// @Success 200 {object} models.ActivityTypeListHomeRespPc
// @router /labelTypeListPc_deltest [get]
func (this *ActivityCoAntroller) LabelTypeListPc() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	isPower, _ := this.GetInt("IsPower")
	//currentIndex, _ := this.GetInt("CurrentIndex")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	//activityTypeIds := this.GetString("ActivityTypeIds")
	whichDay := this.GetString("WhichDay")
	activeState := this.GetString("ActiveState")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" || activeState == "" {
		activeState = "1"
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	var startSize int
	pageSize = 8
	var sortTime string
	var pars []interface{}
	//活动可见限制
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	var permissionNameStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionNameStr += "'" + v + "',"
			}
		} else {
			permissionNameStr += "'" + v + "',"
		}
	}
	permissionNameStr = strings.Replace(permissionNameStr, "(主观)", "", -1)
	permissionNameStr = strings.Replace(permissionNameStr, "(客观)", "", -1)
	permissionNameStr = strings.TrimRight(permissionNameStr, ",")
	list, err := models.GetActivityTypeHomeListPc()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ActivityTypeListHomeRespPc)
	for k, v := range list {
		var sqlExport string
		var condition 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 += `) `
		condition = ` AND art.publish_status = 1  AND art.label != ''  AND art.activity_type_id = ` + strconv.Itoa(v.ActivityTypeId)
		if isPower == 1 {
			condition += permissionSqlStr
		}
		//行业名称
		if len(chartPermissionIds) > 0 {
			condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
		}
		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 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)`
		}
		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 + `) `
		}
		//判断客户规模是否属于可见范围的活动
		companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}
		if companyProduct != nil {
			if companyProduct.Scale != "" {
				conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
			}
		}
		condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
		sortTime = ` mintimesort ASC `
		labelList, err := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		//标签字段关联的产业与标签处理
		for k2, v2 := range labelList {
			labelList[k2].KeyWord = services.LabelStr(v2.KeyWord)

		}
		list[k].List = labelList
	}
	//记录用户搜索的筛选条件
	item := new(models.CygxActivitySearchHistory)
	item.UserId = user.UserId
	item.Mobile = user.Mobile
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.CreateTime = time.Now()
	item.ChartPermissionIds = chartPermissionIds
	item.IsPower = isPower
	item.WhichDay = whichDay
	go models.AddCygxActivitySearchHistory(item)

	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 校验活动带问是否有权限
// @Description 校验活动带问是否有权限接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /checkAsk [post]
func (this *ActivityCoAntroller) CheckAsk() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	signupStatus := "Success"
	var req models.ActivityIdRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//获取销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}
	resp := new(models.SignupStatus)
	hasPermission := 0
	var companyDetailStatus string
	if user.CompanyId <= 1 {
		companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.ActivityId = activityId
			resp.HasPermission = hasPermission
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
		companyDetailStatus = companyDetail.Status
	}
	var userType int
	var permissionStr string
	userType, permissionStr, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}
	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						hasPermission = 3
					}
				}
				resp.ActivityId = activityId
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}
		havePower, err := services.GetHavePower(activityInfo, permissionStr, companyDetailStatus, userType)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if havePower {
			hasPermission = 1
			signupStatus = "Success"
			resp.HaqveJurisdiction = true
		} else {
			if companyItem.ProductId == 2 {
				hasPermission = 2
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.MsgType = "Type"
				resp.OperationMode = "Call"
				if permissionStr == "专家" {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ActivityTypeName + "】类型活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Type"
				} else {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ChartPermissionName + "】行业活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Industry"
				}
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	resp.HasPermission = hasPermission
	resp.SignupStatus = signupStatus
	resp.ActivityId = activityId
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 活动类型下的主题列表（5.3版本）
// @Description 获取活动类型下的主题列表接口（5.3版本）
// @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"
// @Success 200 {object} models.ActivityTypeListHomeResp
// @router /labelTypeListV5 [get]
func (this *ActivityCoAntroller) LabelTypeListV5() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	isPower, _ := this.GetInt("IsPower")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	whichDay := this.GetString("WhichDay")
	activeState := this.GetString("ActiveState")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" || activeState == "" {
		activeState = "1"
	}
	//adminIds, err := models.GetSelleridWhichGroup(user.CompanyId, 2)
	//if err != nil {
	//	br.Msg = "获取失败"
	//	br.ErrMsg = "获取本组下的销售失败，Err:" + err.Error()
	//	return
	//}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	var startSize int
	pageSize = 40
	var sortTime string
	var pars []interface{}
	//活动可见限制
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	var permissionNameStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionNameStr += "'" + v + "',"
			}
		} else {
			permissionNameStr += "'" + v + "',"
		}
	}
	permissionNameStr = strings.Replace(permissionNameStr, "(主观)", "", -1)
	permissionNameStr = strings.Replace(permissionNameStr, "(客观)", "", -1)
	permissionNameStr = strings.TrimRight(permissionNameStr, ",")
	list, err := models.GetActivityTypeHomeList()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	//isMaker := user.IsMaker

	var sqlExport string
	resp := new(models.ActivityTypeListHomeResp)
	for k, v := range list {
		// 如果是C类电话会就不展示内容，且合并到分析师电话会
		if v.ActivityTypeId == utils.C_CLASS_ACTIVITY_TYPE_ID {
			continue
		}
		var condition string
		conditionActivity, err := services.GetActivityonditionList(user, strconv.Itoa(v.ActivityTypeId), chartPermissionIds, whichDay, activeState, "", isPower)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取活动权限数据失败，Err:" + err.Error()
			return
		}
		condition += `AND art.is_limit_people = 1 ` + conditionActivity
		sortTime = ` mintimesort ASC `
		labelList, err := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		//标签字段关联的产业与标签处理
		for k2, v2 := range labelList {
			labelList[k2].KeyWord = services.LabelStrV5(v2.KeyWord, v2.IsShowSubjectName)
			labelList[k2].ImgUrlBg = v.ImgUrlBgs
		}
		list[k].List = labelList
		list[k].Resource = 1
	}

	//userType = 1
	//查询专项产业调研展示权限
	if whichDay == "" {
		var condition string
		condition = ` AND art.publish_status = 1  AND art.label != '' `
		if isPower == 1 {
			condition += permissionSqlStr
		}
		//行业名称
		if len(chartPermissionIds) > 0 {
			condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
		}
		var conditionOr string

		if (userType == 2 || userType == 3 || userType == 4) && strings.Contains(permissionStr, "专家") {
			conditionOr += ` OR (1=1 AND   art.customer_type_ids LIKE '%4%'	 ` + condition + `) `
		}
		if (userType == 5) && strings.Contains(permissionStr, "专家") {
			conditionOr += ` OR (1=1 AND art.customer_type_ids LIKE '%5%'	 ` + condition + `) `
		}
		if userType == 1 {
			conditionOr += ` OR (1=1 ` + condition + permissionSqlStr + `) `
		}

		if companyProduct != nil {
			if companyProduct.Scale != "" {
				conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
			}
		}

		condition += sqlExport + conditionOr
		specialList, err := models.GetActivityLabelSpecialListAll(condition, pars, startSize, 8)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		for k2, v2 := range specialList {
			specialList[k2].KeyWord = services.LabelStrV5(v2.KeyWord, v2.IsShowSubjectName)
			specialList[k2].ImgUrlBg = "https://hzstatic.hzinsights.com/static/temp/20220426202204/20220426/XDLLsjC9XAAy8LIzQr7GsjrBbtX6.png"
		}

		itemList := new(models.ActivityTypeHome)
		itemList.ActivityTypeName = "专项产业调研"
		itemList.Resource = 2
		itemList.List = specialList
		itemList.ActivityTypeId = 7
		itemList.ImgUrl = "https://hzstatic.hzinsights.com/static/temp/20220427202204/20220427/b2Bj3fGakP16iJRFKisQohCWnCNl.png"
		itemList.ImgUrlBg = "https://hzstatic.hzinsights.com/static/temp/20220427202204/20220427/OkunjfKEgo5KRLifzwwLX8cDZnnN.png"
		list = append(list, itemList)
	}
	//获取对应活动的数量并排序
	intArr := make([]int, 0)
	var items []*models.ActivityTypeHome
	for _, v := range list {
		item := new(models.ActivityTypeHome)
		if len(v.List) > 0 {
			item.List = v.List
			item.ActivityTypeName = v.ActivityTypeName
			item.ActivityTypeId = v.ActivityTypeId
			item.ImgUrlBg = v.ImgUrlBg
			item.ImgUrl = v.ImgUrl
			item.Resource = v.Resource
			items = append(items, item)
			intArr = append(intArr, len(v.List))
		}
	}
	sort.Sort(sort.Reverse(sort.IntSlice(intArr)))
	var itemsNew []*models.ActivityTypeHome
	activityMap := make(map[int]int)
	for _, v := range intArr {
		for _, v2 := range items {
			item := new(models.ActivityTypeHome)
			if len(v2.List) > 0 && v == len(v2.List) && activityMap[v2.ActivityTypeId] == 0 {
				item.List = v2.List
				item.ActivityTypeName = v2.ActivityTypeName
				item.ActivityTypeId = v2.ActivityTypeId
				item.ImgUrlBg = v2.ImgUrlBg
				item.ImgUrl = v2.ImgUrl
				item.Resource = v2.Resource
				itemsNew = append(itemsNew, item)
				activityMap[v2.ActivityTypeId] = len(v2.List)
			}
		}
	}
	//按照像素进行排序
	rowHeight := 83     //每一行的行高
	basicsHeight := 178 // 基础高度
	position := 1       // 初始化位置 ，1，左边， 2 右边
	var leftPx, rightPx int
	for k, v := range itemsNew {
		if leftPx <= rightPx {
			position = 1
		} else {
			position = 2
		}
		itemsNew[k].Position = position
		if position == 1 {
			leftPx += basicsHeight + rowHeight*len(v.List)
		} else {
			rightPx += basicsHeight + rowHeight*len(v.List)
		}
	}
	//记录用户搜索的筛选条件
	item := new(models.CygxActivitySearchHistory)
	item.UserId = user.UserId
	item.Mobile = user.Mobile
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.CreateTime = time.Now()
	item.ChartPermissionIds = chartPermissionIds
	item.IsPower = isPower
	item.WhichDay = whichDay
	go models.AddCygxActivitySearchHistory(item)
	resp.List = itemsNew
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 专项产业调研列表
// @Description 获取专项产业调研列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Success 200 {object} models.GetCygxActivitySpecialDetailListResp
// @router /special/list [get]
func (this *ActivityCoAntroller) SpecialList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	uid := user.UserId
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	userType, permissionStr, err := services.GetUserType(user.CompanyId)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)
	var condition string
	var pars []interface{}
	//活动可见限制
	var sqlExport string
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionSqlStr += "'" + v + "',"
			}
		} else {
			permissionSqlStr += "'" + v + "',"
		}
	}

	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	permissionSqlStr = strings.TrimRight(permissionSqlStr, ",")
	permissionSqlStr = strings.Replace(permissionSqlStr, "(主观)", "", -1)
	permissionSqlStr = strings.Replace(permissionSqlStr, "(客观)", "", -1)
	permissionSqlStr = ` AND art.chart_permission_name  IN (` + permissionSqlStr + `)`
	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 += `) `
	condition += ` AND art.publish_status = 1 `
	condition = ` AND art.publish_status = 1  AND art.label != '' `
	var conditionOr string

	if (userType == 2 || userType == 3 || userType == 4) && strings.Contains(permissionStr, "专家") {
		conditionOr += ` OR (1=1 AND   art.customer_type_ids LIKE '%4%'	 ` + condition + `) `
	}
	if (userType == 5) && strings.Contains(permissionStr, "专家") {
		conditionOr += ` OR (1=1 AND art.customer_type_ids LIKE '%5%'	 ` + condition + `) `
	}
	if userType == 1 {
		conditionOr += ` OR ( 1=1` + condition + permissionSqlStr + `) `
	}
	if companyProduct != nil {
		if companyProduct.Scale != "" {
			conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
		}
	}
	if companyProduct != nil {
		if companyProduct.Scale != "" {
			conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
		}
	}
	condition += sqlExport + conditionOr
	total, err := models.GetActivitySpecialCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, errList := models.GetCygxActivitySpecialDetailList(condition, pars, uid, startSize, pageSize)
	if errList != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + errList.Error()
		return
	}
	detail, err := models.GetConfigByCode("city_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	detailChart, err := models.GetConfigByCode("chart_img_url")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
		return
	}

	addressList := strings.Split(detail.ConfigValue, "{|}")
	mapAddress := make(map[string]string)
	chartList := strings.Split(detailChart.ConfigValue, "{|}")
	mapChart := make(map[string]string)
	var cityName string
	var chartName string
	var imgUrl string
	var imgUrlChart string
	for _, v := range addressList {
		vslice := strings.Split(v, "_")
		cityName = vslice[0]
		imgUrl = vslice[len(vslice)-1]
		mapAddress[cityName] = imgUrl
	}
	for _, v := range chartList {
		vslice := strings.Split(v, "_")
		chartName = vslice[0]
		imgUrlChart = vslice[len(vslice)-1]
		mapChart[chartName] = imgUrlChart
	}
	for k, v := range list {
		//if v.ChartPermissionName == "研选" {
		//	list[k].ActivityTypeName = "研选电话会"
		//	list[k].ImgUrlText = "https://hongze.oss-cn-shanghai.aliyuncs.com/static/images/202112/20211221/bIdfv8t86xrFRpDOeGGHXOmKEuKl.png"
		//}
		list[k].ImgUrlText = "https://hongze.oss-cn-shanghai.aliyuncs.com/static/images/202112/20211221/bIdfv8t86xrFRpDOeGGHXOmKEuKl.png"
		if mapChart[v.ChartPermissionName] != "" {
			list[k].ImgUrl = mapChart[v.ChartPermissionName]
		}
		list[k].ActivityTypeName = "专项调研"

	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.GetCygxActivitySpecialDetailListResp)
	count, err := models.GetCygxUserFollowSpecial(user.UserId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if count == 1 && user.UserId > 0 {
		resp.IsFollow = true
	}
	if user.Mobile != "" {
		resp.IsBindingMobile = true
	}
	resp.List = list
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp

}

// @Title  专项产业调研详情
// @Description 获取专项产业调研详情接口
// @Param   ActivityId   query   int  true       "活动ID"
// @Success Ret=200 {object} models.CygxActivitySpecialResp
// @router /special/detail [get]
func (this *ActivityCoAntroller) SpecialDetail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	activityId, _ := this.GetInt("ActivityId")
	if activityId < 1 {
		br.Msg = "请输入活动ID"
		return
	}
	resp := new(models.CygxActivitySpecialResp)
	hasPermission := 0

	activityInfo, err := models.GetCygxActivitySpecialDetailById(uid, activityId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	if activityInfo == nil {
		br.Msg = "活动不存在"
		br.ErrMsg = "活动ID错误，Err:" + "activityId：" + strconv.Itoa(activityId)
		return
	}
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//获取FICC销售信息 如果是FICC的客户类型，则默认他申请过
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}
	if user.CompanyId <= 1 {
		//companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.HasPermission = hasPermission
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
	}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	itemAct := new(models.ActivityDetail)
	itemAct.CustomerTypeIds = activityInfo.CustomerTypeIds
	noPower, err := services.GetShareNoPowe(itemAct, permissionStr, userType)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}

	//获取用户的产业规模，判断是否允许可见
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	if companyProduct != nil {
		if companyProduct.Scale != "" {
			if strings.Count(activityInfo.Scale, companyProduct.Scale) > 0 {
				noPower = false
			}
		}
	}
	if noPower {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，获取信息失败"
		return
	}

	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}
	//判断是否已经申请过
	if user.CompanyId > 1 {
		permissionStr, err := models.GetCompanyPermissionByUser(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户权限信息失败,Err:" + err.Error()
			return
		}
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
						sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
						if err != nil && err.Error() != utils.ErrNoRow() {
							br.Msg = "获取信息失败"
							br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
							return
						}
						if sellerItemQy != nil {
							hasPermission = 2
							resp.SellerMobile = sellerItemQy.Mobile
							resp.SellerName = sellerItemQy.RealName
						} else {
							hasPermission = 3
						}
					}
				}
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}
		var havePower bool
		if strings.Contains(permissionStr, activityInfo.ActivityTypeName) {
			havePower = true
		}
		if havePower {
			hasPermission = 1
			resp.HaqveJurisdiction = true
		} else {
			if permissionStr == "专家" {
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				resp.MsgType = "Type"
			} else {
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				resp.MsgType = "Industry"
			}
			if companyItem.ProductId == 2 {
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.OperationMode = "Call"
				hasPermission = 2
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	if hasPermission == 1 {
		count, err := models.GetCygxUserFollowSpecial(user.UserId)
		if err != nil {
			br.Msg = "获取数据失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if count == 1 {
			resp.IsFollow = true
		}
		activityInfo.ActivityTypeName = "专项调研"
		resp.Detail = activityInfo
	}
	resp.HasPermission = hasPermission
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 感兴趣、不感兴趣
// @Description 感兴趣、不感兴趣接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.SignupSpecialStatus
// @router /special/signup/add [post]
func (this *ActivityCoAntroller) SpecialSignupAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ActivityIdRep
	resp := new(models.SignupSpecialStatus)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	hasPermission := 0
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//获取FICC销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}

	activityInfo, errInfo := models.GetCygxActivitySpecialDetail(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//HasPermission "1:有该行业权限,正常展示，2：无该行业权限，3：潜在客户，未提交过申请，4：潜在客户,已提交过申请"`
	//var companyDetailStatus string
	if user.CompanyId > 1 {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.HasPermission = hasPermission
			resp.ActivityId = activityId
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
	}
	var userType int
	var permissionStr string
	userType, permissionStr, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}

	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						hasPermission = 3
					}
				}
				resp.ActivityId = activityId
				resp.HasPermission = hasPermission
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}
		//判断是否有权限
		var havePower bool
		if strings.Contains(permissionStr, activityInfo.ActivityTypeName) {
			havePower = true
		}
		if havePower {
			hasPermission = 1
		} else {
			if companyItem.ProductId == 2 {
				hasPermission = 2
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				if permissionStr == "专家" {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ActivityTypeName + "】类型活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
				} else {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ChartPermissionName + "】行业活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
				}
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	resp.HasPermission = hasPermission
	resp.ActivityId = activityId
	if hasPermission == 1 {
		total, err := models.GetUserCygxActivitySpecialSignup(user.UserId, activityId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取日程数量信息失败,Err:" + err.Error()
			return
		}
		//判断是删除还是添加
		if total == 0 {
			//获取销售信息
			sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
			if err != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
				return
			}
			item := new(models.CygxActivitySpecialSignup)
			item.UserId = uid
			item.RealName = user.RealName
			item.ActivityId = activityId
			item.CreateTime = time.Now()
			item.Mobile = user.Mobile
			item.Email = user.Email
			item.CompanyId = user.CompanyId
			item.CompanyName = user.CompanyName
			if sellerItem != nil {
				item.SellerName = sellerItem.RealName
			}
			err = models.AddCygxActivitySpecialSignup(item)
			if err != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "操作失败,Err:" + err.Error()
				return
			}
			resp.Status = 1

			////给所属销售发送消息
			if sellerItem.Mobile != "" {
				openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
				if openIpItem != nil && openIpItem.OpenId != "" {
					if sellerItem != nil {
						go services.SendSpecialTemplateMsg(user.RealName+"【"+user.CompanyName+"】", time.Now().Format(utils.FormatDateTime), user.Mobile, activityInfo.ResearchTheme, "sale", openIpItem)
					}
				}
			}
			// 给芳姐发消息
			cnf, _ := models.GetConfigByCode("tpl_msg")
			if cnf != nil {
				openIpItem, _ := models.GetUserRecordByMobile(4, cnf.ConfigValue)
				if openIpItem != nil && openIpItem.OpenId != "" {
					actList, _ := models.GetActivityListSpecialAll(activityId)
					if len(actList) == 5 {
						var companyName string
						for _, v := range actList {
							companyName += "【" + v.CompanyName + "】"
						}
						go services.SendSpecialTemplateMsg(companyName, "", "", activityInfo.ResearchTheme, "", openIpItem)
					}
				}
			}
			//用户专项调研操作行为，模板消息推送
			go services.SpecialActivityUserRemind(user, activityInfo, 1)
		} else {
			err = models.DeleteCygxActivitySpecialSignup(user.UserId, activityId)
			if err != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "操作失败,Err:" + err.Error()
				return
			}
			resp.Status = 2
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	br.Data = resp
}

// @Title 新调研通知取消跟添加
// @Description 新调研通知取消跟添加接口
// @Param	request	body models.ArticleCollectResp true "type json string"
// @Success 200
// @router /special/follow [post]
func (this *ActivityCoAntroller) SpecialMsg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	resp := new(models.ArticleCollectResp)
	count, err := models.GetCygxUserFollowSpecial(user.UserId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if count == 0 {
		item := new(models.CygxUserFollowSpecial)
		item.UserId = user.UserId
		item.RealName = user.RealName
		item.CreateTime = time.Now()
		item.Mobile = user.Mobile
		item.Email = user.Email
		item.CompanyId = user.CompanyId
		item.CompanyName = user.CompanyName
		item.CreateTime = time.Now()
		err := models.AddUserFollowSpecial(item)
		if err != nil {
			br.Msg = "操作失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		resp.Status = 1
	} else {
		err := models.DeleteCygxUserFollowSpecial(user.UserId)
		if err != nil {
			br.Msg = "操作失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		resp.Status = 2
	}
	br.Ret = 200
	br.Data = resp
	br.Success = true
	br.Msg = "操作成功！"
}

// @Title 活动类型下的主题列表（6.0Pc版本）
// @Description  获取活动类型下的主题列表接口（6.0Pc版本）
// @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"
// @Success 200 {object} models.ActivityTypeListHomeRespPc
// @router /labelTypeListV6Pc [get]
func (this *ActivityCoAntroller) LabelTypeListV6Pc() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	isPower, _ := this.GetInt("IsPower")
	//currentIndex, _ := this.GetInt("CurrentIndex")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	//activityTypeIds := this.GetString("ActivityTypeIds")
	whichDay := this.GetString("WhichDay")
	activeState := this.GetString("ActiveState")
	//入参为 undefined 时的处理
	if chartPermissionIds == "undefined" {
		chartPermissionIds = ""
	}
	if whichDay == "undefined" {
		whichDay = ""
	}
	if activeState == "undefined" || activeState == "" || activeState == "1" {
		activeState = "1,2"
	}
	//adminIds, err := models.GetSelleridWhichGroup(user.CompanyId, 2)
	//if err != nil {
	//	br.Msg = "获取失败"
	//	br.ErrMsg = "获取本组下的销售失败，Err:" + err.Error()
	//	return
	//}
	userType, permissionStr, err := services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	//isMaker := user.IsMaker

	var startSize int
	pageSize = 8
	var sortTime string
	var pars []interface{}
	//活动可见限制
	slicePer := strings.Split(permissionStr, ",")
	var permissionSqlStr string
	var permissionNameStr string
	for _, v := range slicePer {
		if userType == 1 {
			//if v != "研选" {
			if !strings.Contains(v, "研选") {
				permissionNameStr += "'" + v + "',"
			}
		} else {
			permissionNameStr += "'" + v + "',"
		}
	}
	permissionNameStr = strings.Replace(permissionNameStr, "(主观)", "", -1)
	permissionNameStr = strings.Replace(permissionNameStr, "(客观)", "", -1)
	permissionNameStr = strings.TrimRight(permissionNameStr, ",")
	list, err := models.GetActivityTypeHomeListPc()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	//判断客户规模是否属于可见范围的活动
	companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
		return
	}
	var sqlExport string
	//处理专家权限的查询
	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 += `) `
	resp := new(models.ActivityTypeListHomeRespPc)
	for k, v := range list {
		// 如果是C类电话会就不展示内容，且合并到分析师电话会
		if v.ActivityTypeId == utils.C_CLASS_ACTIVITY_TYPE_ID {
			continue
		}
		var condition string

		conditionActivity, err := services.GetActivityonditionList(user, strconv.Itoa(v.ActivityTypeId), chartPermissionIds, whichDay, activeState, "", isPower)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取活动权限数据失败，Err:" + err.Error()
			return
		}
		//condition += `AND art.is_limit_people = 1 ` + permissionSqlStr + sqlExport + conditionOr
		condition += `AND art.is_limit_people = 1 ` + conditionActivity
		sortTime = ` mintimesort ASC `
		labelList, err := models.GetActivityLabelListAll(condition, sortTime, pars, startSize, pageSize)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		//标签字段关联的产业与标签处理
		for k2, v2 := range labelList {
			labelList[k2].KeyWord = services.LabelStrV5(v2.KeyWord, v2.IsShowSubjectName)
			labelList[k2].Resource = 1
		}
		list[k].List = labelList
		list[k].Resource = 1
	}

	if whichDay == "" {
		//查询专项产业调研展示权限
		var condition string
		condition = ` AND art.publish_status = 1  AND art.label != '' `
		if isPower == 1 {
			condition += permissionSqlStr
		}
		//行业名称
		if len(chartPermissionIds) > 0 {
			condition += ` AND art.chart_permission_id  IN (` + chartPermissionIds + `)`
		}
		var conditionOr string

		if (userType == 2 || userType == 3 || userType == 4) && strings.Contains(permissionStr, "专家") {
			conditionOr += ` OR (1=1 AND   art.customer_type_ids LIKE '%4%'	 ` + condition + `) `
		}
		if (userType == 5) && strings.Contains(permissionStr, "专家") {
			conditionOr += ` OR (1=1 AND art.customer_type_ids LIKE '%5%'	 ` + condition + `) `
		}
		if userType == 1 {
			conditionOr += ` OR (1=1 ` + condition + permissionSqlStr + `) `
		}

		if companyProduct != nil {
			if companyProduct.Scale != "" {
				conditionOr += ` OR (  art.scale LIKE '%` + companyProduct.Scale + `%'	 ` + condition + `) `
			}
		}

		condition += sqlExport + conditionOr
		specialList, err := models.GetActivityLabelSpecialListAll(condition, pars, startSize, 8)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		for k2, v2 := range specialList {
			specialList[k2].KeyWord = services.LabelStrV5(v2.KeyWord, v2.IsShowSubjectName)
			specialList[k2].Resource = 2
		}

		itemList := new(models.ActivityTypeHomePc)
		itemList.ActivityTypeName = "专项产业调研"
		itemList.Resource = 2
		itemList.List = specialList
		itemList.ActivityTypeId = 7
		itemList.OnlineIco = "https://hzstatic.hzinsights.com/static/temp/20220707202207/20220707/0H4md6VgZMuIttggMUnJxgrlayxC.png"
		itemList.ImgUrlBgPc = "https://hzstatic.hzinsights.com/static/temp/20220707202207/20220707/rFwAM1c4fIMJM0EGoUkUYl25XH9L.png"
		list = append(list, itemList)
	}
	//记录用户搜索的筛选条件
	item := new(models.CygxActivitySearchHistory)
	item.UserId = user.UserId
	item.Mobile = user.Mobile
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.CreateTime = time.Now()
	item.ChartPermissionIds = chartPermissionIds
	item.IsPower = isPower
	item.WhichDay = whichDay
	go models.AddCygxActivitySearchHistory(item)

	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 预约纪要
// @Description 预约纪要接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.AppointmentResp
// @router /appointment/add [post]
func (this *ActivityCoAntroller) ActivityAppointmentAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	signupStatus := "Success"
	var req models.ActivityIdRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	//判断是否已经预约过
	totalAppointment, err := models.GetUserCygxActivityAppointmentCount(uid, activityId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if totalAppointment > 0 {
		br.Msg = "您已预约！"
		return
	}

	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}

	//获取销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}

	//SignupStatus string `description:"报名状态：人数已满：FullStarffed、单机构超过两人：TwoPeople、爽约次数过多：BreakPromise、超时：Overtime 、成功：Success"`
	item := new(models.CygxActivityAppointment)
	resp := new(models.SignupStatus)
	hasPermission := 0
	var companyDetailStatus string
	if user.CompanyId <= 1 {
		companyDetailStatus = ""
	} else {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 4
			} else {
				if sellerItem != nil {
					hasPermission = 5
				} else {
					//获取权益销售信息 如果是FICC的客户类型，则默认他申请过
					sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
						return
					}
					if sellerItemQy != nil {
						hasPermission = 2
						resp.SellerMobile = sellerItemQy.Mobile
						resp.SellerName = sellerItemQy.RealName
					} else {
						hasPermission = 3
					}
				}
			}
			resp.ActivityId = activityId
			resp.HasPermission = hasPermission
			resp.OperationMode = "Apply"
			resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
		companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
		if companyDetail == nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId) + "CompanyId：" + strconv.Itoa(user.CompanyId)
			return
		}
		companyDetailStatus = companyDetail.Status
	}
	var userType int
	var permissionStr string
	userType, permissionStr, err = services.GetUserType(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if userType == 1 && strings.Contains(activityInfo.ChartPermissionName, "研选") {
		br.Msg = "您暂无查看该活动权限"
		br.ErrMsg = "被分享客户不可见，永续客户无法查看研选行业"
		return
	}
	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		//冻结客户
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				//如果是FICC的客户类型，则默认他申请过
				if applyCount > 0 {
					hasPermission = 4
				} else {
					if sellerItem != nil {
						hasPermission = 5
					} else {
						hasPermission = 3
					}
				}
				resp.ActivityId = activityId
				resp.HasPermission = hasPermission
				resp.OperationMode = "Apply"
				resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			} else {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户公司信息失败,Err:" + err.Error()
				return
			}
		}

		havePower, err := services.GetHavePower(activityInfo, permissionStr, companyDetailStatus, userType)
		if err != nil {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if havePower {
			hasPermission = 1
			signupStatus = "Success"
			totalMeeting, errMeeting := models.GetUserCygxActivityAppointmentCount(uid, activityId)
			if errMeeting != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败，Err:" + errMeeting.Error()
				return
			}
			if totalMeeting > 0 {
				br.Msg = "您已预约，请勿重复预约"
				return
			}
			var sellerName string
			sellerName, err = models.GetCompanySellerName(user.CompanyId)
			if err != nil {
				br.Msg = "报名失败！"
				br.ErrMsg = "获取对应销售失败，Err:" + err.Error()
				return
			}
			item.UserId = uid
			item.ActivityId = activityId
			item.CreateTime = time.Now()
			item.Mobile = user.Mobile
			item.Email = user.Email
			item.CompanyId = user.CompanyId
			item.CompanyName = user.CompanyName
			item.SellerName = sellerName
			item.RealName = user.RealName
			err = models.AddCygxActivityAppointment(item)
			if err != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "操作失败,Err:" + err.Error()
				return
			}
			resp.HaqveJurisdiction = true
			//1：预约外呼 、2：设置会议提醒 、 3：预约纪要 、4：活动报名
			go services.ActivityUserRemind(user, activityInfo, 3)

		} else {
			if companyItem.ProductId == 2 {
				hasPermission = 2
				resp.SellerMobile = companyItem.Mobile
				resp.SellerName = companyItem.SellerName
				resp.MsgType = "Type"
				resp.OperationMode = "Call"
				if permissionStr == "专家" {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ActivityTypeName + "】类型活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Type"
				} else {
					resp.PopupMsg = "您暂无权限参加【" + activityInfo.ChartPermissionName + "】行业活动，若想参加请联系对口销售--" + companyItem.SellerName + "：" + companyItem.Mobile
					resp.MsgType = "Industry"
				}
			} else {
				hasPermission = 5
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 4
		} else {
			if sellerItem != nil {
				hasPermission = 5
			} else {
				hasPermission = 3
			}
		}
		resp.OperationMode = "Apply"
		resp.PopupMsg = "您暂无权限参加此活动，若想参加可以申请开通对应的试用权限"
	}
	resp.HasPermission = hasPermission
	resp.SignupStatus = signupStatus
	resp.ActivityId = activityId
	var total int
	total, err = models.GetUserCygxActivityAppointmentCountByUid(user.UserId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取日程数量信息失败,Err:" + err.Error()
		return
	}
	if total <= 1 {
		resp.GoFollow = true
	}
	br.Ret = 200
	br.Success = true
	if hasPermission == 1 {
		br.Msg = "请关注【查研观向小助手】公众号，若有调研纪要发布/更新，将及时为您推送微信消息"
	}
	br.Data = resp
}

// @Title 取消预约纪要
// @Description 取消预约纪要接口
// @Param	request	body models.ActivityIdRep true "type json string"
// @Success Ret=200 {object} models.SignupStatus
// @router /appointment/cancel [post]
func (this *ActivityCoAntroller) ActivityAppointmentCancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ActivityIdRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	activityId := req.ActivityId
	signupStatus := "Success"
	item := new(models.CygxActivityAppointment)
	activityInfo, errInfo := models.GetAddActivityInfoById(activityId)
	if activityInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(activityId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}
	total, err := models.GetUserCygxActivityAppointmentCount(uid, activityId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if total == 0 {
		br.Msg = "您暂未预约该纪要"
		return
	}

	item.UserId = uid
	item.ActivityId = activityId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	_, errSignup := models.CancelcygxActivityAppointment(item)
	if errSignup != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errSignup.Error()
		return
	}
	resp := new(models.SignupStatus)
	resp.SignupStatus = signupStatus
	resp.ActivityId = activityId
	br.Ret = 200
	br.Success = true
	br.Msg = "已取消"
	br.Data = resp
}