feat:迁移很ok

_const/redis_key/user_k/keys.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"git.hilo.cn/hilo-common/resource/mysql"
 	"hilo-user/_const/redis_key"
+	"strconv"
+	"strings"
 )
 
 const (
@@ -28,3 +30,9 @@ func GetExternalIdToUidKey(externalId mysql.Str) string {
 func GetCodeToUidKey(code mysql.Str) string {
 	return redis_key.ReplaceKey(UserCodeToUIdStr, code)
 }
+
+const syncTimHiloLock = "sync_tim_hilo_{userId}"
+
+func GetKeySyncTimHilo(userId uint64) string {
+	return strings.Replace(syncTimHiloLock, "{userId}", strconv.FormatUint(userId, 10), -1)
+}

cv/user_cv/user.go

 package user_cv
 
 import (
+	"git.hilo.cn/hilo-common/_const/common"
 	"git.hilo.cn/hilo-common/domain"
 	"git.hilo.cn/hilo-common/mylogrus"
 	"git.hilo.cn/hilo-common/resource/mysql"
 	"git.hilo.cn/hilo-common/rpc"
 	"gorm.io/gorm"
 	"hilo-user/_const/enum/country_e"
+	"hilo-user/_const/enum/cp_e"
 	"hilo-user/cv/headwear_cv"
 	"hilo-user/cv/medal_cv"
 	"hilo-user/cv/noble_cv"
@@ -102,6 +104,7 @@ type CvUserBase struct {
 	Headwear      *headwear_cv.CvHeadwear `json:"headwear"`  // 当前使用的头饰
 	Ride          property_cv.CvProperty  `json:"ride"`      // 当前使用的座驾
 	Noble         noble_cv.CvNoble        `json:"noble"`     // 当前的
+	GroupRole     common.GroupRoleType    `json:"groupRole"` // 在群组的角色
 }
 
 //批量获取用户基本信息
@@ -157,7 +160,7 @@ func GetUserBases(userIds []mysql.ID, myUserId mysql.ID) ([]*CvUserBase, error)
 		return nil, err
 	}
 
-	superManagerMap, err := GetSuperManagerMap(userIds)
+	superManagerMap, err := user_m.GetSuperManagerMap(userIds)
 	if err != nil {
 		return nil, err
 	}
@@ -310,25 +313,6 @@ func GetPropertyAll(db *gorm.DB) (map[uint64]property_cv.CvProperty, error) {
 	return result, nil
 }
 
-func GetSuperManagerMap(userIds []uint64) (map[uint64]bool, error) {
-	if len(userIds) == 0 {
-		return map[uint64]bool{}, nil
-	}
-	var superManagers []user_m.SuperManager
-	if err := mysql.Db.Model(&user_m.SuperManager{}).Where("user_id in (?)", userIds).Find(&superManagers).Error; err != nil {
-		return nil, myerr.WrapErr(err)
-	}
-	//转换成map
-	rs := map[uint64]bool{}
-	for i, _ := range userIds {
-		rs[userIds[i]] = false
-	}
-	for i, _ := range superManagers {
-		rs[superManagers[i].UserId] = true
-	}
-	return rs, nil
-}
-
 func GetUserBaseMap(userIds []mysql.ID, myUserId mysql.ID) (map[mysql.ID]*CvUserBase, error) {
 	userBases, err := GetUserBases(userIds, myUserId)
 	if err != nil {
@@ -383,29 +367,22 @@ type CvUserDetail struct {
 	//是否可以免费通话，自己本人没有数据
 	//IsVideoFreeCan *bool `json:"isVideoCanFree"`
 	//别人是否喜欢我，自己本人没有数据 (20210205 已废弃nil，产品说：可以自己喜欢自己)
-	IsLikeMe          *bool                `json:"isLikeMe"`
-	HeartValue        uint32               `json:"heartValue"`               // 与我之间永恒之心的值
-	HeartValueMax     uint32               `json:"heartValueMax"`            // 与我之间永恒之心的最大值(0代表没有永恒之心，即没有相互关注)
-	MeetDays          uint                 `json:"meetDays"`                 // 成长关系建立的时间（天数）
-	WealthUserGrade   uint32               `json:"wealthUserGrade"`          //财富等级
-	CharmUserGrade    uint32               `json:"charmUserGrade"`           //魅力等级
-	ActivityUserGrade uint32               `json:"activityUserGrade"`        //活跃等级
-	CurrentRoom       string               `json:"currentRoom"`              // 当前用户所在房间（产品叫“群组”）
-	MyGroupPower      uint64               `json:"myGroupPower"`             // 当前用户所在势力
-	MyGroupPowerName  string               `json:"myGroupPowerName"`         // 当前用户所在势力绑定群组的名称
-	GroupPower        rpc.CvGroupPowerInfo `json:"groupPower"`               // 家族
-	GroupId           string               `json:"groupId"`                  // 当前用户拥有的群组id（产品叫“群组”），如果没有则为空，拥有多个，返回第一个
-	PhoneInfo         *UserPhoneInfo       `json:"phoneInfo"`                // 用户绑定的手机信息
-	ThirdList         []int8               `json:"thirdList"`                // 用户绑定的第三方平台列表；类型 1:phone, 2:google, 3:facebook 4:apple 5：wechat" Enums(1,2,3,4,5)
-	CountryManager    *CVCountryManager    `json:"countryManager,omitempty"` // 国家管理员
-	Cp                *rpc.CvCp            `json:"cp,omitempty"`             // cp信息
-}
-
-type UserPhoneInfo struct {
-	Phone        string `json:"phone"`
-	PhoneCountry string `json:"phoneCountry"`
-	AreaCode     string `json:"areaCode"`
-	Icon         string `json:"icon"`
+	IsLikeMe          *bool                 `json:"isLikeMe"`
+	HeartValue        uint32                `json:"heartValue"`               // 与我之间永恒之心的值
+	HeartValueMax     uint32                `json:"heartValueMax"`            // 与我之间永恒之心的最大值(0代表没有永恒之心，即没有相互关注)
+	MeetDays          uint                  `json:"meetDays"`                 // 成长关系建立的时间（天数）
+	WealthUserGrade   uint32                `json:"wealthUserGrade"`          //财富等级
+	CharmUserGrade    uint32                `json:"charmUserGrade"`           //魅力等级
+	ActivityUserGrade uint32                `json:"activityUserGrade"`        //活跃等级
+	CurrentRoom       string                `json:"currentRoom"`              // 当前用户所在房间（产品叫“群组”）
+	MyGroupPower      uint64                `json:"myGroupPower"`             // 当前用户所在势力
+	MyGroupPowerName  string                `json:"myGroupPowerName"`         // 当前用户所在势力绑定群组的名称
+	GroupPower        rpc.CvGroupPowerInfo  `json:"groupPower"`               // 家族
+	GroupId           string                `json:"groupId"`                  // 当前用户拥有的群组id（产品叫“群组”），如果没有则为空，拥有多个，返回第一个
+	PhoneInfo         *user_m.UserPhoneInfo `json:"phoneInfo"`                // 用户绑定的手机信息
+	ThirdList         []int8                `json:"thirdList"`                // 用户绑定的第三方平台列表；类型 1:phone, 2:google, 3:facebook 4:apple 5：wechat" Enums(1,2,3,4,5)
+	CountryManager    *CVCountryManager     `json:"countryManager,omitempty"` // 国家管理员
+	Cp                *CvCp                 `json:"cp,omitempty"`             // cp信息
 }
 
 // cv国家管理人员
@@ -413,3 +390,32 @@ type CVCountryManager struct {
 	Country string                   `json:"country"`                    // 国家name
 	Role    country_e.CountryMgrRole `json:"role" swaggertype:"integer"` // 角色 1:国家管理员 2:国家助理
 }
+
+// cp信息
+type CvCp struct {
+	CpUserInfo      *CvUserBase   `json:"cpUserInfo"`      // cp用户信息
+	CpLevel         CvCpLevel     `json:"cpLevel"`         // cp等级
+	MyPrivilegeList []CvPrivilege `json:"myPrivilegeList"` // 等级特权
+	CreatedUnix     int64         `json:"createdUnix"`     // cp创建时间
+	CpDays          int           `json:"cpDays"`          // cp天数
+}
+
+// cp关系
+type CvCpRelation struct {
+	CpId         uint64 `json:"cpId"`
+	UserId       uint64 `json:"userId"`
+	CpUserId     uint64 `json:"cpUserId"`
+	CpUserAvatar string `json:"cpUserAvatar,omitempty"`
+}
+
+// cp等级
+type CvCpLevel struct {
+	Level  cp_e.CpLevel `json:"level"`           // 等级 0:无称号 1:恋爱CP 2:甜蜜CP 3:忠诚CP 4:炽热CP 5:荣耀CP
+	Points uint32       `json:"points"`          // CP值
+	Title  string       `json:"title,omitempty"` // 称号翻译
+}
+
+// 特权信息
+type CvPrivilege struct {
+	Type cp_e.CpPrivilege `json:"type"` // 特权id 1:空间 2:横幅 3:等级勋章 4:证书 5:进场特效 6:头像头饰 7:动态资料卡 8:麦位特效
+}

domain/model/country_m/country_mgr.go

+package country_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"gorm.io/gorm"
+	"hilo-user/_const/enum/country_e"
+	"hilo-user/myerr"
+)
+
+type CountryMgrUser struct {
+	mysql.Entity
+	Country string
+	UserId  mysql.ID
+	Role    country_e.CountryMgrRole
+}
+
+// 获取国家管理人员
+func GetCountryMgr(model *domain.Model, userId mysql.ID) (*CountryMgrUser, error) {
+	cmu := new(CountryMgrUser)
+	if err := model.Db.WithContext(model.MyContext.Context).Where("user_id = ?", userId).First(&cmu).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		} else {
+			return nil, myerr.WrapErr(err)
+		}
+	}
+	return cmu, nil
+}
+
+// 更新国家管理人员
+func (cmu *CountryMgrUser) UpdateCountryMgr(userId mysql.ID, role country_e.CountryMgrRole, country string) *CountryMgrUser {
+	cmu.UserId, cmu.Role, cmu.Country = userId, role, country
+	return cmu
+}
+
+// 删除国家管理人员
+func (cmu *CountryMgrUser) DeleteCountryMgr() {
+	cmu.SetDel()
+}

domain/model/groupPower_m/groupPower.go

@@ -17,6 +17,14 @@ type GroupPowerUser struct {
 	Role          groupPower_e.GroupPowerUserRole
 }
 
+type GroupPower struct {
+	mysql.Entity
+	*domain.Model `gorm:"-"`
+	GroupUid      mysql.Str
+	Name          mysql.Str
+	Status        groupPower_e.GroupPowerStatus
+}
+
 // 查询用户加入的国家势力ID及名称（势力绑定的群组的名称）
 func GetUserGroupPower(model *domain.Model, userId uint64) (uint64, string, error) {
 	gpu, err := GetGroupPowerUserOrNil(model, userId)
@@ -65,3 +73,12 @@ func GetGroupPowerUserOrNil(model *domain.Model, userId mysql.ID) (*GroupPowerUs
 	groupPowerUser.Model = model
 	return &groupPowerUser, nil
 }
+
+func GetGroupPowerOrErr(model *domain.Model, id uint64) (*GroupPower, error) {
+	groupPower := GroupPower{}
+	if err := model.Db.Model(&GroupPower{}).First(&groupPower, id).Error; err != nil {
+		return nil, myerr.WrapErr(err)
+	}
+	groupPower.Model = model
+	return &groupPower, nil
+}

domain/model/group_m/groupInfo.go

@@ -51,3 +51,59 @@ func GetGroupInfo(model *domain.Model, groupId string) (*GroupInfo, error) {
 	}
 	return &r, nil
 }
+
+func FindGroupByOwner(model *domain.Model, ownerId uint64) ([]GroupInfo, error) {
+	rows := make([]GroupInfo, 0)
+	err := model.Db.Where(&GroupInfo{Owner: ownerId}).Find(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func ToTxGroupId(model *domain.Model, imGroupId string) (string, error) {
+	if len(imGroupId) <= 0 {
+		return "", nil
+	}
+
+	gi, err := GetGroupInfo(model, imGroupId)
+	if err != nil {
+		return "", err
+	}
+	if gi == nil {
+		return "", bizerr.GroupNotFound
+	}
+	return gi.TxGroupId, nil
+}
+
+func ToImGroupId(model *domain.Model, txGroupId string) (string, error) {
+	if len(txGroupId) <= 0 {
+		return "", nil
+	}
+
+	gi, err := GetInfoByTxGroupId(model, txGroupId)
+	if err != nil {
+		return "", err
+	}
+	if gi == nil {
+		return "", bizerr.GroupNotFound
+	}
+	return gi.ImGroupId, nil
+}
+
+func GetInfoByTxGroupId(model *domain.Model, txGroupId string) (*GroupInfo, error) {
+	if len(txGroupId) <= 0 {
+		return nil, bizerr.GroupNotFound
+	}
+
+	r := GroupInfo{}
+	err := model.Db.Where(&GroupInfo{TxGroupId: txGroupId}).First(&r).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		} else {
+			return nil, err
+		}
+	}
+	return &r, nil
+}

domain/model/group_m/role.go

+package group_m
+
+import (
+	"git.hilo.cn/hilo-common/_const/common"
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"gorm.io/gorm"
+)
+
+type GroupRoles struct {
+	mysql.Entity
+	UserId    uint64
+	ImGroupId string
+	Role      common.GroupRoleType
+}
+
+type GroupMember struct {
+	GroupId string
+	UserId  uint64
+}
+
+func (gm *GroupMember) Find(db *gorm.DB) ([]GroupMember, error) {
+	rows := make([]GroupMember, 0)
+	if err := db.Where(gm).Order("created_time DESC").Find(&rows).Error; err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func GetGroupRoleById(model *domain.Model, imGroupId string, userId uint64) (role common.GroupRoleType, err error) {
+	role = common.GROUP_VISITOR
+	roles, _, err := GetRolesInGroup(model, imGroupId)
+	if err != nil {
+		return
+	}
+	for u, r := range roles {
+		if u == userId {
+			role = r
+			return
+		}
+	}
+
+	isGroupMember, err := IsGroupMember(model.Db, imGroupId, userId)
+	if err != nil {
+		return
+	}
+	if isGroupMember {
+		role = common.GROUP_MEMBER
+	}
+	return
+}
+
+// 查询群组中所有有角色的成员，由级别高到低、创建时间由早到晚排列
+func GetRolesInGroup(model *domain.Model, groupId string) (map[uint64]uint16, []uint64, error) {
+	data := make([]GroupRoles, 0)
+	err := model.Db.Where(&GroupRoles{ImGroupId: groupId}).Order("role DESC, created_time").Find(&data).Error
+	if err != nil {
+		return nil, nil, err
+	}
+
+	result := make(map[uint64]uint16, 0)
+	orders := make([]uint64, 0)
+	for _, i := range data {
+		orders = append(orders, i.UserId)
+		result[i.UserId] = i.Role
+	}
+	return result, orders, nil
+}
+
+func IsGroupMember(db *gorm.DB, groupId string, userId uint64) (bool, error) {
+	gm := GroupMember{
+		GroupId: groupId,
+		UserId:  userId,
+	}
+	rows, err := gm.Find(db)
+	if err != nil {
+		return false, err
+	}
+	return len(rows) > 0, nil
+}

domain/model/tim_m/user.go

+package tim_m
+
+import (
+	"encoding/json"
+	"git.hilo.cn/hilo-common/sdk/tencentyun"
+)
+
+type TimHiloInfo struct {
+	IsVip      bool     `json:"isVip"`
+	IsPretty   bool     `json:"isPretty"`
+	Medals     []uint32 `json:"medals"`
+	PowerName  string   `json:"powerName"` // 用户加入的国家势力的绑定群组的名称
+	NobleLevel uint16   `json:"nobleLevel"`
+}
+
+func FlushHiloInfo(extId string, isVip bool, isPrettyCode bool, medals []uint32, groupPowerName string, nobleLevel uint16) error {
+	info := TimHiloInfo{IsVip: isVip, IsPretty: isPrettyCode, Medals: medals, PowerName: groupPowerName, NobleLevel: nobleLevel}
+	buf, err := json.Marshal(info)
+	if err != nil {
+		return err
+	}
+
+	if err = tencentyun.SetUserHiloInfo(extId, string(buf)); err != nil {
+		return err
+	}
+	return nil
+}

domain/model/user_m/count.go

+package user_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"hilo-user/_const/enum/user_e"
+)
+
+//用户统计
+type UserCount struct {
+	mysql.Entity
+	*domain.Model `gorm:"-"`
+	UserId        mysql.ID
+	Type          user_e.CountType
+	Num           mysql.Num
+	isAdd         bool      `gorm:"-"`
+	isReduce      bool      `gorm:"-"`
+	addReduceNum  mysql.Num `gorm:"-"`
+}

domain/model/user_m/superManager.go

@@ -65,15 +65,21 @@ func GetSuperManagerAll(model *domain.Model) ([]uint64, error) {
 	return userIds, nil
 }
 
-/*
-func GetSuperManagerMap(model *domain.Model) (map[uint64]struct{}, error) {
-	userIds, err := GetSuperManagerAll(model)
-	if err != nil {
-		return nil, err
+func GetSuperManagerMap(userIds []uint64) (map[uint64]bool, error) {
+	if len(userIds) == 0 {
+		return map[uint64]bool{}, nil
+	}
+	var superManagers []SuperManager
+	if err := mysql.Db.Model(&SuperManager{}).Where("user_id in (?)", userIds).Find(&superManagers).Error; err != nil {
+		return nil, myerr.WrapErr(err)
 	}
-	userIdMap := map[uint64]struct{}{}
+	//转换成map
+	rs := map[uint64]bool{}
 	for i, _ := range userIds {
-		userIdMap[userIds[i]] = struct{}{}
+		rs[userIds[i]] = false
 	}
-	return userIdMap, nil
-}*/
+	for i, _ := range superManagers {
+		rs[superManagers[i].UserId] = true
+	}
+	return rs, nil
+}

