hongze_mobile_admin/services/rs/calendar.go

package rs

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/http"
	"hongze/hongze_mobile_admin/models/roadshow"
	"hongze/hongze_mobile_admin/models/tables/admin"
	"hongze/hongze_mobile_admin/utils"
	"io/ioutil"
	netHttp "net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

// getAccessToken token内部请求接口
func getAccessToken() (tokenData roadshow.TokenData, err error) {
	getUrl := fmt.Sprintf(utils.CRM_OPEN_API_URL+"/v1/auth/getAccessToken?app_key=%s&app_secret=%s", utils.CRM_OPEN_API_APP_KEY, utils.CRM_OPEN_API_APP_SECRET)
	body, err := http.Get(getUrl)
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}

	var tokenResp roadshow.GetTokenResp
	err = json.Unmarshal(body, &tokenResp)
	if err != nil {
		err = errors.New("Unmarshal Err:" + err.Error())
		return
	}
	if tokenResp.Code != 1 {
		err = errors.New("getAccessToken err:" + tokenResp.Msg)
		return
	}
	tokenData = tokenResp.TokenData
	return
	//return tokenResp.TokenData.AccessToken, err
}

// GetAccessToken 获取accessToken
func GetAccessToken() (token string, err error) {
	defer func() {
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"获取上海的token失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		}
	}()
	token, err = utils.Rc.RedisString("SH_ACCESS_TOKEN")
	//如果从redis中accessToken 获取失败或者token为空了，那么重新获取accessToken
	if err != nil || token == `` {
		tokenInfo, tmpErr := getAccessToken()
		if tmpErr != nil {
			err = tmpErr
			return
		}
		token = tokenInfo.AccessToken
		if !utils.Rc.SetNX("SH_ACCESS_TOKEN", token, time.Duration(tokenInfo.ExpireIn-600)*time.Second) {
			err = errors.New("set Redis err")
		}
	}
	return
}

func getCalendarFrom(userPhone, startDate, endDate string) (list []roadshow.UserCalendar, err error) {
	token, err := GetAccessToken()
	if err != nil {
		return
	}
	exUrl := utils.CRM_OPEN_API_URL + "/v1/calendar/userCalendarList?user_phone=%s&start_time=%s&end_time=%s&access_token=%s"
	getUrl := fmt.Sprintf(exUrl, userPhone, startDate, endDate, token)

	body, err := http.Get(getUrl)
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}

	var userCalendarList roadshow.UserCalendarList
	err = json.Unmarshal(body, &userCalendarList)
	if err != nil {
		utils.FileLog.Info("getCalendarFrom Err:", "url:", getUrl, ";response:", string(body))
		err = errors.New("Unmarshal Err:" + err.Error())
		return
	}

	if userCalendarList.Code != 1 {
		utils.FileLog.Info("getCalendarFrom:", "url:", getUrl, ";response:", string(body))
		err = errors.New(userCalendarList.Msg)
		return
	}
	list = userCalendarList.Data
	//fmt.Println("userCalendarList", userCalendarList)
	return
}

