hongze_yb/services/company/permission.go

package company

import (
	"errors"
	"fmt"
	companyCache "hongze/hongze_yb/cache/company"
	"hongze/hongze_yb/global"
	"hongze/hongze_yb/models/response"
	"hongze/hongze_yb/models/tables/admin"
	"hongze/hongze_yb/models/tables/chart_permission"
	"hongze/hongze_yb/models/tables/company"
	"hongze/hongze_yb/models/tables/company_product"
	"hongze/hongze_yb/models/tables/company_report_permission"
	"hongze/hongze_yb/models/tables/company_user_chart_classify_permission"
	"hongze/hongze_yb/models/tables/wx_user"
	"hongze/hongze_yb/models/tables/yb_apply_record"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/utils"
	"sort"
	"strings"
	"time"
)

// GetClassNameListByProductId 根据权限id获取权限分类
func GetClassNameListByProductId(productId int64) (list []*chart_permission.ChartPermission, err error) {
	list, err = chart_permission.GetClassNameListByProductId(productId)
	return
}

// GetPermissionListByProductId 根据product_id获取所有的权限列表
func GetPermissionListByProductId(productId int64) (list []*chart_permission.ChartPermission, err error) {
	list, err = chart_permission.GetListByProductId(productId)
	return
}

// GetValidPermissionByCompany2ProductId 根据客户id和产品id获取有效的权限列表
func GetValidPermissionByCompany2ProductId(companyId, productId int64) (list []*company_report_permission.CompanyReportPermission, err error) {
	where := make(map[string]interface{})
	where["company_id ="] = companyId
	where["product_id ="] = productId
	where["status in"] = []string{"正式", "试用", "永续"}
	list, err = company_report_permission.GetByWhereMap(where)
	return
}


// GetPurchasePermissionIdsByCompany2ProductId 根据客户id和产品id获取有效的权限id集合
func GetPurchasePermissionIdsByCompany2ProductId(companyId, productId int64) (permissionIds []int, err error) {
	where := make(map[string]interface{})
	where["company_id ="] = companyId
	where["product_id ="] = productId
	where["status in"] = []string{"正式", "永续"}
	list, err := company_report_permission.GetByWhereMap(where)
	if err != nil {
		return
	}
	for _, v := range  list {
		permissionIds = append(permissionIds, v.ChartPermissionID)
	}
	return
}

// GetValidPermissionIdListByCompany2ProductId 根据客户id和产品id获取有效的权限id列表
func GetValidPermissionIdListByCompany2ProductId(companyId, productId int64) (list []int, err error) {
	companyReportPermissionList, err := GetValidPermissionByCompany2ProductId(companyId, productId)
	if err != nil {
		return
	}
	for _, v := range companyReportPermissionList {
		list = append(list, v.ChartPermissionID)
	}
	return
}

// PermissionCheckInfo 权限校验完成后的结果
type PermissionCheckInfo struct {
	Name         string       `json:"name" description:"销售名称"`
	Mobile       string       `json:"mobile" description:"手机号"`
	Type         string       `json:"type" description:"校验失败，没有权限，需要让前端处理的类型，枚举值：apply,contact"`
	CustomerInfo CustomerInfo `json:"customer_info" description:"客户信息"`
}

// CustomerInfo 客户信息
type CustomerInfo struct {
	CompanyName string `json:"company_name" description:"客户（公司）名称"`
	Name        string `json:"name" description:"联系人名称"`
	Mobile      string `json:"mobile" description:"手机号"`
	Status      string `json:"status" description:"状态"`
	IsSuspend   int8   `json:"is_suspend" description:"启用与否字段：1:暂停,0:启用"`
	HasApply    bool   `json:"has_apply" description:"是否有申请过"`
}