domain/model/user_m/userBindInfo.go

+package user_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"time"
+)
+
+type UserBindInfo struct {
+	UserId       uint64    `json:"user_id"`
+	Phone        string    `json:"phone"`
+	PhoneCountry string    `json:"phone_country"`
+	Pwd          string    `json:"pwd"`
+	AreaCode     string    `json:"area_code"`
+	Icon         string    `json:"icon"`
+	CreateAt     time.Time `json:"create_at"`
+	UpdateAt     time.Time `json:"update_at"`
+}
+
+func (*UserBindInfo) TableName() string {
+	return "user_bind_info"
+}
+
+type UserPhoneInfo struct {
+	Phone        string `json:"phone"`
+	PhoneCountry string `json:"phoneCountry"`
+	AreaCode     string `json:"areaCode"`
+	Icon         string `json:"icon"`
+}
+
+// 获取用户手机号绑定信息
+func GetUserBindInfoByUserId(model *domain.Model, userId uint64) (*UserBindInfo, error) {
+	res := new(UserBindInfo)
+	err := model.DB().Where(&UserBindInfo{UserId: userId}).First(&res).Error
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}

domain/model/user_m/userOauth.go

+package user_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"gorm.io/gorm"
+	"hilo-user/myerr"
+)
+
+type UserOauth struct {
+	UserId         uint64 `json:"user_id"`
+	ThirdPartyId   string `json:"third_party_id"`
+	ThirdPartyType int8   `json:"third_party_type"`
+}
+
+func (*UserOauth) TableName() string {
+	return "user_oauth"
+}
+
+// 根据id获取第三方登录信息
+func GetUserOauthByUserId(model *domain.Model, userId uint64, thirdType uint8) ([]*UserOauth, error) {
+	res := make([]*UserOauth, 0)
+	db := model.DB().Where(&UserOauth{UserId: userId})
+	if thirdType > 0 {
+		db = db.Where(&UserOauth{ThirdPartyType: int8(thirdType)})
+	}
+	err := db.Find(&res).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		} else {
+			return nil, myerr.WrapErr(err)
+		}
+	}
+	return res, nil
+}