// CalendarToSH 创建活动时同步上海的前置函数
func CalendarToSH(rsCalendar roadshow.RsCalendar, researcher roadshow.RsCalendarResearcher) {
	//获取创建者及研究员的信息，长度应为2
	var condition string
	var err error
	var pars []interface{}
	if rsCalendar.SysUserId == researcher.ResearcherId {
		condition = ` AND admin_id =? `
		pars = append(pars, rsCalendar.SysUserId)
	} else {
		condition = ` AND admin_id IN (?,?) `
		pars = append(pars, rsCalendar.SysUserId, researcher.ResearcherId)
	}

	lists, err := roadshow.GetResearcherFromAdmin(condition, pars)
	if err != nil {
		err = errors.New("GetResearcherFromAdmin err:" + err.Error())
		fmt.Println(err)
		return
	}
	var userPhone, toUserPhone string

	if len(lists) > 0 {
		//当研究员也是创建者时，lists长度为1 做兼容
		if len(lists) == 1 && rsCalendar.SysUserId == researcher.ResearcherId {
			userPhone = lists[0].Mobile
			toUserPhone = lists[0].Mobile
		} else if lists[0].AdminId == rsCalendar.SysUserId {
			userPhone = lists[0].Mobile
			toUserPhone = lists[1].Mobile
		} else {
			userPhone = lists[1].Mobile
			toUserPhone = lists[0].Mobile
		}
		sTime, _ := time.ParseInLocation(utils.FormatDateTime, researcher.StartDate+" "+researcher.StartTime, time.Now().Location())
		startTime := sTime.Format("2006-01-02 15:04")
		eTime, _ := time.ParseInLocation(utils.FormatDateTime, researcher.EndDate+" "+researcher.EndTime, time.Now().Location())
		endTime := eTime.Format("2006-01-02 15:04")
		err = CreatSHCalendar(userPhone, toUserPhone, rsCalendar.Title, startTime, endTime, 1, researcher.RsCalendarResearcherId)
		if err != nil {
			return
		}
	} else {
		err = errors.New("Parameter Err,未查询到创建者或研究员信息" + err.Error())
		fmt.Println("Parameter Err: " + err.Error())
		return
	}
	if err != nil {
		utils.SendEmail("研究员日历同步失败:", "新建上海研究员日历失败 "+err.Error(), utils.EmailSendToUsers)
	} else {
		whereParams := make(map[string]interface{})
		updateParams := make(map[string]interface{})

		whereParams["rs_calendar_researcher_id"] = researcher.RsCalendarResearcherId

		updateParams["is_synced"] = 1
		err = roadshow.UpdateCalendarResearcher(whereParams, updateParams)
		if err != nil {
			utils.FileLog.Info("UpdateCalendarResearcher err: " + err.Error())
			fmt.Println("UpdateCalendarResearcher err: " + err.Error())
			return
		}
		calWhereParams := make(map[string]interface{})
		calWhereParams["rs_calendar_id"] = rsCalendar.RsCalendarId
		err = roadshow.UpdateRsCalendar(calWhereParams, updateParams)
		if err != nil {
			utils.FileLog.Info("UpdateRsCalendar err: " + err.Error())
			fmt.Println("UpdateRsCalendar err: " + err.Error())
			return
		}
	}
}

// MatterToSH 创建事项时同步上海的前置函数
func MatterToSH(matter roadshow.RsMatters) {
	var condition string
	var pars []interface{}
	condition = ` AND admin_id =? `
	pars = append(pars, matter.SysUserId)
	lists, err := roadshow.GetResearcherFromAdmin(condition, pars)
	if err != nil || len(lists) == 0 {
		err = errors.New("GetResearcherFromAdmin err:" + err.Error())
		return
	}
	sTime, _ := time.ParseInLocation(utils.FormatDateTime, matter.StartDate+" "+matter.StartTime, time.Now().Location())
	startTime := sTime.Format("2006-01-02 15:04")
	eTime, _ := time.ParseInLocation(utils.FormatDateTime, matter.EndDate+" "+matter.EndTime, time.Now().Location())
	endTime := eTime.Format("2006-01-02 15:04")
	err = CreatSHCalendar(lists[0].Mobile, lists[0].Mobile, matter.MatterContent, startTime, endTime, 2, matter.RsMattersId)
	if err != nil {
		return
	}
	if err != nil {
		utils.SendEmail("研究员日历同步失败:", "新建上海研究员日历事项失败 "+err.Error(), utils.EmailSendToUsers)
	} else {
		updateParams := make(map[string]interface{})
		whereParams := make(map[string]interface{})
		updateParams["is_synced"] = 1
		whereParams["rs_matters_id"] = matter.RsMattersId
		err = roadshow.UpdateRsMatters(whereParams, updateParams)
		if err != nil {
			utils.FileLog.Info("UpdateRsMatters err: " + err.Error())
			fmt.Println("UpdateRsMatters err: " + err.Error())
			return
		}
	}
}

