add: 1-图库权限 2-图库分类 3-图库列表

controller/chart/my_chart.go

@@ -0,0 +1,117 @@
+package chart
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/models/response/my_chart"
+	my_chart2 "hongze/hongze_yb/models/tables/my_chart"
+	"hongze/hongze_yb/services/chart"
+	"hongze/hongze_yb/services/user"
+	"strconv"
+	"strings"
+)
+
+// GetMyChartChassify 获取图表分类列表
+// @Tags 图库模块
+// @Summary  获取图表分类
+// @Description 获取图表分类列表
+// @Security ApiKeyAuth
+// @Param Authorization	header string true "Bearer 31a165baebe6dec616b1f8f3207b4273"
+// @Accept  json
+// @Product json
+// @Param Keywords query string false "分类名称关键词"
+// @Success 200 {object} my_chart.MyChartClassifyListResp
+// @failure 400 {string} string "分类列表获取失败"
+// @Router /chart/getChartChassify [get]
+func GetMyChartChassify(c *gin.Context) {
+	userInfo := user.GetInfoByClaims(c)
+	publicCondition := make(map[string]interface{})
+	privateCondition := make(map[string]interface{})
+	reqKeywords := c.DefaultQuery("Keywords", "")
+	if reqKeywords != "" {
+		publicCondition["my_chart_classify_name like"] = "%" + reqKeywords + "%"
+		privateCondition["my_chart_classify_name like"] = "%" + reqKeywords + "%"
+	}
+
+	publicClassify, privateClassify, err := chart.GetUserChartClassifyListByCondition(userInfo, publicCondition, privateCondition)
+	if err != nil {
+		response.Fail("获取图表分类失败, Err:" + err.Error(), c)
+		return
+	}
+
+	respData := &my_chart.MyChartClassifyListResp {
+		PublicClassify: publicClassify,
+		PrivateClassify: privateClassify,
+	}
+	response.OkData("获取成功", respData, c)
+}
+
+
+// GetMyChartChassify 获取图表分类列表
+// @Tags 图库模块
+// @Summary  获取图表分类
+// @Description 获取图表分类列表
+// @Security ApiKeyAuth
+// @Param Authorization	header string true "Bearer 31a165baebe6dec616b1f8f3207b4273"
+// @Accept  json
+// @Product json
+// @Param Keywords query string false "图表名称关键词"
+// @Param Page query int false "当前页页码，从1开始"
+// @Param Limit query int false "每页数据量"
+// @Success 200 {object} []my_chart.MyChartList
+// @failure 400 {string} string "图库列表获取失败"
+// @Router /chart/getChartList [get]
+func GetMyChartList(c *gin.Context) {
+	userInfo := user.GetInfoByClaims(c)
+
+	// 获取图表分类IDs
+	publicCondition := make(map[string]interface{})
+	privateCondition := make(map[string]interface{})
+	publicClassify, privateClassify, err := chart.GetUserChartClassifyListByCondition(userInfo, publicCondition, privateCondition)
+	if err != nil {
+		response.Fail("获取图标信息失败, Err:" + err.Error(), c)
+		return
+	}
+
+	var condition string
+	var pars []interface{}
+	// 图表分类
+	classifyIdsSlice := make([]string, 0)
+	for i := 0; i < len(publicClassify); i++ {
+		classifyIdsSlice = append(classifyIdsSlice, strconv.Itoa(publicClassify[i].MyChartClassifyID))
+	}
+	for i := 0; i < len(privateClassify); i++ {
+		classifyIdsSlice = append(classifyIdsSlice, strconv.Itoa(privateClassify[i].MyChartClassifyID))
+	}
+	classifyIdsStr := strings.Join(classifyIdsSlice, ",")
+	condition += " AND d.my_chart_classify_id IN (?)"
+	pars = append(pars, classifyIdsStr)
+	// 关键词
+	reqKeywords := c.DefaultQuery("Keywords", "")
+	if reqKeywords != "" {
+		condition += " AND b.chart_name LIKE ?"
+		pars = append(pars, "%" + reqKeywords + "%")
+	}
+	page, _ := strconv.Atoi(c.Query("Page"))
+	limit, _ := strconv.Atoi(c.Query("Limit"))
+	if page == 0 {
+		page = 1
+	}
+	if limit == 0 {
+		limit = 10
+	}
+
+	list, err := my_chart2.GetMyChartListByCondition(condition, pars, page, limit)
+	if err != nil {
+		response.Fail("获取图库列表失败, Err:" + err.Error(), c)
+		return
+	}
+
+	response.OkData("获取成功", list, c)
+}
+
+
+// GetChartInfo 获取图表详情
+func GetChartInfo(c *gin.Context)  {
+
+}