domain/model/user_m/user_trade_union.go

+package user_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"gorm.io/gorm"
+	"hilo-user/myerr"
+)
+
+type UserTradeUnion struct {
+	mysql.Entity
+	*domain.Model     `gorm:"-"`
+	UserId            mysql.ID
+	MatchNotification mysql.OpenClose
+	AgentId           mysql.ID
+	StarchatId        mysql.ID
+	Avatar            string
+}
+
+func GetUserTradeUnion(userId mysql.ID) (*UserTradeUnion, error) {
+	var userTradeUnion UserTradeUnion
+	if err := mysql.Db.Where(UserTradeUnion{
+		UserId: userId,
+	}).First(&userTradeUnion).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		} else {
+			return nil, myerr.WrapErr(err)
+		}
+	}
+	return &userTradeUnion, nil
+}
+
+type AgentMgr struct {
+	mysql.Entity
+	*domain.Model `gorm:"-"`
+	UserId        mysql.ID
+	AgentId       mysql.ID
+}
+
+func IsAgent(userId uint64) bool {
+	data := AgentMgr{}
+	return mysql.Db.Where(&AgentMgr{UserId: userId}).First(&data).Error == nil
+}

domain/model/visit_m/repo.go

+package visit_m
+
+import "hilo-user/domain/model"
+
+func (userVisit *UserVisit) Persistent() error {
+	return model.Persistent(userVisit.Db, userVisit)
+}