// CreatSHCalendar 新增上海日历活动
func CreatSHCalendar(userPhone, toUserPhone, content, startTime, endTime string, calendarType int8, selfCalendarId int) (err error) {
	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/Calendar/create?access_token=" + token

	//creditCode, err := rs.GetCreditCodeFromCompany(rsCalendar.CompanyId)
	//if err != nil {
	//	err = errors.New("GetCreditCodeFromCompany err:" + err.Error())
	//	return
	//}
	//发送创建请求
	resp, err := netHttp.PostForm(finalUrl, url.Values{"user_phone": {userPhone}, "to_user_phone": {toUserPhone},
		"content": {content}, "start_time": {startTime}, "end_time": {endTime}})
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}

	defer resp.Body.Close()

	//解析resp并且存入关联表
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reponse error", err)
		return
	}
	var calendarResp roadshow.CreatSHCalendarResp
	err = json.Unmarshal(body, &calendarResp)
	if calendarResp.Code != 1 {
		err = errors.New("Create SHCalendar err:" + calendarResp.Msg)
		return
	}
	sThirdId := calendarResp.Data.CalendarID
	thirdId, err := strconv.Atoi(sThirdId)
	if err != nil {
		err = errors.New("string to int Err:" + err.Error())
		return
	}
	relationItem := roadshow.RsCalendarRelation{
		UserPhone:        userPhone,
		CalendarType:     calendarType,
		SelfCalendarId:   selfCalendarId,
		ThirdCalendarId:  thirdId,
		Title:            content,
		ResearcherMobile: toUserPhone,
		ModifyTime:       time.Now(),
		CreateTime:       time.Now(),
	}
	_, err = roadshow.AddRsCalendarRelation(&relationItem)
	if err != nil {
		err = errors.New("AddRsCalendarRelation Err:" + err.Error())
		return
	}
	return
}