// CheckPermissionByFicc 权限校验
func CheckPermissionByFicc(companyId int64, permissionId int) (ok bool, permissionCheckInfo PermissionCheckInfo, err error) {
	//非潜在客户
	var productId int64
	productId = 1
	if companyId > 1 {
		//查询是否 开通ficc的客户
		companyProductInfo, tmpErr := company_product.GetByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			// 没有开通ficc的客户
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}

		// 如果客户ficc产品的状态是流失，那么也是让去申请
		if companyProductInfo.Status == "流失" {
			permissionCheckInfo.Type = "apply"
			return
		}
		// 获取有效的权限id列表
		validPermissionIdList, tmpErr := GetValidPermissionIdListByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		// 校验在有效的权限id列表中是否存在该权限
		for _, validPermissionId := range validPermissionIdList {
			//如果有该权限id，那么直接返回校验通过
			if validPermissionId == permissionId {
				ok = true
				return
			}
		}
		//查找对应客户的销售信息

		adminInfo, tmpErr := admin.GetByAdminId(companyProductInfo.SellerID)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		permissionCheckInfo = PermissionCheckInfo{
			Name:   adminInfo.RealName,
			Mobile: adminInfo.Mobile,
			Type:   "contact",
		}
	} else {
		permissionCheckInfo.Type = "apply"
	}

	return
}

// CheckPermissionByPermissionIdList2Ficc 根据权限id集合权限校验（ficc）
func CheckPermissionByPermissionIdList2Ficc(companyId int64, userId int, permissionIdList []int) (ok bool, permissionCheckInfo PermissionCheckInfo, err error) {
	defer func() {
		// 如果无权限，那么就去查询是否申请过
		if ok == false {
			ok, _ = checkPermissionByPermissionIdList2Rai(companyId, userId, permissionIdList)
		}
		if ok == false && permissionCheckInfo.Type == "apply" {
			_, err = yb_apply_record.GetLastNotOpRecordByUserId(userId)	// 从来源我的/活动申请的记录
			if err != nil && err != utils.ErrNoRow {
				return
			}
			//查询是否有申请过，如果有申请过的话，那么err是nil
			if err == nil {
				permissionCheckInfo.CustomerInfo.HasApply = true
			}
		}
	}()
	//非潜在客户
	if len(permissionIdList) <= 0 {
		err = fmt.Errorf("权限异常，请传入需要校验的权限")
		return
	}

	permissionMap := make(map[int]bool)
	for _, permissionId := range permissionIdList {
		permissionMap[permissionId] = true
	}
	var productId int64
	productId = 1
	if companyId > 1 {
		//查询是否 开通ficc的客户
		companyProductInfo, tmpErr := company_product.GetByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			// 没有开通ficc的客户
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}

		wxUser, tmpErr := wx_user.GetByUserId(userId)
		if tmpErr != nil {
			permissionCheckInfo.Type = "apply"
			err = tmpErr
			return
		}

		//客户信息
		companyInfo, tmpErr := company.GetByCompanyId(companyId)
		if tmpErr != nil {
			// 没有开通ficc的客户
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}
		customerInfo := CustomerInfo{
			CompanyName: companyInfo.CompanyName,
			Status:      companyProductInfo.Status,
			Name:        wxUser.RealName,
			IsSuspend:   companyProductInfo.IsSuspend,
			Mobile:      wxUser.Mobile,
		}
		permissionCheckInfo.CustomerInfo = customerInfo

		// 如果客户ficc产品的状态是流失，那么也是让去申请
		if companyProductInfo.Status == "流失" {
			permissionCheckInfo.Type = "apply"
			return
		}

		//查找对应客户的销售信息
		adminInfo, tmpErr := admin.GetByAdminId(companyProductInfo.SellerID)
		if tmpErr != nil {
			//if tmpErr ==
			err = tmpErr
			return
		}

		permissionCheckInfo.Name = adminInfo.RealName
		permissionCheckInfo.Mobile = adminInfo.Mobile
		if companyProductInfo.Status == "冻结" {
			permissionCheckInfo.Type = "contact"
			return
		}

		//客户状态是：试用暂停状态（联系销售）
		if companyProductInfo.Status == "试用" && companyProductInfo.IsSuspend == 1 {
			permissionCheckInfo.Type = "contact"
			return
		}

		// 获取有效的权限id列表
		validPermissionIdList, tmpErr := GetValidPermissionIdListByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		// 校验在有效的权限id列表中是否存在该权限
		for _, validPermissionId := range validPermissionIdList {
			//如果有该权限id，那么直接返回校验通过
			if _, validOk := permissionMap[validPermissionId]; validOk {
				ok = true
				return
			}
		}
		permissionCheckInfo.Type = "contact"
	} else {
		permissionCheckInfo.Type = "apply"
	}

	return
}