domain/model/visit_m/visit.go

+package visit_m
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"hilo-user/myerr"
+)
+
+type UserVisit struct {
+	mysql.Entity
+	*domain.Model `gorm:"-"`
+	UserId        mysql.ID
+	VisitUserId   mysql.ID
+	N             mysql.Num
+}
+
+func GetVisitInstanceOrInit(model *domain.Model, userId mysql.ID, visitUserId mysql.ID) (*UserVisit, error) {
+	var userVisit UserVisit
+	if err := model.Db.Where(&UserVisit{
+		UserId:      userId,
+		VisitUserId: visitUserId,
+	}).FirstOrInit(&userVisit, UserVisit{
+		UserId:      userId,
+		VisitUserId: visitUserId,
+		N:           0,
+	}).Error; err != nil {
+		return nil, myerr.WrapErr(err)
+	}
+	userVisit.Model = model
+	return &userVisit, nil
+}
+
+func (userVisit *UserVisit) UserVisitAdd() *UserVisit {
+	userVisit.N = userVisit.N + 1
+	return userVisit
+}

domain/service/cp_s/cp.go

+package cp_s
+
+import (
+	"git.hilo.cn/hilo-common/domain"
+	"git.hilo.cn/hilo-common/mycontext"
+	"hilo-user/_const/enum/cp_e"
+	"hilo-user/cv/cp_cv"
+	"hilo-user/cv/user_cv"
+	"hilo-user/domain/model/cp_m"
+	"time"
+)
+
+type CpService struct {
+	svc *domain.Service
+}
+
+func NewCpService(myContext *mycontext.MyContext) *CpService {
+	svc := domain.CreateService(myContext)
+	return &CpService{svc}
+}
+
+// 获取用户cp信息
+func (s *CpService) GetUserCp(userId uint64, lang string) (*user_cv.CvCp, error) {
+	var model = domain.CreateModelContext(s.svc.MyContext)
+	cpLevel := cp_e.CpLevel0
+	cpRelation, exists := cp_m.GetCpRelation(model, userId)
+	if !exists {
+		return nil, nil
+	}
+	var myPrivilegeList []user_cv.CvPrivilege
+	level := cp_m.GetCpLevel(model, cpRelation.Id)
+	if level.ExpireAt.Before(time.Now()) {
+		level.ExpireAt = time.Now().AddDate(0, 1, 0)
+	}
+	cpLevel = level.Level
+	cpUserId := cpRelation.UserId2
+	if cpUserId == userId {
+		cpUserId = cpRelation.UserId1
+	}
+	userPrivileges, err := cp_m.MGetUserSvipPrivilege(model, []uint64{userId})
+	if err != nil {
+		return nil, err
+	}
+	privilegeList := cp_cv.CopyCpLevelPrivilegeList(level.Level, "en")
+	for i, v := range privilegeList {
+		if v.CanSwitch {
+			privilegeList[i].UserSwitch = userPrivileges[userId][v.Type]
+		}
+	}
+	// 我的特权,有开关并且打开才返回
+	for _, v := range privilegeList {
+		if !v.CanSwitch {
+			myPrivilegeList = append(myPrivilegeList, user_cv.CvPrivilege{Type: v.Type})
+		} else if v.UserSwitch {
+			myPrivilegeList = append(myPrivilegeList, user_cv.CvPrivilege{Type: v.Type})
+		}
+	}
+	userBases, err := user_cv.GetUserBaseMap([]uint64{cpUserId}, userId)
+	if err != nil {
+		return nil, err
+	}
+	// 返回值
+	title := cp_cv.GetTranslate(237, lang)
+	if msgId, ok := cp_e.CpLevelTitle[level.Level]; ok {
+		title = cp_cv.GetTranslate(msgId, lang)
+	}
+	var oldScore uint32
+	if oldCp, _ := cp_m.GetOldConnectCp(model, cpRelation.UserId1, cpRelation.UserId2); oldCp != nil {
+		oldScore = uint32(oldCp.Score)
+	}
+	response := &user_cv.CvCp{
+		CpUserInfo: userBases[cpUserId],
+		CpLevel: user_cv.CvCpLevel{
+			Level:  cpLevel,
+			Points: oldScore + cp_m.SumCpPoints(model, cpRelation.Id), // 历史分数
+			Title:  title,
+		},
+		MyPrivilegeList: myPrivilegeList,
+		CpDays:          int(time.Now().Sub(cpRelation.CreatedTime).Hours()/24) + 1,
+		CreatedUnix:     cpRelation.CreatedTime.Unix(),
+	}
+	return response, nil
+}