// UpdateSHCalendar 更新上海日历活动
func UpdateSHCalendar(req roadshow.EditActivityReq) {
	var err error
	//需要同时修改创建人及研究员的日历
	for _, researcher := range req.ResearcherList {
		//查询关联表获取信息
		var condition string
		var pars []interface{}
		condition = ` AND self_calendar_id = ? `
		pars = append(pars, req.RsCalendarResearcherId)
		relationItem, err := roadshow.GetRelationByPars(condition, pars)
		if err != nil {
			err = errors.New("GetRelationByPars err:" + err.Error())
			go utils.SendEmail(utils.APPNAME+"上海关联表查询失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
			fmt.Println(err)
			return
		}

		sTime, _ := time.ParseInLocation(utils.FormatDateTime, researcher.StartDate+" "+researcher.StartTime, time.Now().Location())
		startTime := sTime.Format("2006-01-02 15:04")
		eTime, _ := time.ParseInLocation(utils.FormatDateTime, researcher.EndDate+" "+researcher.EndTime, time.Now().Location())
		endTime := eTime.Format("2006-01-02 15:04")
		title := getTitle(req.ActivityType, req.RoadshowType, req.ActivityCategory, req.RoadshowPlatform, req.Province, req.City)
		//发送更新请求
		body, err := updateSHCalendar(fmt.Sprintf("%v", relationItem.ThirdCalendarId), relationItem.ResearcherMobile, title, startTime, endTime)
		if err != nil {
			fmt.Println(err)
		}

		//解析resp判断请求结果是否成功
		var calendarResp roadshow.CreatSHCalendarResp
		err = json.Unmarshal(body, &calendarResp)
		if calendarResp.Code != 1 {
			err = errors.New("Update SHCalendar err:" + calendarResp.Msg)
			fmt.Println(err)
		}
	}
	if err != nil {
		fmt.Println(err)
		utils.SendEmail("研究员日历同步失败:", "更新上海研究员日历失败 "+err.Error(), utils.EmailSendToUsers)
	} else {
		whereParams := make(map[string]interface{})
		updateParams := make(map[string]interface{})
		whereParams["rs_calendar_researcher_id"] = req.RsCalendarResearcherId
		updateParams["is_synced"] = 1
		err = roadshow.UpdateCalendarResearcher(whereParams, updateParams)
		if err != nil {
			fmt.Println("UpdateCalendarResearcher err: ", err.Error())
			return
		}
		calWhereParams := make(map[string]interface{})
		calWhereParams["rs_calendar_id"] = req.RsCalendarId
		err = roadshow.UpdateRsCalendar(calWhereParams, updateParams)
		if err != nil {
			fmt.Println("UpdateRsCalendar err: ", err.Error())
			return
		}
	}
}

// UpdateSHCalendarByMatter 更新上海日历活动
func UpdateSHCalendarByMatter(req roadshow.UpdateMattersReq) {
	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/Calendar/update?access_token=" + token

	//需要同时修改创建人及研究员的日历
	//查询关联表获取信息
	var condition string
	var pars []interface{}
	condition = ` AND self_calendar_id = ? `
	pars = append(pars, req.RsMattersId)
	relationItem, err := roadshow.GetRelationByPars(condition, pars)
	if err != nil {
		err = errors.New("GetRelationByPars err:" + err.Error())
		go utils.SendEmail(utils.APPNAME+"上海关联表查询失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		fmt.Println(err)
		return
	}

	sTime, _ := time.ParseInLocation(utils.FormatDateTime, req.StartDate+" "+req.StartTime, time.Now().Location())
	startTime := sTime.Format("2006-01-02 15:04")
	eTime, _ := time.ParseInLocation(utils.FormatDateTime, req.EndDate+" "+req.EndTime, time.Now().Location())
	endTime := eTime.Format("2006-01-02 15:04")
	//发送更新请求
	resp, err := netHttp.PostForm(finalUrl, url.Values{"calendar_id": {fmt.Sprintf("%v", relationItem.ThirdCalendarId)},
		"to_user_phone": {relationItem.ResearcherMobile}, "content": {relationItem.Content}, "start_time": {startTime}, "end_time": {endTime}})
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reponse error", err)
		return
	}

	//解析resp判断请求结果是否成功
	var calendarResp roadshow.CreatSHCalendarResp
	err = json.Unmarshal(body, &calendarResp)
	if calendarResp.Code != 1 {
		err = errors.New("Update SHCalendar err:" + calendarResp.Msg)
		fmt.Println(err)
	}
	if err != nil {
		go utils.SendEmail("研究员日历同步失败:", "更新上海研究员日历失败 "+err.Error(), utils.EmailSendToUsers)
	} else {
		updateParams := make(map[string]interface{})
		whereParams := make(map[string]interface{})
		updateParams["is_synced"] = 1
		whereParams["rs_matters_id"] = req.RsMattersId
		err = roadshow.UpdateRsMatters(whereParams, updateParams)
		if err != nil {
			utils.FileLog.Info("UpdateRsMatters err: " + err.Error())
			fmt.Println("UpdateRsMatters err: " + err.Error())
			return
		}
	}
}

// updateSHCalendar 内部函数，只用于发送修改上海日历的http请求
func updateSHCalendar(thirdCalendarId, researcherMobile, content, startTime, endTime string) (body []byte, err error) {
	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/Calendar/update?access_token=" + token
	resp, respErr := netHttp.PostForm(finalUrl, url.Values{"calendar_id": {thirdCalendarId},
		"to_user_phone": {researcherMobile}, "content": {content}, "start_time": {startTime}, "end_time": {endTime}})
	if respErr != nil {
		respErr = errors.New("NewRequest Err:" + respErr.Error())
		return
	}
	defer resp.Body.Close()

	body, bodyErr := ioutil.ReadAll(resp.Body)
	if bodyErr != nil {
		fmt.Println("reponse error", bodyErr)
		return
	}
	return
}

// DeleteSHCalendar 删除上海日历活动
func DeleteSHCalendar(rsCalendarResearcherId int) {
	var err error
	defer func() {
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"删除上海日历活动失败："+time.Now().Format("2006-01-02 15:04:05"), fmt.Sprint("关系id：", rsCalendarResearcherId, ";err:", err.Error()), utils.EmailSendToUsers)
		}
	}()

	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/Calendar/delete?access_token=" + token

	var condition string
	var pars []interface{}
	condition = ` AND self_calendar_id = ? `
	pars = append(pars, rsCalendarResearcherId)
	relationItem, err := roadshow.GetRelationByPars(condition, pars)
	if err != nil {
		err = errors.New("GetRelationByPars err" + err.Error())
		go utils.SendEmail(utils.APPNAME+"上海关联表查询失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		return
	}
	resp, err := netHttp.PostForm(finalUrl, url.Values{"user_phone": {relationItem.UserPhone}, "calendar_id": {fmt.Sprintf("%v", relationItem.ThirdCalendarId)}})
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reponse error", err)
		return
	}
	//解析resp判断请求结果是否成功
	var calendarResp roadshow.CreatSHCalendarResp
	err = json.Unmarshal(body, &calendarResp)
	if calendarResp.Code != 1 {
		err = errors.New("Update SHCalendar err:" + calendarResp.Msg)
		return
	}
	//删除活动表及事项表
	err = roadshow.DeleteRsCalendarRelation(relationItem.RelationId)
	if err != nil {
		err = errors.New("DeleteRsCalendarRelation err:" + err.Error())
		return
	}
	if err != nil {
		//发送邮件解决异常
		utils.SendEmail("研究员日历同步失败:", "删除上海研究员日历失败 "+err.Error(), utils.EmailSendToUsers)
		//fmt.Println("DeleteSHCalendar err:",err.Error())
	}
}