func GetCheckPermission(companyId int64, userId int, permissionIdList []int) (ok bool, permissionCheckInfo response.PermissionCheckInfo, finalValidPermissionIds []int, err error) {
	defer func() {
		// 如果无权限，那么就去查询是否申请过
		if ok == false {
			ok, _ = checkPermissionByPermissionIdList2Rai(companyId, userId, permissionIdList)
		}
		if ok == false && permissionCheckInfo.Type == "apply" {
			_, err = yb_apply_record.GetLastNotOpRecordByUserId(userId)	// 从来源我的/活动申请的记录
			if err != nil {
				if err == utils.ErrNoRow {
					err = nil
				}
				return
			}
			//查询是否有申请过，如果有申请过的话，那么err是nil
			if err == nil {
				permissionCheckInfo.CustomerInfo.HasApply = true
			}
		}
	}()
	//非潜在客户
	permissionMap := make(map[int]bool)
	if len(permissionIdList) > 0 {
		for _, permissionId := range permissionIdList {
			permissionMap[permissionId] = true
		}
	}

	var productId int64
	productId = 1
	if companyId > 1 {
		//查询是否 开通ficc的客户
		companyProductInfo, tmpErr := company_product.GetByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			// 没有开通ficc的客户
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}

		wxUser, tmpErr := wx_user.GetByUserId(userId)
		if tmpErr != nil {
			permissionCheckInfo.Type = "apply"
			err = tmpErr
			return
		}

		//客户信息
		companyInfo, tmpErr := companyCache.GetByCompanyId(companyId)
		if tmpErr != nil {
			// 没有开通ficc的客户
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}
		customerInfo := response.CustomerInfo{
			CompanyName: companyInfo.CompanyName,
			Status:      companyProductInfo.Status,
			Name:        wxUser.RealName,
			IsSuspend:   companyProductInfo.IsSuspend,
			Mobile:      wxUser.Mobile,
		}
		permissionCheckInfo.CustomerInfo = customerInfo

		// 如果客户ficc产品的状态是流失，那么也是让去申请
		if companyProductInfo.Status == "流失" {
			permissionCheckInfo.Type = "apply"
			return
		}

		//查找对应客户的销售信息
		adminInfo, tmpErr := admin.GetByAdminId(companyProductInfo.SellerID)
		if tmpErr != nil {
			//if tmpErr ==
			err = tmpErr
			return
		}

		permissionCheckInfo.Name = adminInfo.RealName
		permissionCheckInfo.Mobile = adminInfo.Mobile
		if companyProductInfo.Status == "冻结" {
			permissionCheckInfo.Type = "contact"
			return
		}

		//客户状态是：试用暂停状态（联系销售）
		if companyProductInfo.Status == "试用" && companyProductInfo.IsSuspend == 1 {
			permissionCheckInfo.Type = "contact"
			return
		}

		// 获取有效的权限id列表
		validPermissionIdList, tmpErr := GetValidPermissionIdListByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		// 校验在有效的权限id列表中是否存在该权限
		if len(permissionIdList) > 0 {
			for _, validPermissionId := range validPermissionIdList {
				//如果有该权限id，那么直接返回校验通过
				if _, validOk := permissionMap[validPermissionId]; validOk {
					finalValidPermissionIds = append(finalValidPermissionIds, validPermissionId)
					ok = true
				}
			}
			return
		}

		permissionCheckInfo.Type = "contact"
	} else {
		permissionCheckInfo.Type = "apply"
	}
	permissionCheckInfo.HzPhone = utils.HZPHONE
	return
}