init_serve/router.go

@@ -31,15 +31,18 @@ func InitRouter() (r *gin.Engine) {
 		})
 	})
 	routers.InitTest(r)
-	//微信相关路由
+	// 微信相关路由
 	routers.InitWechat(r)
 	// 活动相关路由
 	routers.InitActivity(r)
-	//用户接口
+	// 用户接口
 	routers.InitUser(r)
-	//公共接口
+	// 公共接口
 	routers.InitPublic(r)
-	//报告接口
+	// 报告接口
 	routers.InitResearchReport(r)
+	// 图库相关路由
+	routers.InitChart(r)
+
 	return
 }

logic/user/user.go

@@ -107,6 +107,8 @@ type Detail struct {
 	SellerName     string              `json:"seal_name" description:"所属销售名称"`
 	SellerMobile   string              `json:"seal_mobile" description:"所属销售手机号"`
 	PermissionList []CompanyPermission `json:"permission_list" description:"权限列表"`
+	IsInner		   int				   `json:"is_inner" description:"是否为内部员工"`
+	AdminInfo      *admin2.Admin	   `json:"admin_info" description:"系统管理员信息"`
 }
 
 // GetUserInfo 获取用户我的页面详情数据
@@ -191,18 +193,32 @@ func GetUserInfo(userInfo user.UserInfo) (userDetail Detail, err error, errMsg s
 		}
 
 	}
-	//if Note
+	// 是否为内部员工
+	isInner := 0
+	ok, adminInfo, err := user.GetAdminByUserInfo(userInfo)
+	if err != nil {
+		err = errors.New("获取用户系统管理员信息失败")
+		errMsg = "系统异常"
+		return
+	}
+	if ok == true {
+		isInner = 1
+	}
+
 	userDetail = Detail{
-		CompanyName:    companyName, //客户名称（公司名称）
-		Status:         status,      //产品状态
-		IsSuspend:      isSuspend,   //是否启用
+		CompanyName:    companyName, 		//客户名称（公司名称）
+		Status:         status,      		//产品状态
+		IsSuspend:      isSuspend,   		//是否启用
 		RealName:       userInfo.RealName,
 		Mobile:         userInfo.Mobile,
 		Email:          userInfo.Email,
 		SellerName:     sellerName,
 		SellerMobile:   sellerMobile,
-		PermissionList: list, //权限列表
+		PermissionList: list,				//权限列表
+		IsInner: 		isInner,			// 是否为内部员工
+		AdminInfo: 		adminInfo,			// 系统管理员信息
 	}
+
 	return
 }
 

middleware/check_activity_auth.go

@@ -0,0 +1 @@
+package middleware

middleware/check_chart_auth.go