// DeleteSHMatter 删除上海日历事项
func DeleteSHMatter(matterId int) {
	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/Calendar/delete?access_token=" + token

	var condition string
	var pars []interface{}
	condition = ` AND self_calendar_id = ? `
	pars = append(pars, matterId)
	relationItem, err := roadshow.GetRelationByPars(condition, pars)
	if err != nil {
		err = errors.New("GetRelationByPars err" + err.Error())
		go utils.SendEmail(utils.APPNAME+"上海关联表查询失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		return
	}
	resp, err := netHttp.PostForm(finalUrl, url.Values{"user_phone": {relationItem.UserPhone}, "calendar_id": {fmt.Sprintf("%v", relationItem.ThirdCalendarId)}})
	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reponse error", err)
		return
	}
	//解析resp判断请求结果是否成功
	var calendarResp roadshow.CreatSHCalendarResp
	err = json.Unmarshal(body, &calendarResp)
	if calendarResp.Code != 1 {
		err = errors.New("Update SHCalendar err:" + calendarResp.Msg)
		return
	}
	//删除活动表及事项表
	err = roadshow.DeleteRsCalendarRelation(relationItem.RelationId)
	if err != nil {
		err = errors.New("DeleteRsCalendarRelation err:" + err.Error())
		return
	}
	if err != nil {
		//发送邮件解决异常
		utils.SendEmail("研究员日历同步失败:", "删除上海研究员日历失败 "+err.Error(), utils.EmailSendToUsers)
		//fmt.Println("DeleteSHCalendar err:",err.Error())
	}
}