// checkPermissionByPermissionIdList2Rai 根据权限id集合权限校验（权益）
func checkPermissionByPermissionIdList2Rai(companyId int64, userId int, permissionIdList []int) (ok bool, err error) {
	//非潜在客户
	if len(permissionIdList) <= 0 {
		err = fmt.Errorf("权限异常，请传入需要校验的权限")
		return
	}

	// 查询用户是否为弘则研究已禁用的联系人
	wxUser, tmpErr := wx_user.GetByUserId(userId)
	if tmpErr != nil {
		err = fmt.Errorf("用户信息异常")
		return
	}
	if companyId == 16 {
		if wxUser.Enabled != 1 {
			return
		}
	}

	//市场策略（ficc权限id）：33
	ficcPermissionId := 33
	//市场策略（权益权限id）：23
	raiPermissionId := 23

	//是否往下校验
	var permissionOk bool
	for _, permissionId := range permissionIdList {
		if permissionId == ficcPermissionId {
			permissionOk = true
		}
	}
	var productId int64
	productId = 2
	if companyId > 1 && permissionOk {
		// 获取有效的权限id列表
		validPermissionIdList, tmpErr := GetValidPermissionIdListByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		// 校验在有效的权限id列表中是否存在该权限
		for _, validPermissionId := range validPermissionIdList {
			if validPermissionId == raiPermissionId {
				ok = true
				return
			}
		}
	}

	return
}

// ChartPermissionCheckInfo 图表权限验证信息
type ChartPermissionCheckInfo struct {
	Name         	string       	`json:"name" description:"销售名称"`
	Mobile       	string       	`json:"mobile" description:"手机号"`
	Type			string			`json:"type" description:"无权限，需要前端处理的类型，枚举值：expired, apply, contact"`
	CustomerInfo	CustomerInfo 	`json:"customer_info" description:"客户信息"`
}

// CheckUserChartPermission 验证用户/联系人的图库权限
func CheckUserChartPermission(companyId int64, userId int) (ok bool, permissionCheckInfo ChartPermissionCheckInfo, err error) {
	defer func() {
		// 如果无权限，那么就去查询是否申请过
		if ok == false && permissionCheckInfo.Type == "apply" {
			_, err = yb_apply_record.GetLastNotOpRecordByUserId(userId)	// 图库申请
			// 查询是否有申请过，如果有申请过的话，那么err是nil
			if err != nil {
				if err == utils.ErrNoRow {
					err = nil
					return
				}
				return
			}
			permissionCheckInfo.CustomerInfo.HasApply = true
		}
	}()

	var productId int64
	productId = 1
	if companyId > 1 {
		// 查询是否开通FICC
		companyProductInfo, tmpErr := company_product.GetByCompany2ProductId(companyId, productId)
		if tmpErr != nil {
			// 没有开通FICC
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}

		wxUser, tmpErr := wx_user.GetByUserId(userId)
		if tmpErr != nil {
			permissionCheckInfo.Type = "apply"
			err = tmpErr
			return
		}

		// 客户信息
		companyInfo, tmpErr := company.GetByCompanyId(companyId)
		if tmpErr != nil {
			// 没有开通FICC
			if tmpErr == utils.ErrNoRow {
				permissionCheckInfo.Type = "apply"
				return
			}
			err = tmpErr
			return
		}
		customerInfo := CustomerInfo{
			CompanyName: companyInfo.CompanyName,
			Status:      companyProductInfo.Status,
			Name:        wxUser.RealName,
			IsSuspend:   companyProductInfo.IsSuspend,
			Mobile:      wxUser.Mobile,
		}
		permissionCheckInfo.CustomerInfo = customerInfo

		// 如果客户FICC产品的状态是流失-申请
		if companyProductInfo.Status == "流失" {
			permissionCheckInfo.Type = "apply"
			return
		}

		// 查找对应客户的销售信息
		adminInfo, tmpErr := admin.GetByAdminId(companyProductInfo.SellerID)
		if tmpErr != nil {
			err = tmpErr
			return
		}

		// 客户状态为冻结/试用暂停-联系销售
		permissionCheckInfo.Name = adminInfo.RealName
		permissionCheckInfo.Mobile = adminInfo.Mobile
		if companyProductInfo.Status == "冻结" || (companyProductInfo.Status == "试用" && companyProductInfo.IsSuspend == 1) {
			permissionCheckInfo.Type = "contact"
			return
		}

		// 验证用户的图表权限
		permissionInfo, tmpErr := company_user_chart_classify_permission.GetPermissionByUserId(userId)
		if tmpErr != nil {
			if tmpErr == utils.ErrNoRow {
				// 无权限-联系销售
				permissionCheckInfo.Type = "contact"
				return
			}
			err = tmpErr
			return
		}
		nowTime := time.Now()
		if permissionInfo.Enabled != 1 {
			// 权限被禁用-联系销售
			permissionCheckInfo.Type = "contact"
			return
		}
		endTime := permissionInfo.EndTime.Add(23 * time.Hour + 59 * time.Minute + 59 * time.Second)
		if nowTime.After(permissionInfo.StartTime) && nowTime.Before(endTime) {
			ok = true
		} else {
			// 权限已到期
			permissionCheckInfo.Type = "expired"
			return
		}

		// 都不是默认联系销售
		permissionCheckInfo.Type = "contact"
	} else {
		permissionCheckInfo.Type = "apply"
	}

	return
}