@@ -0,0 +1,31 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/response"
+	"hongze/hongze_yb/services/company"
+	"hongze/hongze_yb/services/user"
+)
+
+// CheckChartAuth 图库权限验证
+func CheckChartAuth() gin.HandlerFunc {
+
+	return func(c *gin.Context) {
+
+		userInfo := user.GetInfoByClaims(c)
+
+		ok, permissionCheckInfo, err := company.CheckUserChartPermission(userInfo.CompanyID, int(userInfo.UserID))
+		if err != nil {
+			response.Fail("图库权限验证失败", c)
+			c.Abort()
+			return
+		}
+		if !ok {
+			response.AuthError(permissionCheckInfo, "暂无权限", c)
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}

models/response/my_chart/my_chart.go

@@ -0,0 +1,8 @@
+package my_chart
+
+import "hongze/hongze_yb/models/tables/my_chart_classify"
+
+type MyChartClassifyListResp struct {
+	PublicClassify	[]*my_chart_classify.MyChartClassify	`description:"公共图库" json:"public_classify"`
+	PrivateClassify	[]*my_chart_classify.MyChartClassify	`description:"我的图库" json:"private_classify"`
+}

models/tables/admin/query.go

@@ -9,3 +9,9 @@ func GetByAdminId(adminId int) (item *Admin, err error) {
 	err = global.DEFAULT_MYSQL.Where("admin_id =  ? ", adminId).First(&item).Error
 	return
 }
+
+// GetAdminByMobile 通过手机号获取系统用户信息
+func GetAdminByMobile(mobile string) (item *Admin, err error) {
+	err = global.DEFAULT_MYSQL.Model(Admin{}).Where("mobile = ?", mobile).First(&item).Error
+	return
+}

models/tables/company_user_chart_classify_permission/company_user_chart_classify_permission.go

@@ -0,0 +1,44 @@
+package company_user_chart_classify_permission
+
+import (
+	"time"
+)
+
+// CompanyUserChartClassifyPermission 客户联系人-图表分类权限表
+type CompanyUserChartClassifyPermission struct {
+	ID            uint32    `gorm:"primaryKey;column:id;type:int(10) unsigned;not null" json:"-"`                            // 主键ID
+	UserID        uint32    `gorm:"index:idx_user_id;column:user_id;type:int(10) unsigned;not null;default:0" json:"userId"` // 用户ID
+	ChartClassify string    `gorm:"column:chart_classify;type:varchar(255);not null;default:''" json:"chartClassify"`        // 图表分类权限-逗号分隔
+	StartTime     time.Time `gorm:"column:start_time;type:datetime" json:"startTime"`                                        // 起始时间
+	EndTime       time.Time `gorm:"column:end_time;type:datetime" json:"endTime"`                                            // 终止时间
+	Enabled       uint8     `gorm:"column:enabled;type:tinyint(4) unsigned;not null;default:1" json:"enabled"`               // 使用状态 1-开启 0-关闭
+	CreateTime    time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                      // 创建时间
+	UpdateTime    time.Time `gorm:"column:update_time;type:datetime" json:"updateTime"`                                      // 更新时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *CompanyUserChartClassifyPermission) TableName() string {
+	return "company_user_chart_classify_permission"
+}
+
+// CompanyUserChartClassifyPermissionColumns get sql column name.获取数据库列名
+var CompanyUserChartClassifyPermissionColumns = struct {
+	ID            string
+	UserID        string
+	ChartClassify string
+	StartTime     string
+	EndTime       string
+	Enabled       string
+	CreateTime    string
+	UpdateTime    string
+}{
+	ID:            "id",
+	UserID:        "user_id",
+	ChartClassify: "chart_classify",
+	StartTime:     "start_time",
+	EndTime:       "end_time",
+	Enabled:       "enabled",
+	CreateTime:    "create_time",
+	UpdateTime:    "update_time",
+}
+

models/tables/company_user_chart_classify_permission/query.go

@@ -0,0 +1,9 @@
+package company_user_chart_classify_permission
+
+import "hongze/hongze_yb/global"
+
+// GetPermissionByUserId 获取用户图库分类权限信息
+func GetPermissionByUserId(userId int) (item *CompanyUserChartClassifyPermission, err error) {
+	err = global.DEFAULT_MYSQL.Model(CompanyUserChartClassifyPermission{}).Where("user_id", userId).First(&item).Error
+	return
+}

models/tables/my_chart/my_chart.go

@@ -0,0 +1,34 @@
+package my_chart
+
+import (
+	"time"
+)
+
+// MyChart 我的图表
+type MyChart struct {
+	MyChartID   int       `gorm:"primaryKey;column:my_chart_id;type:int(11);not null" json:"-"`
+	ChartInfoID int       `gorm:"column:chart_info_id;type:int(11)" json:"chartInfoId"`
+	AdminID     int       `gorm:"column:admin_id;type:int(11)" json:"adminId"`
+	CreateTime  time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	ModifyTime  time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *MyChart) TableName() string {
+	return "my_chart"
+}
+
+// MyChartColumns get sql column name.获取数据库列名
+var MyChartColumns = struct {
+	MyChartID   string
+	ChartInfoID string
+	AdminID     string
+	CreateTime  string
+	ModifyTime  string
+}{
+	MyChartID:   "my_chart_id",
+	ChartInfoID: "chart_info_id",
+	AdminID:     "admin_id",
+	CreateTime:  "create_time",
+	ModifyTime:  "modify_time",
+}

models/tables/my_chart/query.go

@@ -0,0 +1,51 @@
+package my_chart
+
+import (
+	"hongze/hongze_yb/global"
+	"time"
+)
+
+type MyChartList struct {
+	MyChartId           int		`description:"我的图表主键"`
+	ChartInfoId         int
+	ChartName           string	`description:"来源名称"`
+	ChartClassifyId     int		`description:"图表分类id"`
+	SysUserId           int
+	SysUserRealName     string
+	UniqueCode          string	`description:"图表唯一编码"`
+	CreateTime          time.Time
+	ModifyTime          time.Time
+	DateType            int		`description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
+	StartDate           string	`description:"自定义开始日期"`
+	EndDate             string	`description:"自定义结束日期"`
+	IsSetName           int		`description:"设置名称"`
+	EdbInfoIds          string	`description:"指标id"`
+	ChartType           int		`description:"生成样式:1:曲线图,2:季节性图"`
+	Calendar            string	`description:"公历/农历"`
+	SeasonStartDate     string	`description:"季节性图开始日期"`
+	SeasonEndDate       string	`description:"季节性图开始日期"`
+	ChartImage          string	`description:"图表图片"`
+	Sort                int		`description:"排序字段，数字越小越排前面"`
+	IsAdd               bool	`description:"true:已加入我的图库,false:未加入我的图库"`
+	MyChartClassifyName string	`description:"分类名称，多个用英文逗号分割"`
+	MyChartClassifyId   string	`description:"分类id，多个用英文逗号分割"`
+	EdbEndDate          string	`description:"指标最新更新日期"`
+}
+
+// GetMyChartListByCondition 条件获取图库列表
+func GetMyChartListByCondition(condition string, pars []interface{}, page, limit int) (list []*MyChartList, err error) {
+	sql := ` SELECT a.my_chart_id,c.sort,b.* FROM my_chart AS a
+			INNER JOIN chart_info AS b ON a.chart_info_id=b.chart_info_id
+			INNER JOIN my_chart_classify_mapping AS c ON a.my_chart_id=c.my_chart_id
+			INNER JOIN my_chart_classify AS d ON c.my_chart_classify_id=d.my_chart_classify_id
+			WHERE 1=1 `
+	if condition != "" {
+		sql += condition
+	}
+	sql += " GROUP BY a.chart_info_id ORDER BY c.sort ASC LIMIT ?,? "
+	offset := (page - 1) * limit
+	pars = append(pars, offset, limit)
+	err = global.MYSQL["data"].Raw(sql, pars).Scan(&list).Error
+
+	return
+}

models/tables/my_chart_classify/my_chart_classify.go

@@ -0,0 +1,46 @@
+package my_chart_classify
+
+
+import (
+	"time"
+)
+
+// MyChartClassify 我的图表分类
+type MyChartClassify struct {
+	MyChartClassifyID   int       `gorm:"primaryKey;column:my_chart_classify_id;type:int(11);not null" json:"-"`
+	MyChartClassifyName string    `gorm:"uniqueIndex:idx_my_chart_classify_name;column:my_chart_classify_name;type:varchar(255);default:''" json:"myChartClassifyName"` // 分类名称
+	AdminID             int       `gorm:"uniqueIndex:idx_my_chart_classify_name;column:admin_id;type:int(11)" json:"adminId"`                                           // 用户id
+	Sort                int       `gorm:"column:sort;type:int(9);default:0" json:"sort"`                                                                                // 排序字段，值越小，越靠前
+	IsPublic            uint8     `gorm:"column:is_public;type:tinyint(4) unsigned;default:0" json:"isPublic"`					// 是否所有人可见，0：仅自己可见，1：所有人可见
+	IsCompanyPublic		uint8     `gorm:"column:is_company_public;type:tinyint(4) unsigned;default:0" json:"isCompanyPublic"`	// 是否用户可见：0-否 1-是
+	CreateTime          time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	ModifyTime          time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`
+	PublicTime          time.Time `gorm:"column:public_time;type:datetime" json:"publicTime"`					// 公开时间
+	CompanyPublicTime	time.Time `gorm:"column:company_public_time;type:datetime" json:"companyPublicTime"`	// 用户可见公开时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *MyChartClassify) TableName() string {
+	return "my_chart_classify"
+}
+
+// MyChartClassifyColumns get sql column name.获取数据库列名
+var MyChartClassifyColumns = struct {
+	MyChartClassifyID   string
+	MyChartClassifyName string
+	AdminID             string
+	Sort                string
+	IsPublic            string
+	CreateTime          string
+	ModifyTime          string
+	PublicTime          string
+}{
+	MyChartClassifyID:   "my_chart_classify_id",
+	MyChartClassifyName: "my_chart_classify_name",
+	AdminID:             "admin_id",
+	Sort:                "sort",
+	IsPublic:            "is_public",
+	CreateTime:          "create_time",
+	ModifyTime:          "modify_time",
+	PublicTime:          "public_time",
+}

models/tables/my_chart_classify/query.go

@@ -0,0 +1,19 @@
+package my_chart_classify
+
+import (
+	"errors"
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/utils"
+)
+
+// GetClassifyListByCondition 根据条件获取图表分类列表
+func GetClassifyListByCondition(condition map[string]interface{}) (list []*MyChartClassify, err error) {
+	maps, values, buildErr := utils.WhereBuild(condition)
+	if buildErr != nil {
+		err = errors.New("系统异常，生成查询语句失败")
+		return
+	}
+	err = global.DEFAULT_MYSQL.Where(maps, values...).Order("sort ASC").Scan(&list).Error
+
+	return
+}

models/tables/my_chart_classify_mapping/my_chart_classify_mapping.go

@@ -0,0 +1,39 @@
+package my_chart_classify_mapping
+
+import "time"
+
+// MyChartClassifyMapping 我的图库及分类关联表
+type MyChartClassifyMapping struct {
+	MyChartClassifyMappingID int       `gorm:"primaryKey;column:my_chart_classify_mapping_id;type:int(11);not null" json:"-"`
+	AdminID                  int       `gorm:"column:admin_id;type:int(11)" json:"adminId"`
+	MyChartID                int       `gorm:"column:my_chart_id;type:int(11)" json:"myChartId"`
+	MyChartClassifyID        int       `gorm:"column:my_chart_classify_id;type:int(11)" json:"myChartClassifyId"`
+	CreateTime               time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	ModifyTime               time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`
+	Sort                     float64   `gorm:"column:sort;type:double;default:0" json:"sort"` // 排序
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *MyChartClassifyMapping) TableName() string {
+	return "my_chart_classify_mapping"
+}
+
+// MyChartClassifyMappingColumns get sql column name.获取数据库列名
+var MyChartClassifyMappingColumns = struct {
+	MyChartClassifyMappingID string
+	AdminID                  string
+	MyChartID                string
+	MyChartClassifyID        string
+	CreateTime               string
+	ModifyTime               string
+	Sort                     string
+}{
+	MyChartClassifyMappingID: "my_chart_classify_mapping_id",
+	AdminID:                  "admin_id",
+	MyChartID:                "my_chart_id",
+	MyChartClassifyID:        "my_chart_classify_id",
+	CreateTime:               "create_time",
+	ModifyTime:               "modify_time",
+	Sort:                     "sort",
+}
+

models/tables/my_chart_log/my_chart_log.go

@@ -0,0 +1,46 @@
+package my_chart_log
+
+import (
+	"time"
+)
+
+// MyChartLog 我的图表操作日志
+type MyChartLog struct {
+	MyChartLogID    int       `gorm:"primaryKey;column:my_chart_log_id;type:int(11);not null" json:"-"`
+	MyChartID       int       `gorm:"index:idx_my_chart_id;column:my_chart_id;type:int(11)" json:"myChartId"`
+	ChartInfoID     int       `gorm:"column:chart_info_id;type:int(11)" json:"chartInfoId"`
+	SysUserID       int       `gorm:"column:sys_user_id;type:int(11)" json:"sysUserId"`
+	CreateTime      time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`
+	SysUserRealName string    `gorm:"column:sys_user_real_name;type:varchar(50);default:''" json:"sysUserRealName"`
+	Content         string    `gorm:"column:content;type:text" json:"content"`
+	Status          string    `gorm:"column:status;type:varchar(50);default:''" json:"status"`
+	Method          string    `gorm:"column:method;type:varchar(255);default:''" json:"method"`
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *MyChartLog) TableName() string {
+	return "my_chart_log"
+}
+
+// MyChartLogColumns get sql column name.获取数据库列名
+var MyChartLogColumns = struct {
+	MyChartLogID    string
+	MyChartID       string
+	ChartInfoID     string
+	SysUserID       string
+	CreateTime      string
+	SysUserRealName string
+	Content         string
+	Status          string
+	Method          string
+}{
+	MyChartLogID:    "my_chart_log_id",
+	MyChartID:       "my_chart_id",
+	ChartInfoID:     "chart_info_id",
+	SysUserID:       "sys_user_id",
+	CreateTime:      "create_time",
+	SysUserRealName: "sys_user_real_name",
+	Content:         "content",
+	Status:          "status",
+	Method:          "method",
+}

routers/chart.go

@@ -0,0 +1,15 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"hongze/hongze_yb/controller/chart"
+	"hongze/hongze_yb/middleware"
+)
+
+func InitChart(r *gin.Engine) {
+	rGroup := r.Group("my_chart").Use(middleware.Token(), middleware.CheckChartAuth())
+	{
+		rGroup.GET("/getChartChassify", chart.GetMyChartChassify)
+		rGroup.GET("/getChartList", chart.GetMyChartList)
+	}
+}

services/chart/my_chart.go

@@ -0,0 +1,40 @@
+package chart
+
+import (
+	"errors"
+	"hongze/hongze_yb/models/tables/my_chart_classify"
+	"hongze/hongze_yb/services/user"
+)
+
+// GetUserChartClassifyListByCondition 获取用户图表分类列表
+func GetUserChartClassifyListByCondition(userInfo user.UserInfo, publicCondition, privateCondition map[string]interface{}) (publicClassify, privateClassify []*my_chart_classify.MyChartClassify, err error) {
+	// 判断是否为内部人员
+	isInner, adminInfo, err := user.GetAdminByUserInfo(userInfo)
+	if err != nil {
+		err = errors.New("用户信息有误, Err:" + err.Error())
+		return
+	}
+
+	if isInner {
+		// 内部人员
+		publicCondition["is_public"] = 1
+		privateCondition["admin_id"] = adminInfo.AdminID
+		privateClassify, err = my_chart_classify.GetClassifyListByCondition(privateCondition)
+		if err != nil {
+			err = errors.New("获取我的图表分类失败, Err:" + err.Error())
+			return
+		}
+	} else {
+		// 用户
+		publicCondition["is_public"] = 1
+		publicCondition["is_company_public"] = 1
+	}
+
+	publicClassify, err = my_chart_classify.GetClassifyListByCondition(publicCondition)
+	if err != nil {
+		err = errors.New("获取公共图表分类失败, Err:" + err.Error())
+		return
+	}
+
+	return
+}

services/company/permission.go

@@ -7,9 +7,11 @@ import (
 	"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/utils"
+	"time"
 )
 
 // GetClassNameListByProductId 根据权限id获取权限分类
@@ -276,3 +278,125 @@ func checkPermissionByPermissionIdList2Rai(companyId int64, permissionIdList []i
 
 	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, 3)	// 图库申请
+			// 查询是否有申请过，如果有申请过的话，那么err是nil
+			if err == nil {
+				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 == "冻结" {
+			permissionCheckInfo.Type = "contact"
+			return
+		}
+		if 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
+		}
+		if nowTime.After(permissionInfo.StartTime) && nowTime.Before(permissionInfo.EndTime) {
+			ok = true
+		} else {
+			// 权限已到期
+			permissionCheckInfo.Type = "expired"
+			return
+		}
+
+		// 都不是默认联系销售
+		permissionCheckInfo.Type = "contact"
+	} else {
+		permissionCheckInfo.Type = "apply"
+	}
+
+	return
+}

services/user/user.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"github.com/gin-gonic/gin"
 	"github.com/silenceper/wechat/v2/miniprogram/auth"
+	admin2 "hongze/hongze_yb/models/tables/admin"
 	"hongze/hongze_yb/models/tables/rddp/session"
 	"hongze/hongze_yb/models/tables/user_record"
 	"hongze/hongze_yb/models/tables/wx_user"
@@ -353,3 +354,23 @@ func GetInfoByClaims(c *gin.Context) (userInfo UserInfo) {
 	userInfo = claims.(UserInfo)
 	return
 }
+
+// GetAdminByUserId 判断当前用户是否为内部人员
+func GetAdminByUserInfo(userInfo UserInfo) (ok bool, adminInfo *admin2.Admin, err error) {
+	mobile := userInfo.Mobile
+	if mobile == "" {
+		err = errors.New("用户手机号信息有误")
+		return
+	}
+	adminInfo, err = admin2.GetAdminByMobile(mobile)
+	if err != nil {
+		if err == utils.ErrNoRow {
+			err = nil
+			return
+		}
+		return
+	}
+	ok = true
+
+	return
+}