// SyncCalendarFromShanghai 上海路演数据同步到自系统
func SyncCalendarFromShanghai(userPhone, startDate, endDate string) (err error) {
	errMsg := ``
	defer func() {
		if errMsg != `` {
			//fmt.Println("err:", errMsg)
			go utils.SendEmail(utils.APPNAME+"上海路演数据同步到自系统失败："+time.Now().Format("2006-01-02 15:04:05"), errMsg, utils.EmailSendToUsers)
		}
	}()
	//fmt.Println(userPhone, startDate, endDate)
	endDateTime, err := time.ParseInLocation(utils.FormatDate, endDate, time.Local)
	if err != nil {
		errMsg = `结束日期转time类型失败，err:` + err.Error()
		return
	}
	currDay := time.Now().Format(utils.FormatDate)
	nowDateTime, _ := time.ParseInLocation(utils.FormatDate, currDay, time.Local)
	//如果传入的结束日期早于当前日期，那么就不去查询了
	if endDateTime.Before(nowDateTime) {
		return
	}
	//以当前日期作为起始日期去同步
	list, err := getCalendarFrom(userPhone, currDay, endDate)
	if err != nil {
		errMsg = "获取第三方路演日历数据失败,err:" + err.Error()
		return
	}
	thirdIdList := make([]int, 0)
	if len(list) > 0 {
		for _, v := range list {
			thirdIdList = append(thirdIdList, v.ID)
		}
		rsCalendarRelationList, tmpErr := roadshow.GetRsCalendarRelationListByThirdIds(thirdIdList)
		if tmpErr != nil {
			err = tmpErr
			errMsg = "获取关联列表失败,err:" + tmpErr.Error()
			return
		}

		rsCalendarRelationMap := make(map[int]*roadshow.RsCalendarRelation)
		for _, rsCalendarRelation := range rsCalendarRelationList {
			rsCalendarRelationMap[rsCalendarRelation.ThirdCalendarId] = rsCalendarRelation
		}

		for _, v := range list {
			fmt.Println(v)
			thirdIdList = append(thirdIdList, v.ID)
			if rsCalendarRelation, ok := rsCalendarRelationMap[v.ID]; ok {
				//存在的话，那么就去查找对应的信息
				if rsCalendarRelation.CalendarType == 1 {
					//路演
					rsCalendarResearcherInfo, tmpErr := roadshow.GetRsCalendarResearcherById(rsCalendarRelation.SelfCalendarId)
					if tmpErr != nil {
						errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取路演研究员信息失败;err:"+tmpErr.Error(), ";")
						continue
					}
					rsCalendarInfo, tmpErr := roadshow.GetRsCalendarById(rsCalendarResearcherInfo.RsCalendarId)
					if tmpErr != nil {
						errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取路演信息失败;err:"+tmpErr.Error(), ";")
						continue
					}
					if rsCalendarInfo.Source == 0 { //自系统创建的路演活动，不需要依靠上海方来修改
						continue
					}

					//是否去同步变更数据库
					isUpdateSync := false

					//是否变更
					isUpdate := false
					if v.StartTime != rsCalendarRelation.StartTime {
						isUpdate = true
					}
					if v.EndTime != rsCalendarRelation.EndTime {
						isUpdate = true
					}
					if v.Title != rsCalendarRelation.Title {
						isUpdate = true
					}

					researcherList := make([]admin.Admin, 0)
					researcherMap := make(map[int]admin.Admin)

					addResearcherList := make([]admin.Admin, 0)                  // 需要新增的研究员
					delResearcherIdList := make([]int, 0)                             //需要删除的路演活动与研究员的关系id
					updateResearcherList := make([]*roadshow.RsCalendarResearcher, 0) //待更新的路演活动中研究员信息

					if v.ResearcherMobile != rsCalendarRelation.ResearcherMobile {
						//研究员变更了，需要去改表
						isUpdateSync = true

						researcherMobileList := strings.Split(v.ResearcherMobile, ",")
						if len(researcherMobileList) > 0 {
							for _, mobile := range researcherMobileList {
								researcherInfo, tmpErr := getAdminInfo(mobile)
								if tmpErr != nil {
									errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取研究员失败,研究员手机号：", mobile, ";err:"+tmpErr.Error(), ";")
									continue
								}
								if researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_RESEARCHR ||
									researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RESEARCHR ||
									researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_RESEARCHR ||
									researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_DEPARTMENT ||
									researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_DEPARTMENT {
									researcherList = append(researcherList, researcherInfo)

									researcherMap[researcherInfo.AdminId] = researcherInfo
								}
							}
						}

						//没有研究员
						if len(researcherList) <= 0 {
							errMsg += fmt.Sprint("第三方日历ID：", v.ID, "；对方研究员信息失败；")
							continue
						}

						rsCalendarResearcherList, tmpErr := roadshow.GetRsCalendarResearcherListByRsCalendarId(rsCalendarInfo.RsCalendarId)
						if tmpErr != nil {
							errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取路演活动中的研究员列表失败,路演活动ID：", rsCalendarInfo.RsCalendarId, ";err:"+tmpErr.Error(), ";")
							continue
						}

						//现有活动中的研究员
						rsCalendarResearcherMap := make(map[int]*roadshow.RsCalendarResearcher)
						for _, rsCalendarResearcher := range rsCalendarResearcherList {
							if _, ok := researcherMap[rsCalendarResearcher.ResearcherId]; ok {
								if isUpdate {
									updateResearcherList = append(updateResearcherList, rsCalendarResearcher)
								}
							} else {
								delResearcherIdList = append(delResearcherIdList, rsCalendarResearcher.RsCalendarResearcherId)
							}

							rsCalendarResearcherMap[rsCalendarResearcher.ResearcherId] = rsCalendarResearcher
						}

						//校验是否需要新增研究员
						for adminId, researcherInfo := range researcherMap {
							//如果
							if _, ok := rsCalendarResearcherMap[adminId]; !ok {
								addResearcherList = append(addResearcherList, researcherInfo)
							}
						}
					} else if isUpdate { //如果有字段更新，那么需要将所有的研究员信息更新
						isUpdateSync = true

						rsCalendarResearcherList, tmpErr := roadshow.GetRsCalendarResearcherListByRsCalendarId(rsCalendarInfo.RsCalendarId)
						if tmpErr != nil {
							errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取路演活动中的研究员列表失败,路演活动ID：", rsCalendarInfo.RsCalendarId, ";err:"+tmpErr.Error(), ";")
							continue
						}
						for _, rsCalendarResearcher := range rsCalendarResearcherList {
							updateResearcherList = append(updateResearcherList, rsCalendarResearcher)
						}
					}

					if isUpdateSync {
						tmpErr = roadshow.UpdateSyncRsCalendarRelation(v, rsCalendarInfo, rsCalendarRelation, updateResearcherList, delResearcherIdList, addResearcherList)
						if tmpErr != nil {
							err = tmpErr
							errMsg += fmt.Sprint("第三方日历ID：", v.ID, "修改关联关系失败；err:"+tmpErr.Error(), ";")
							return
						}
					}
				} else {
					//事项
					//事项都是由自系统创建的，不需要依靠上海方来修改
				}
			} else {
				//数据不存在
				createUser, tmpErr := getAdminInfo(v.UserPhone)
				if tmpErr != nil {
					errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取创建人失败,创建人手机号：", v.UserPhone, ";err:"+tmpErr.Error(), ";")
					continue
				}

				//研究员列表
				researcherList := make([]admin.Admin, 0)
				researcherMobileList := strings.Split(v.ResearcherMobile, ",")
				if len(researcherMobileList) > 0 {
					for _, mobile := range researcherMobileList {
						researcherInfo, tmpErr := getAdminInfo(mobile)
						if tmpErr != nil {
							errMsg += fmt.Sprint("第三方日历ID：", v.ID, "获取研究员失败,研究员手机号：", mobile, ";err:"+tmpErr.Error(), ";")
							continue
						}
						if researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_RESEARCHR ||
							researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RESEARCHR ||
							researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_RESEARCHR ||
							researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_DEPARTMENT ||
							researcherInfo.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_DEPARTMENT {
							researcherList = append(researcherList, researcherInfo)
						}
					}
				}

				//没有研究员
				if len(researcherList) <= 0 {
					continue
				}
				//数据入库
				tmpErr = roadshow.SyncRsCalendarRelation(v, createUser, researcherList)
				if tmpErr != nil {
					err = tmpErr
					errMsg += fmt.Sprint("第三方日历ID：", v.ID, "绑定关联关系失败；err:"+tmpErr.Error(), ";")
					return
				}
				//fmt.Println("createUser:", createUser)
			}

		}
	}
	return
}