type FiccPermissionList struct {
	ClassifyName	string 				`description:"分类"`
	HasPermission	bool				`description:"是否有权限"`
	Items        	[]*PermissionItem	`description:"子类"`
}

type PermissionItem struct {
	PermissionId 		int    	`description:"权限id"`
	PermissionName    	string 	`description:"权限名称"`
	HasPermission		bool	`description:"是否有权限"`
}

// GetFiccPermissionList 获取FICC品种权限列表
func GetFiccPermissionList() (list []*FiccPermissionList, err error) {
	productId := 1
	for _, v := range utils.PermissionFiccClassifyArr {
		classify := new(FiccPermissionList)
		classify.ClassifyName = v
		items, tmpErr := chart_permission.GetListByProductIdAndClassifyName(productId, v)
		if tmpErr != nil {
			return
		}
		tmpItems := make([]*PermissionItem, 0)
		for _, iv := range items {
			item := new(PermissionItem)
			item.PermissionId = int(iv.ChartPermissionID)
			item.PermissionName = iv.PermissionName
			tmpItems = append(tmpItems, item)
		}
		classify.Items = tmpItems
		list = append(list, classify)
	}

	return
}

func GetHomeFiccPermissions(user user.UserInfo) (ret response.PermissionFiccResp, err error){
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetHomeFiccPermissions: userId=%d, err:%s， errMsg:%s", user.UserID, err.Error(), errMsg))
		}
	}()
	validPermissionList, err := GetValidPermissionByCompany2ProductId(user.CompanyID, 1)
	if err != nil {
		return
	}
	var validPermissionIds []int
	for _, item := range validPermissionList {
		validPermissionIds = append(validPermissionIds, item.ChartPermissionID)
	}
	permissionList, err := chart_permission.GetFiccListExceptTacticByProductId()
	if err != nil {
		return
	}
	permissionMap := make(map[uint64]bool)
	permissionFirstMap := make(map[string]*response.PermissionFirstItem)
	permissionFirstMap["宏观经济"] = &response.PermissionFirstItem{
		Sort: 1001,
	}
	permissionFirstMap["化工产业"] = &response.PermissionFirstItem{
		Sort: 1002,
	}
	permissionFirstMap["黑色产业"] = &response.PermissionFirstItem{
		Sort: 1003,
	}
	permissionFirstMap["有色产业"] = &response.PermissionFirstItem{
		Sort: 1004,
	}

	for k, v := range permissionList {
		permissionMap[v.ChartPermissionID] = false
		for _, myPerId := range validPermissionIds {
			if int(v.ChartPermissionID) == myPerId {
				permissionMap[v.ChartPermissionID] = true
				permissionList[k].Sort = v.Sort - 1000
				if _, ok :=  permissionFirstMap[v.ClassifyName]; ok && !permissionFirstMap[v.ClassifyName].IsCheck {
					permissionFirstMap[v.ClassifyName].AuthOk = true
					permissionFirstMap[v.ClassifyName].Sort -= 1000
					permissionFirstMap[v.ClassifyName].IsCheck = true
				}
				break
			}
		}
	}

	for _, v := range permissionList {
		temp := new(response.PermissionFiccSecondItem)
		temp.Sort = v.Sort
		temp.ChartPermissionID = int(v.ChartPermissionID)
		temp.ChartPermissionName = v.PermissionName
		temp.AuthOk = permissionMap[v.ChartPermissionID]
		if _, ok := permissionFirstMap[v.ClassifyName]; ok{
			permissionFirstMap[v.ClassifyName].List = append(permissionFirstMap[v.ClassifyName].List, temp)
		}else{
			permissionFirstMap[v.ClassifyName] = &response.PermissionFirstItem{
				List: []*response.PermissionFiccSecondItem{temp},
			}
		}


	}
	var list response.PermissionFiccList
	for k, v := range permissionFirstMap {
		temp := new(response.PermissionFiccItem)
		temp.Sort = v.Sort
		temp.ClassifyName = k
		if strings.Contains(temp.ClassifyName, "宏观") {
			temp.ClassifyName = "宏观经济"
			temp.SelectIconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_hongguan_select.png"
			temp.IconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_hongguan.png"
		}else if temp.ClassifyName == "化工产业" {
			temp.ClassifyName = "化工"
			temp.SelectIconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_huagong_select.png"
			temp.IconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_huagong.png"
		}else if temp.ClassifyName == "黑色产业" {
			temp.ClassifyName = "黑色"
			temp.SelectIconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_black_select.png"
			temp.IconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_black.png"
		}else if temp.ClassifyName == "有色产业" {
			temp.ClassifyName = "有色"
			temp.SelectIconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_youse_select.png"
			temp.IconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_youse.png"
		}
		if len(v.List) > 0 {
			temp.List = v.List
			sort.Sort(temp.List)
		}
		list = append(list, temp)
	}

	if len(list) > 0 {
		sort.Sort(list)
	}
	//判断是否是已购用户，如果是已购用户，需要返回对应的联系人方式
	companyProduct, err := company_product.GetByCompany2ProductId(user.CompanyID, 1)
	if err != nil {
		if err == utils.ErrNoRow {
			err = nil
		}
	}

	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询用户状态失败")
		return
	}
	// 已购仅付费用户可见
	var contactInfo response.PermissionCheckContactInfo
	checkFlag := false
	if strings.Contains("永续,正式", companyProduct.Status) {
		//查询对应的销售
		//查找对应客户的销售信息
		adminInfo, tmpErr := admin.GetByAdminId(companyProduct.SellerID)
		if tmpErr != nil {
			errMsg = tmpErr.Error()
			err = errors.New("查询销售信息出错")
			return
		}
		contactInfo.Name = adminInfo.RealName
		contactInfo.Mobile = adminInfo.Mobile
		checkFlag = true
	}

	temp := new(response.PermissionFiccItem)
	temp.SelectIconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_more_select.png"
	temp.IconUrl = utils.ALIYUN_YBIMG_HOST+"ficc_icon_idx_more.png"
	temp.ClassifyName = "更多报告"
	temp.Sort = 100000
	list = append(list, temp)

	ret.PermissionList = list
	ret.CheckFlag = checkFlag
	ret.ContactInfo = contactInfo
	return
}