domain/service/user_s/util.go

+package user_s
+
+import (
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"hilo-user/cv/headwear_cv"
+	"hilo-user/cv/medal_cv"
+	"hilo-user/cv/property_cv"
+	"time"
+)
+
+//空字符串转成nil
+func StrNil(msg string) *string {
+	if msg == "" {
+		return nil
+	}
+	return &msg
+}
+
+func TypeToUint8(t *mysql.Type) *uint8 {
+	if *t == 0 {
+		return nil
+	} else {
+		return (*uint8)(t)
+	}
+}
+
+func BirthdayToUint64(birthday *mysql.Timestamp) *uint64 {
+	if *birthday == 0 {
+		return nil
+	}
+	return (*uint64)(birthday)
+}
+
+func NumToUint32(num *mysql.Num) *uint32 {
+	return (*uint32)(num)
+}
+
+func TimeToUint64(t *time.Time) *uint64 {
+	a := uint64(t.Unix())
+	return &a
+}
+
+func StrToString(str *mysql.Str) *string {
+	return (*string)(str)
+}
+
+func IndexToUint16(i *mysql.Index) *uint16 {
+	return (*uint16)(i)
+}
+
+func IdToUint64(id *mysql.ID) *uint64 {
+	return (*uint64)(id)
+}
+
+func IfLogout(logoutTime int64) bool {
+	return logoutTime > 0 && time.Now().Unix() > logoutTime
+}
+func IfLogoutMedals(condition bool, trueVal, falseVal []uint32) []uint32 {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+func IfLogoutMedalInfo(condition bool, trueVal, falseVal []medal_cv.CvMedal) []medal_cv.CvMedal {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+func IfLogoutHeadwear(condition bool, trueVal, falseVal *headwear_cv.CvHeadwear) *headwear_cv.CvHeadwear {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+func IfLogoutRide(condition bool, trueVal, falseVal property_cv.CvProperty) property_cv.CvProperty {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+func IfLogoutStr(condition bool, trueVal, falseVal string) string {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+func IfLogoutNick(condition bool, code string, nick string) string {
+	if condition {
+		return "Hilo No." + code
+	}
+	return nick
+}

route/router.go

@@ -28,7 +28,8 @@ func InitRouter() *gin.Engine {
 	{
 		user.GET("/nameplate", wrapper(user_r.UserNameplate))
 		user.GET("/bag/:resType", wrapper(user_r.UserBag))
-
+		user.GET("/detail", wrapper(user_r.UserDetail))
+		user.GET("/detail/:userExternalId", wrapper(user_r.UserDetailByExternalId))
 	}
 	cp := v2.Group("/cp")
 	{

route/user_r/user.go

@@ -3,9 +3,16 @@ package user_r
 import (
 	"git.hilo.cn/hilo-common/domain"
 	"git.hilo.cn/hilo-common/mycontext"
+	"git.hilo.cn/hilo-common/resource/mysql"
+	"git.hilo.cn/hilo-common/resource/redisCli"
 	"github.com/gin-gonic/gin"
+	"hilo-user/_const/redis_key/user_k"
+	"hilo-user/domain/model/group_m"
+	"hilo-user/domain/model/tim_m"
+	"hilo-user/domain/service/user_s"
 	"hilo-user/req"
 	"hilo-user/resp"
+	"time"
 )
 
 // @Tags 用户
@@ -20,17 +27,82 @@ import (
 // @Router /v1/user/detail [get]
 func UserDetail(c *gin.Context) (*mycontext.MyContext, error) {
 	myContext := mycontext.CreateMyContext(c.Keys)
-	userId, err := req.GetUserId(c)
+	userId, lang, err := req.GetUserIdLang(c, myContext)
 	if err != nil {
 		return myContext, err
 	}
 
+	cvUserDetail, err := user_s.NewUserService(myContext).GetUserDetail(userId, userId, lang)
+	if err != nil {
+		return myContext, err
+	}
+	resp.ResponseOk(c, cvUserDetail)
+	return myContext, nil
+}
+
+// @Tags 用户
+// @Summary 获取用户详细信息
+// @Param token header string true "token"
+// @Param timestamp header string true "时间戳"
+// @Param nonce header string true "随机数字"
+// @Param signature header string true "sha1加密结果"
+// @Param deviceType header string true "系统类型 ios android"
+// @Param deviceVersion header string true "系统版本"
+// @Param userExternalId path string true "userExternalId"
+// @Param groupId query string false "群组id，当传了该id，则返回该用户在该群组的身份"
+// @Success 200 {object} user_cv.CvUserDetail
+// @Router /v1/user/detail/{userExternalId} [get]
+func UserDetailByExternalId(c *gin.Context) (*mycontext.MyContext, error) {
+	myContext := mycontext.CreateMyContext(c.Keys)
+	userId, lang, err := req.GetUserIdLang(c, myContext)
+	if err != nil {
+		return myContext, err
+	}
+	otherUserId, err := req.ToUserId(myContext, mysql.Str(c.Param("userExternalId")))
+	if err != nil {
+		return nil, err
+	}
 	model := domain.CreateModelContext(myContext)
 
-	cvUserDetail, err := cv.GetUserDetail(model, userId, userId)
+	imGroupId := c.Query("groupId")
+	if imGroupId != "" {
+		imGroupId, err = group_m.ToImGroupId(model, imGroupId)
+		if err != nil {
+			return myContext, err
+		}
+	}
+
+	cvUserDetail, err := user_s.NewUserService(myContext).GetUserDetail(otherUserId, userId, lang)
 	if err != nil {
 		return myContext, err
 	}
+	if imGroupId != "" {
+		cvUserDetail.GroupRole, err = group_m.GetGroupRoleById(model, imGroupId, otherUserId)
+		if err != nil {
+			return myContext, err
+		}
+	}
+
+	if cvUserDetail != nil {
+		// 检查是否需要同步
+		if n, err := redisCli.GetRedis().Exists(model, user_k.GetKeySyncTimHilo(userId)).Result(); err == nil {
+			if n == 0 {
+				// FIXME：转异步执行
+				err = tim_m.FlushHiloInfo(*cvUserDetail.ExternalId, cvUserDetail.IsVip, cvUserDetail.IsPrettyCode,
+					nil, cvUserDetail.MyGroupPowerName, cvUserDetail.Noble.Level)
+				if err == nil {
+					redisCli.GetRedis().Set(model, user_k.GetKeySyncTimHilo(userId), "1", time.Minute)
+				} else {
+					model.Log.Info("UserBaseByExternalId, FlushHiloInfo failed: ", err)
+				}
+			} else {
+				model.Log.Info("UserDetailByExternalId, no need to sync yet: ", userId)
+			}
+		} else {
+			model.Log.Info("UserDetailByExternalId, check KeySyncTimHilo failed", err)
+		}
+	}
+
 	resp.ResponseOk(c, cvUserDetail)
 	return myContext, nil
 }