// CreateOaUser 新增系统用户
func CreateOaUser(mobile, username string, groupId int) (err error) {
	defer func() {
		if err != nil {
			go utils.SendEmail(utils.APPNAME+"系统用户同步到上海失败："+time.Now().Format("2006-01-02 15:04:05"), err.Error(), utils.EmailSendToUsers)
		}
	}()
	token, err := GetAccessToken()
	finalUrl := utils.CRM_OPEN_API_URL + "/v1/OaUser/create?access_token=" + token

	//发送创建请求
	form := url.Values{}
	form.Add("mobile", mobile)
	form.Add("username", username)
	form.Add("group_id", fmt.Sprint(groupId))
	resp, err := netHttp.PostForm(finalUrl, form)
	fmt.Println("form:", form)

	if err != nil {
		err = errors.New("NewRequest Err:" + err.Error())
		return
	}

	defer resp.Body.Close()

	//解析resp并且存入关联表
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reponse error", err)
		return
	}
	fmt.Println("body:", string(body))
	var calendarResp roadshow.CreatSHCalendarResp
	err = json.Unmarshal(body, &calendarResp)
	if calendarResp.Code != 1 {
		err = errors.New("Create SHCalendar err:" + calendarResp.Msg)
		return
	}
	return
}

// getAdminInfo 通过手机号获取用户信息
func getAdminInfo(mobile string) (adminInfo admin.Admin, err error) {
	adminMap := make(map[string]admin.Admin)
	redisAdminData, redisErr := utils.Rc.RedisString(utils.CACHE_KEY_ADMIN)
	if redisErr != nil {
		list, err := admin.GetSysuserList("", []interface{}{}, 0, 1000)
		//	GetSysuserList
		for _, tmpAdminInfo := range list {
			adminMap[tmpAdminInfo.Mobile] = *tmpAdminInfo
		}

		//入缓存
		redisJsonData, err := json.Marshal(adminMap)
		if err == nil {
			_ = utils.Rc.Put(utils.CACHE_KEY_ADMIN, string(redisJsonData), time.Minute*30)
		}
	} else {
		err := json.Unmarshal([]byte(redisAdminData), &adminMap)
		if err != nil {
			fmt.Println("用户数据，json转换失败：", err)
		}
	}
	adminInfo, ok := adminMap[mobile]
	if !ok {
		err = fmt.Errorf("找不到该手机号用户，mobile:" + mobile)
	}

	return
}

func getTitle(activityType, roadshowType, activityCategory, roadshowPlatform, province, city string) string {
	var title string
	switch activityType {
	case "内部会议":
		title = "内部会议"
	case "公开会议", "路演":
		if roadshowType == "线上" {
			title = roadshowType + activityType + roadshowPlatform
		} else {
			title = roadshowType + activityType + province + city
		}
	case "报告电话会":
		title = activityCategory + "电话会"
	}
	return title
}

// GetAllActivityType 获取全部的活动分类
func GetAllActivityType() (list []*roadshow.ActivityTypeList, err error) {
	list, err = roadshow.GetActivityTypeListByActivityTypePId(0)
	if err != nil {
		return
	}

	for _, v := range list {
		tmpList, tmpErr := roadshow.GetActivityTypeListByActivityTypePId(v.ActivityTypeId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		v.ChildList = tmpList
	}
	return
}