minghui/mh_goadmin_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4124d8862a
mh_goadmin_server/app/admin/models/user.go

2525 lines
79 KiB
Go
Raw Normal View History

fix:
2023-09-16 02:56:39 +00:00
package models
import (
"encoding/csv"
"errors"
"fmt"
"github.com/gin-gonic/gin"
"github.com/xuri/excelize/v2"
"go-admin/app/admin/apis/pay"
utils "go-admin/app/admin/models/tools"
orm "go-admin/common/global"
"go-admin/logger"
"go-admin/pkg/jwtauth"
"go-admin/tools/app"
"log"
"net/http"
"os"
"sort"
"time"
)
// gen:qs
//
//go:generate goqueryset -in user.go
type UserInfo struct {
Model
1.增加零售订单相关接口； 2.增加查询会员手机号接口； 3.修改库存导入串码规则； 4.查询库存详情增加出参求和字段； 5.日志初始化位置调整；
2023-12-19 10:21:44 +00:00
Uid uint32 `json:"uid" gorm:"column:uid;unique_index"` //
MemberLevel uint32 `json:"memberLevel"` // 会员等级 1-会员
MemberExpire time.Time `json:"memberExpire"` // 会员到期时间
OpenMemberTime time.Time `json:"open_member_time"` // 开通会员
Bond uint32 `json:"bond"` // 保证金
WxName string `json:"wxName"` // 昵称
WxAvatar string `json:"wxAvatar"` // 头像
WxOpenID string `json:"wxOpenID"` // 微信openid
AppOpenID string `json:"appOpenID"` //
WxUnionID string `json:"wxUnionID"` // 微信unionId
Tel string `json:"tel"` // 电话
Gender uint8 `json:"gender"` // 性别
City string `json:"city"` // 城市
Province string `json:"province"` // 省
Country string `json:"country"` // 市
Deposit uint32 `json:"deposit"` // 押金
UserType uint8 `json:"user_type"` // 用户类型 1-普通用户 2-店员
XcxRoleId uint32 `json:"xcx_role_id"` // 角色id
OpenMemberChannel string `json:"open_member_channel" ` // 开通会员渠道: -门店推广 -用户邀请 -兑换码
StoreId uint64 `json:"store_id"` // 门店id
InviteCodeUrl string `json:"invite_code_url"` // 分享二维码
MemberOpenTime time.Time `json:"member_open_time" gorm:"-"` //
LastLoginAt time.Time `json:"last_login_at"` // 最近登录时间
IP string `json:"-" gorm:"type:varchar(60)"` // ip
InBlack bool `json:"in_black"` // 是否在黑名单
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
CooperativeName string `json:"cooperative_name"` // 合作商名称
Version uint32 `json:"-"` //
MemberStatus uint8 `json:"member_status" gorm:"-"` //
InviteTime time.Time `json:"invite_time"` //
ShopAssistantName string `json:"shop_assistant_name"` // 店员名称
RenewalTime time.Time `json:"renewal_time"` //
RenewalMemberLevel uint32 `json:"renewal_member_level"` //
Mark int8 `json:"mark"` // 标记
FirstRetailOrder time.Time `json:"first_retail_order"` //
MemberLevelString string `json:"member_level_string" gorm:"-"` // 会员类型
Store *Store `json:"store" gorm:"-"` //
OrderCards []OrderCard `json:"order_cards" gorm:"foreignKey:uid;references:uid"` //
ForfeitPenalty int `json:"forfeit_penalty" gorm:"-"` // 滞纳金
fix:
2023-09-16 02:56:39 +00:00
}
func (m *UserInfo) TableName() string {
return "user"
}
const (
UserTypeConsumer = 1 // 普通用户
UserTypeShopAssistant = 2 // 店员
)
标记用户
2023-09-26 05:56:34 +00:00
const (
UNMARK = iota
MARK
)
fix:
2023-09-16 02:56:39 +00:00
const (
OpenMemberChannelStorePromotion = "store_promotion" // 门店推荐
OpenMemberChannelUserInvite = "user_invite"
OpenMemberChannelRedeemCode = "redeem_code"
)
const DateTimeFormat = "2006-01-02"
1、优化库存导入接口；2、库存模块增加添加备注接口 3、商品列表和详情接口入参增加是否串码的字段is_imei；4、优化提示语
2023-11-24 09:09:24 +00:00
const TimeFormat = "2006-01-02 15-04-05"
1.收付款方式设置调整，银行名称和账号改为非必填； 2.收付款方式默认配置的type为0，新增的type为1； 3.商品分类调整，如果父类被隐藏或显示，其子类也做对应修改； 4.新增商品资料入参调整，串码类型改为非必填； 5.新增商品资料调整，相同名称商品不允许新建； 6.零售订单审核优化，记录审核时间； 7.零售订单付款接口优化； 8.新增零售订单付款状态查询接口； 9.日志部分init时进行设置，避免test报错； 10.QueryTimeFormat格式调整，跟前端保持一致； 11.新增河马付相关密钥文件；
2023-12-21 09:36:13 +00:00
const QueryTimeFormat = "2006-01-02T15:04:05+08:00"
fix:
2023-09-16 02:56:39 +00:00
const (
ExportUrl = "https://dev.admin.deovo.com/load/export/"
)
type UserInvite struct {
Model
FromUid uint32 `json:"from_uid"` // 邀请用户id
UserType uint8 `json:"user_type"` // 用户类型
StoreId uint64 `json:"store_id"` // 门店id
MemberOpenTime time.Time `json:"member_open_time"` // 开通会员
MemberType uint8 `json:"member_type"` // 被邀请用户 1-普通用户 2-会员
MemberStatus uint8 `json:"member_status"` // 被邀请用户 1-未开通 2-已开通 3-已取消会员
ToUid uint32 `json:"to_uid"` // 被邀请用户
StoreType uint32 `json:"store_type"` // 门店类型
Action uint32 `json:"action"` // 2-激活邀请
SpendType uint32 `json:"spend_type"` // 1-开通会员 2-续费 3-升级
MemberLevel uint32 `json:"member_level"` // 会员等级
}
func (m *UserInvite) TableName() string {
return "user_invite"
}
const (
DepositRefundStatusUnconfirmed = 1 // 待确认
DepositRefundStatusConfirmed = 2 // 已确认
DepositRefundStatusRefunded = 3 // 已退款
DepositRefundStatusRefused = 4 // 已拒绝
)
// gen:qs
type DepositRefundRecord struct {
Model
Uid uint32 `json:"uid"`
Status uint32 `json:"status"` // unconfirmed confirmed refunded
Amount uint32 `json:"amount"`
Operator uint32 `json:"operator"` // 操作者
ConfirmTime time.Time `json:"confirm_time"`
User User `json:"user" gorm:"-"`
}
const (
//FundTypeMemberGold = "member_gold" // 黄金会员
//FundTypeMemberPlatinum = "member_platinum" // 白金会员
//FundTypeMemberBlackGold = "member_black_gold" // 黑金会员
//FundTypeMemberGoldDeposit = "member_gold_deposit" // 黄金会员押金
//FundTypeMemberPlatinumDeposit = "member_platinum_deposit" // 白金会员押金
//FundTypeMemberBlackGoldDeposit = "member_black_gold_platinum" // 黑金会员押金
//FundTypeExpressFee = "express_fee" // 邮费
//FundTypeUpgradeMember = "upgrade_member" // 升级会员
//FundTypeMemberExpireDelay = "member_expire_delay" // 滞纳金
FundTypeMemberFee = "member_fee" // 会员费
FundTypeMemberDeposit = "member_deposit" // 押金
FundTypeExpressFee = "express_fee" // 邮费
FundTypeUpgradeMember = "upgrade_member" // 升级会员
FundTypeMemberExpireDelay = "member_expire_delay" // 滞纳金
FundTypeDepositRefund = "deposit_refund" // 退押金
FundTypeExpressFeeRefund = "express_fee_refund" // 退邮费
FundTypeRecycleCard = "recycle_card" // 回收卡带
)
// gen:qs
type FundRecord struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
FundType string `json:"fund_type" gorm:"index"` // -member_gold -member_platinum -member_black_gold
Amount int64 `json:"amount"`
TransactionId string `json:"transaction_id" gorm:"index"` // 支付单号
OutTradeNo string `json:"out_trade_no" gorm:"index"`
RefundId string `json:"refund_id" gorm:"index"`
PaymentNo string `json:"payment_no" gorm:"index"` // 付款单号
Status uint32 `json:"status"` // 1-待支付 2-已支付 3-已退款
Remark string `json:"remark"` // 备注
// fund_record
}
type XcxRole struct {
Model
RoleName string `json:"role_name" gorm:"size:255;"` // 角色名称
RoleKey string `json:"role_key" gorm:"size:255;"` // 角色代码
RoleSort int `json:"role_sort" gorm:""` // 角色排序
Status string `json:"status" gorm:"size:255;"` // 状态:1-停用 2-正常
Flag string `json:"flag" gorm:"size:255;"` //
CreateBy string `json:"create_by" gorm:"size:255;"` //
UpdateBy string `json:"update_by" gorm:"size:255;"` //
Remark string `json:"remark" gorm:"size:255;"` // 备注
Params string `json:"params" gorm:"-"`
MenuIds []int `json:"menuIds" gorm:"-"`
DeptIds []int `json:"deptIds" gorm:"-"`
// xcx_role
}
const (
OperationTypeRentCardRevert = "rent_card_revert"
OperationTypeRentCardDeliver = "rent_card_deliver"
OperationTypeMallOrderRefundSendReceive = "mall_goods_order_refund_receive" // 退货入库
)
// gen:qs
type OperationLog struct {
Model
Uid uint32 `json:"uid" gorm:"index"` // 店员id
SysUid uint32 `json:"sys_uid" gorm:"index"`
Description string `json:"description"` // 描述
OperationType string `json:"operation_type" gorm:"index"` // 操作类型
CorrelationId uint32 `json:"correlation_id" gorm:"index"` // 关联id
CorrelationName string `json:"correlation_name" gorm:"index"` // 关联name
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
StoreName string `json:"store_name"` // 门店名称
CooperativeName string `json:"cooperative_name"` // 合作商名称
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
SerialNumber string `json:"serial_number" gorm:"index"` // 卡编号
Detail string `json:"detail"` // 详情
Remark string `json:"remark"` // 备注
}
用户列表新增字段 - 滞纳金 - 过期天数 - 未归还卡带信息
2023-09-26 02:51:58 +00:00
type U struct {
UserInfo
MemberExpireDays uint32 `json:"member_expire_days"` //会员过期天数
}
过滤无滞纳金已标记用户
2023-09-26 09:57:18 +00:00
func GetUserList(page, pageSize, uid, memberLevel, storeId, userType, cooperativeBusinessId int, tel, startTime, endTime, nameKey, sortFiled, sortType string, filter bool) ([]U, uint32, uint32, error) {
fix:
2023-09-16 02:56:39 +00:00
var (
用户列表新增字段 - 滞纳金 - 过期天数 - 未归还卡带信息
2023-09-26 02:51:58 +00:00
users = make([]U, 0)
fix:
2023-09-16 02:56:39 +00:00
totalPage uint32
)
fmt.Println("tel:", tel)
fmt.Println("nameKey:", nameKey)
page -= 1
if page < 0 {
page = 0
}
用户列表新增字段 - 滞纳金 - 过期天数 - 未归还卡带信息
2023-09-26 02:51:58 +00:00
if sortFiled == "" {
sortFiled = "id"
}
if sortType == "" {
sortType = "DESC"
}
fix:
2023-09-16 02:56:39 +00:00
user := &UserInfo{}
qs := orm.Eloquent.Table(user.TableName()).Debug()
if tel != "" {
qs = qs.Where("tel", tel)
}
if uid != 0 {
qs = qs.Where("uid", uid)
}
if memberLevel != 0 {
qs = qs.Where("member_level", memberLevel)
}
if storeId != 0 {
qs = qs.Where("store_id", storeId)
}
if userType != 0 {
qs = qs.Where("user_type", userType)
}
if cooperativeBusinessId != 0 {
qs = qs.Where("cooperative_business_id=?", cooperativeBusinessId)
}
if startTime != "" {
parse, err := time.Parse(DateTimeFormat, startTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, 0, err
}
qs = qs.Where("created_at > ?", parse)
}
if endTime != "" {
parse, err := time.Parse(DateTimeFormat, endTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, 0, err
}
qs = qs.Where("created_at < ?", parse)
}
if nameKey != "" {
qs = qs.Where("wx_name LIKE ?", "%"+nameKey+"%")
}
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, 0, err
}
用户列表新增字段 - 滞纳金 - 过期天数 - 未归还卡带信息
2023-09-26 02:51:58 +00:00
currentTime := time.Now()
//计算过期天数
qs = qs.Select("*, CASE WHEN (member_level IN (2, 4, 5) AND member_expire < ?) THEN DATEDIFF(?,member_expire) ELSE 0 END AS member_expire_days", currentTime, currentTime)
过滤无滞纳金已标记用户
2023-09-26 09:57:18 +00:00
if filter {
qs = orm.Eloquent.Table("(?) as a", qs)
//qs = qs.Preload("OrderCards", func(db *gorm.DB) *gorm.DB {
// return db.Where("pay_status = ? AND card_status IN (?)", 2, []int{1, 2, 3}).
// Group("uid").
// Having("count(uid) > 0")
//})
qs = qs.Select("a.*").
Joins("inner join order_card as oc on a.uid=oc.uid").
Where("pay_status = ? AND card_status IN (?)", 2, []int{1, 2, 3}).
Group("oc.uid").
Having("count(oc.uid) > 0")
qs = qs.Where("member_expire_days > 0").Where("mark = ?", UNMARK)
}
用户列表新增字段 - 滞纳金 - 过期天数 - 未归还卡带信息
2023-09-26 02:51:58 +00:00
err = qs.Order(fmt.Sprintf("%s %s", sortFiled, sortType)).Offset(page * pageSize).Limit(pageSize).Find(&users).Error
fix:
2023-09-16 02:56:39 +00:00
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, 0, err
}
totalPage = uint32(int(count)/pageSize + 1)
return users, totalPage, uint32(count), nil
}
type CommonProblem struct {
Model
Question string `json:"question"`
Answer string `json:"answer" gorm:"type:text"`
Sort uint32 `json:"sort" gorm:"index"`
}
func (*CommonProblem) TableName() string {
return "common_problem"
}
type GroupSendMessageTemplate struct {
Model
Title string `json:"title" `
Message string `json:"message"`
UserType uint32 `json:"user_type" gorm:"index,column:user_type"` // 1-所有用户 2-会员 3-非会员 4-指定用户
SendTime time.Time `json:"send_time"`
Tels string `json:"tels"`
Status uint32 `json:"status"` // 1-待发送 2-已发送
}
func (*GroupSendMessageTemplate) TableName() string {
return "group_send_message_template"
}
type ExpireMemberSmsSend struct {
Model
Message string `json:"message"`
SendTime time.Time `json:"send_time"`
Tel string `json:"tel" gorm:"index"`
Status uint32 `json:"status"` // 1-发送成功 2-发送失败
}
func GetUserInfoMap(uids []uint32) (map[uint32]UserInfo, error) {
userInfoMap := make(map[uint32]UserInfo, 0)
if len(uids) == 0 {
return userInfoMap, nil
}
var userInfos []UserInfo
err := orm.Eloquent.Table("user").Where("uid in (?)", uids).Find(&userInfos).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return userInfoMap, err
}
for i, _ := range userInfos {
userInfoMap[userInfos[i].Uid] = userInfos[i]
}
return userInfoMap, nil
}
func (m *CommonProblem) List() ([]CommonProblem, error) {
commons := make([]CommonProblem, 0)
err := orm.Eloquent.Table("common_problem").Order("sort desc").Find(&commons).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return commons, err
}
return commons, nil
}
func (m *CommonProblem) Add() error {
err := orm.Eloquent.Table("common_problem").Create(m).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
func (m *CommonProblem) Modify() error {
err := orm.Eloquent.Table("common_problem").Save(m).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
func (m *CommonProblem) Del() error {
err := orm.Eloquent.Table("common_problem").Where("id", m.ID).Delete(m).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
type UserAddress struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
ReceiverName string `json:"receiver_name"`
Tel string `json:"tel" gorm:"type:varchar(20)"`
Province string `json:"province" gorm:"type:varchar(100)"`
City string `json:"city" gorm:"type:varchar(100)"`
District string `json:"district" gorm:"type:varchar(100)"`
Address string `json:"address" gorm:"type:varchar(100)"`
State uint8 `json:"state"`
IsDefault uint8 `json:"is_default"`
}
func (m *UserAddress) TableName() string {
return `user_address`
}
// gen:qs
type InviteMemberReport struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
GoldCount uint32 `json:"gold_count"` // 黄金数量
PlatinumCount uint32 `json:"platinum_count"` // 白金数量
BlackGoldCount uint32 `json:"black_gold_count"` // 黑金数量
Date string `json:"date" gorm:"index"` // 业绩时间
DeductAmount uint32 `json:"deduct_amount"` // 店员提成
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
CooperativeName string `json:"cooperative_name"` // 合作商名称
GoldDeduct uint32 `json:"gold_deduct"` // 黄金会员提成
PlatinumDeduct uint32 `json:"platinum_deduct"` // 白金会员提成
BlackGoldDeduct uint32 `json:"black_gold_deduct"` // 黑金会员提成
UserInfo *UserInfo `json:"user_info" gorm:"-"` // 用户
Store *Store `json:"store" gorm:"-"` // 门店
// ReportTime string `json:"report_time" gorm:"index"` // 业绩时间
// invite_member_report
}
type UserInviteListReq struct {
//StoreId uint32 `json:"store_id"` // 门店id
Uid uint32 `json:"uid"` // 用户id
Page int `json:"pageIndex"`
PageSize int `json:"pageSize"`
MemberType int `json:"memberType"` // 0-全部 1-普通用户 2-会员
StartTime string `json:"startTime"` // 开始时间
EndTime string `json:"endTime"` // 结束时间
}
func (m *UserInfo) InitUserInvite(invite UserInvite) {
m.MemberOpenTime = invite.MemberOpenTime
m.MemberStatus = invite.MemberStatus
m.InviteTime = invite.CreatedAt
m.MemberLevel = invite.MemberLevel
}
func (m *UserInviteListReq) InviteList() ([]UserInfo, int, error) {
var (
users = make([]UserInfo, 0)
totalPage uint32
page = m.Page - 1
pageSize = m.PageSize
)
if page < 0 {
page = 0
}
if pageSize == 0 {
pageSize = 10
}
//user := &UserInfo{}
//UserInvite{}
var userInvites []UserInvite
qs := orm.Eloquent.Table("user_invite").Where("from_uid", m.Uid)
if m.MemberType != 0 {
qs = qs.Where("member_type=?", m.MemberType)
}
if m.StartTime != "" {
parse, err := time.Parse(DateTimeFormat, m.StartTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, err
}
if m.MemberType == 2 {
qs = qs.Where("member_open_time > ?", parse)
} else {
qs = qs.Where("created_at > ?", parse)
}
}
if m.EndTime != "" {
parse, err := time.Parse(DateTimeFormat, m.EndTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, err
}
parse = parse.AddDate(0, 0, 1)
if m.MemberType == 2 {
qs = qs.Where("member_open_time < ?", parse)
} else {
qs = qs.Where("created_at < ?", parse)
}
}
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, err
}
err = qs.Order("id DESC").Offset(page * pageSize).Limit(pageSize).Find(&userInvites).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, err
}
totalPage = uint32(int(count)/pageSize + 1)
uids := make([]uint32, 0)
userInviteMap := make(map[uint32]UserInvite, 0)
for i, _ := range userInvites {
uids = append(uids, userInvites[i].ToUid)
userInviteMap[userInvites[i].ToUid] = userInvites[i]
}
err = orm.Eloquent.Table("user").Debug().Where("uid in (?)", uids).Find(&users).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return users, 0, err
}
fmt.Println("totalPage", totalPage)
userMap := make(map[uint32]UserInfo, 0)
for i, _ := range users {
userMap[users[i].Uid] = users[i]
}
list := make([]UserInfo, 0, len(users))
for i, _ := range uids {
invite, ok1 := userInviteMap[uids[i]]
if !ok1 {
continue
}
userInfo, ok2 := userMap[uids[i]]
if !ok2 {
continue
}
userInfo.InitUserInvite(invite)
list = append(list, userInfo)
}
return list, int(count), nil
}
type UserInviteMember struct {
FromUserInfo UserInfo
ToUserInfo UserInfo
Store Store
UserInvite
UserInviteRecord UserInviteRecord
}
func MemberLevelToString(memberLevel uint32) string {
switch memberLevel {
case 2:
return "黄金会员"
case 4:
return "白金会员"
case 5:
return "黑金会员"
}
return ""
}
func ExportUserMember(storeId uint32, startTime, endTime string) string {
var userInvites []UserInvite
qs := orm.Eloquent.Table("invite")
if storeId != 0 {
qs = qs.Where("store_id", storeId)
}
if startTime != "" {
parse, err := time.Parse(DateTimeFormat, startTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
qs = qs.Where("member_open_time > ?", parse)
}
if endTime != "" {
parse, err := time.Parse(DateTimeFormat, endTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
parse = parse.AddDate(0, 0, 1)
qs = qs.Where("member_open_time < ?", parse)
}
err := qs.Order("id DESC,store_id DESC,from_uid DESC").Find(&userInvites).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
storeIds := make([]uint64, 0)
fromUids := make([]uint32, 0)
toUids := make([]uint32, 0)
for i, _ := range userInvites {
storeIds = append(storeIds, userInvites[i].StoreId)
fromUids = append(fromUids, userInvites[i].FromUid)
toUids = append(toUids, userInvites[i].ToUid)
}
var stores []Store
err = orm.Eloquent.Table("store").Where("id in (?)", storeIds).Find(&stores).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
storeMap := make(map[uint32]Store)
for i, _ := range stores {
storeMap[stores[i].ID] = stores[i]
}
fromUids = append(fromUids, toUids...)
var userInfos []UserInfo
err = orm.Eloquent.Table("user").Where("uid in (?)", fromUids).Find(&userInfos).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
userInfoMap := make(map[uint32]UserInfo, 0)
for i, _ := range userInfos {
userInfoMap[userInfos[i].Uid] = userInfos[i]
}
inviteMembers := make([]UserInviteMember, 0, len(userInvites))
for i, _ := range userInvites {
fromUser, _ := userInfoMap[userInvites[i].FromUid]
toUser, ok2 := userInfoMap[userInvites[i].ToUid]
if !ok2 {
continue
}
store, ok1 := storeMap[uint32(userInvites[i].StoreId)]
if !ok1 {
store = storeMap[uint32(toUser.StoreId)]
}
invite := UserInviteMember{
FromUserInfo: fromUser,
Store: store,
ToUserInfo: toUser,
UserInvite: userInvites[i],
}
inviteMembers = append(inviteMembers, invite)
}
fileName := "邀请会员"
if storeId == 0 {
fileName = "全部门店邀请会员"
} else {
if len(stores) > 0 {
fileName = stores[0].Name
}
}
//url := "http://switch.deovo.com:8000/img/export/"
//url := "http://39.108.188.218:8000/img/export/"
//fileName = fileName + time.Now().Format("2006-01-02 15:04:05") + ".csv"
//f, err := os.OpenFile(fmt.Sprintf("./")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
f, err := os.OpenFile(fmt.Sprintf("/www/server/images/export/")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
if err != nil {
fmt.Println(err)
return fileName
}
defer f.Close()
w := csv.NewWriter(f)
//headline := []string{"门店名称", "店员id", "店员昵称","姓名", "会员id", "会员昵称", "注册会员时间", "会员状态"}
headline := []string{"门店名称", "店员id", "姓名", "会员id", "会员昵称", "会员等级", "会员手机号", "注册会员时间", "会员状态"}
if err := w.Write(headline); err != nil {
重构日志
2023-10-14 08:19:04 +00:00
log.Fatalln("error writing record to csv:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
for _, invite := range inviteMembers {
//fmt.Println("MemberOpenTime",invite.UserInvite.MemberOpenTime)
//fmt.Println("MemberOpenTime",invite.UserInvite.MemberOpenTime.Format("2006-01-02 15:04:05"))
record := []string{invite.Store.Name, fmt.Sprintf("%d", invite.FromUserInfo.Uid), invite.FromUserInfo.ShopAssistantName,
fmt.Sprintf("%d", invite.ToUserInfo.Uid), invite.ToUserInfo.WxName, MemberLevelToString(invite.UserInvite.MemberLevel),
invite.ToUserInfo.Tel, invite.UserInvite.MemberOpenTime.Format("2006-01-02 15:04:05"),
GetUserInviteStatus(invite.MemberStatus)}
if err := w.Write(record); err != nil {
重构日志
2023-10-14 08:19:04 +00:00
log.Fatalln("error writing record to csv:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
w.Flush()
if err := w.Error(); err != nil {
log.Fatal(err)
}
return ExportUrl + fileName
}
// gen:qs
type UserInviteRecord struct {
Model
ToUid uint32 `json:"to_uid"` // 用户ID
FromUid uint32 `json:"from_uid"` // 邀请人ID
Action uint32 `json:"action"` // 1-未激活 2-激活邀请
SpendType uint32 `json:"spend_type"` // 1-未开通 2-开通会员 3-续费 4-升级
MemberLevel uint32 `json:"member_level"` // 会员等级
First uint32 `json:"first"` // 首次
Scan uint32 `json:"scan"` // 扫码
ActionTime time.Time `json:"action_time"` // 激活时间
RenewHide uint32 `json:"renew_hide"` // 自动续费
ShopAssistantName string `json:"shop_assistant_name" gorm:"-"` // 店员名称
// user_invite_record
}
type UserInviteRecordReq struct {
PageNum int `json:"pageIndex"`
PageSize int `json:"pageSize"`
MemberType int `json:"member_type"` // 1-首次邀请 2-开通黄金 3-开通白金 4-开通黑金 5-续费黄金 6-续费白金 7-续费黑金
FromUid uint32 `json:"from_uid"`
ToUid uint32 `json:"to_uid"`
StartTime time.Time `json:"startTime"` // 开始时间
EndTime time.Time `json:"endTime"` // 结束时间
}
func (m *UserInviteRecordReq) List() ([]UserInviteRecord, int64, error) {
var records []UserInviteRecord
err := UpdateUserInviteRecordRenewHide()
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return records, 0, err
}
page := m.PageNum - 1
pageSize := m.PageSize
if page < 0 {
page = 0
}
if pageSize == 0 {
pageSize = 10
}
qs := orm.Eloquent.Table("user_invite_record").Where("action=2").Where("renew_hide!=1")
//qs := orm.Eloquent.Table("user_invite_record")
if m.MemberType != 0 {
switch m.MemberType {
case 1:
qs = qs.Where("first=1").Where("spend_type=1")
case 2:
qs = qs.Where("member_level=2").Where("spend_type=2")
case 3:
qs = qs.Where("member_level=4").Where("spend_type=2")
case 4:
qs = qs.Where("member_level=5").Where("spend_type=2")
case 5:
qs = qs.Where("member_level=2").Where("spend_type=3")
case 6:
qs = qs.Where("member_level=4").Where("spend_type=3")
case 7:
qs = qs.Where("member_level=5").Where("spend_type=3")
}
}
if m.FromUid != 0 {
qs = qs.Where("from_uid=?", m.FromUid)
}
if m.ToUid != 0 {
qs = qs.Where("to_uid=?", m.ToUid)
}
if !m.StartTime.IsZero() {
//qs = qs.Where("created_at > ?", m.StartTime)
qs = qs.Where("action_time > ?", m.StartTime)
}
if !m.EndTime.IsZero() {
//qs = qs.Where("created_at < ?", m.EndTime)
qs = qs.Where("action_time < ?", m.EndTime)
}
var count int64
err = qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return records, 0, err
}
err = qs.Order("action_time DESC").Offset(page * pageSize).Limit(pageSize).Find(&records).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return records, 0, err
}
return records, count, nil
}
func UpdateUserInviteRecordRenewHide() error {
err := orm.Eloquent.Exec("UPDATE user_invite_record SET renew_hide=1 WHERE spend_type=3 AND scan=0 AND renew_hide!=1;").Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("update renew_hide err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
//func ExportUserMemberList(storeId, memberType uint32, startTime, endTime string) string {
// var userInvites []UserInvite
// qs := orm.Eloquent.Table("user_11invite").Where("from_uid > 0")
// if memberType == 1 {
// qs = qs.Where("member_type=？", 1)
// } else if memberType == 2 {
// qs = qs.Where("member_type in (?)", []uint32{2, 4, 5})
// } else if memberType == 3 {
// qs = qs.Where("member_type=？", 3)
// }
//
// if storeId != 0 {
// qs = qs.Where("store_id", storeId)
// }
// if startTime != "" {
// parse, err := time.Parse(DateTimeFormat, startTime)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Errorf("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
// }
// qs = qs.Where("member_open_time > ?", parse)
// }
// if endTime != "" {
// parse, err := time.Parse(DateTimeFormat, endTime)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Errorf("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
// }
// parse = parse.AddDate(0, 0, 1)
// qs = qs.Where("member_open_time < ?", parse)
// }
//
// err := qs.Order("id DESC,store_id DESC,from_uid DESC").Find(&userInvites).Error
// if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Errorf("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
// }
//
// storeIds := make([]uint64, 0)
// fromUids := make([]uint32, 0)
// toUids := make([]uint32, 0)
// for i, _ := range userInvites {
// storeIds = append(storeIds, userInvites[i].StoreId)
// fromUids = append(fromUids, userInvites[i].FromUid)
// toUids = append(toUids, userInvites[i].ToUid)
// }
//
// var stores []Store
// err = orm.Eloquent.Table("store").Where("id in (?)", storeIds).Find(&stores).Error
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
// }
// storeMap := make(map[uint32]Store)
// for i, _ := range stores {
// storeMap[stores[i].ID] = stores[i]
// }
//
// fromUids = append(fromUids, toUids...)
// var userInfos []UserInfo
// err = orm.Eloquent.Table("user").Where("uid in (?)", fromUids).Find(&userInfos).Error
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
// }
// userInfoMap := make(map[uint32]UserInfo, 0)
// for i, _ := range userInfos {
// userInfoMap[userInfos[i].Uid] = userInfos[i]
// }
//
// inviteMembers := make([]UserInviteMember, 0, len(userInvites))
// for i, _ := range userInvites {
// fromUser, _ := userInfoMap[userInvites[i].FromUid]
// toUser, ok2 := userInfoMap[userInvites[i].ToUid]
// if !ok2 {
// continue
// }
// store, ok1 := storeMap[uint32(userInvites[i].StoreId)]
// if !ok1 {
// store = storeMap[uint32(toUser.StoreId)]
// }
// invite := UserInviteMember{
// FromUserInfo: fromUser,
// Store: store,
// ToUserInfo: toUser,
// UserInvite: userInvites[i],
// }
// inviteMembers = append(inviteMembers, invite)
// }
//
// fileName := "邀请会员"
// if storeId == 0 {
// fileName = "全部门店邀请会员"
// } else {
// if len(stores) > 0 {
// fileName = stores[0].Name
// }
// }
// //url := "http://switch.deovo.com:8000/img/export/"
// url := "http://39.108.188.218:8000/img/export/"
//
// fileName = fileName + time.Now().Format("2006-01-02 15:04:05") + ".csv"
// //f, err := os.OpenFile(fmt.Sprintf("./")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
// f, err := os.OpenFile(fmt.Sprintf("/www/server/images/export/")+fileName, os.O_CREATE|os.O_TRUNC|os.O_APPEND|os.O_RDWR, 0644)
// if err != nil {
// fmt.Println(err)
// return fileName
// }
// defer f.Close()
//
// w := csv.NewWriter(f)
//
// //headline := []string{"门店名称", "店员id", "店员昵称","姓名", "会员id", "会员昵称", "注册会员时间", "会员状态"}
// headline := []string{"门店名称", "店员id", "姓名", "会员id", "会员昵称", "会员等级", "注册会员时间", "会员状态"}
// if err := w.Write(headline); err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// log.Fatalln("error writing record to csv:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// }
//
// for _, invite := range inviteMembers {
// //fmt.Println("MemberOpenTime",invite.UserInvite.MemberOpenTime)
// //fmt.Println("MemberOpenTime",invite.UserInvite.MemberOpenTime.Format("2006-01-02 15:04:05"))
// record := []string{invite.Store.Name, fmt.Sprintf("%d", invite.FromUserInfo.Uid), invite.FromUserInfo.ShopAssistantName,
// fmt.Sprintf("%d", invite.ToUserInfo.Uid), invite.ToUserInfo.WxName, MemberLevelToString(invite.UserInvite.MemberLevel), invite.UserInvite.MemberOpenTime.Format("2006-01-02 15:04:05"),
// GetUserInviteStatus(invite.MemberStatus)}
// if err := w.Write(record); err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// log.Fatalln("error writing record to csv:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// }
// }
//
// w.Flush()
// if err := w.Error(); err != nil {
// log.Fatal(err)
// }
//
// return url + fileName
//}
// 导出用户
func ExportUserMemberList(storeId, memberType, cooperativeId uint32, startTime, endTime, renewalStartTime, renewalEndTime string) string {
var userInfos []UserInfo
qs := orm.Eloquent.Table("user")
if memberType == 1 {
qs = qs.Where("member_level=?", 1)
} else if memberType == 2 {
qs = qs.Where("member_level in (?)", []uint32{2, 4, 5})
} else if memberType == 3 {
qs = qs.Where("member_level=?", 3)
}
if storeId != 0 {
qs = qs.Where("store_id=?", storeId)
}
if startTime != "" {
parse, err := time.Parse(DateTimeFormat, startTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
//qs = qs.Where("created_at > ?", parse)
qs = qs.Where("open_member_time > ?", parse)
}
if endTime != "" {
parse, err := time.Parse(DateTimeFormat, endTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
parse = parse.AddDate(0, 0, 1)
//qs = qs.Where("created_at < ?", parse)
qs = qs.Where("open_member_time < ?", parse)
}
if cooperativeId != 0 {
qs = qs.Where("cooperative_business_id=?", cooperativeId)
}
//err := qs.Order("id DESC,store_id DESC,from_uid DESC").Find(&userInvites).Error
err := qs.Order("id DESC,store_id DESC,uid DESC").Find(&userInfos).Error
//err := qs.Order("id DESC").Find(&userInfos).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
storeIds := make([]uint32, 0)
fromUids := make([]uint32, 0)
toUids := make([]uint32, 0)
for i, _ := range userInfos {
storeIds = append(storeIds, uint32(userInfos[i].StoreId))
//fromUids = append(fromUids, userInvites[i].FromUid)
toUids = append(toUids, userInfos[i].Uid)
}
//var stores []Store
//err = orm.Eloquent.Table("store").Where("id in (?)", storeIds).Find(&stores).Error
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return ""
//}
//storeMap := make(map[uint32]Store)
//for i, _ := range stores {
// storeMap[stores[i].ID] = stores[i]
//}
//fromUids = append(fromUids, toUids...)
var userInvites []UserInvite
inviteQs := orm.Eloquent.Table("user_invite").Where("to_uid in (?)", toUids)
if memberType == 1 {
}
if memberType == 2 {
inviteQs = inviteQs.Where("action=2").Where("spend_type=2")
}
err = inviteQs.Find(&userInvites).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
userInviteMap := make(map[uint32]UserInvite, 0)
for i, _ := range userInvites {
userInviteMap[userInvites[i].ToUid] = userInvites[i]
fromUids = append(fromUids, userInvites[i].FromUid)
}
var fromUserInfos []UserInfo
err = orm.Eloquent.Table("user").Where("uid in (?)", fromUids).Find(&fromUserInfos).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("from user infos err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
fromUserMap := make(map[uint32]UserInfo, 0)
for i, _ := range fromUserInfos {
fromUserMap[fromUserInfos[i].Uid] = fromUserInfos[i]
//
storeIds = append(storeIds, uint32(fromUserInfos[i].StoreId))
}
storeMap := StoreMapByIds(storeIds)
isRenewal := false
var inviteRecords []UserInviteRecord
//err = orm.Eloquent.Table("user_invite_record").Where("to_uid in (?)", toUids).Where("first!=1").
// Where("scan=1").Order("id DESC").Find(&inviteRecords).Error
qsInviteRecords := orm.Eloquent.Table("user_invite_record").Where("to_uid in (?)", toUids).
Where("first!=1").Where("action=2")
if renewalStartTime != "" {
isRenewal = true
parse, err := time.Parse(DateTimeFormat, renewalStartTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
//qs = qs.Where("created_at > ?", parse)
qsInviteRecords = qsInviteRecords.Where("action_time > ?", parse).Where("spend_type=3")
}
if renewalEndTime != "" {
isRenewal = true
parse, err := time.Parse(DateTimeFormat, renewalEndTime)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
parse = parse.AddDate(0, 0, 1)
//qs = qs.Where("created_at < ?", parse)
qsInviteRecords = qsInviteRecords.Where("action_time < ?", parse).Where("spend_type=3")
}
err = qsInviteRecords.Order("id ASC").Find(&inviteRecords).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("invite record err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
UserInviteRecordListSetAssistantName(inviteRecords)
inviteRecordMap := make(map[uint32][]UserInviteRecord, 0)
for i, _ := range inviteRecords {
fromUser, ok3 := fromUserMap[inviteRecords[i].FromUid]
if ok3 {
inviteRecords[i].ShopAssistantName = fromUser.ShopAssistantName
}
//inviteRecordMap[inviteRecords[i].ToUid] = inviteRecords[i]
v, ok := inviteRecordMap[inviteRecords[i].ToUid]
if ok {
if len(v) >= 2 {
continue
}
}
if inviteRecords[i].SpendType == 3 && inviteRecords[i].Scan == 0 {
inviteRecords[i].ShopAssistantName = "自动续费"
}
inviteRecordMap[inviteRecords[i].ToUid] = append(inviteRecordMap[inviteRecords[i].ToUid], inviteRecords[i])
}
inviteMembers := make([]UserInviteMember, 0, len(userInvites))
for i, _ := range userInfos {
//toUser, ok2 := userInfoMap[userInvites[i].ToUid]
store, ok1 := storeMap[(userInfos[i].StoreId)]
userInfoMember := UserInviteMember{
FromUserInfo: UserInfo{},
Store: store,
ToUserInfo: userInfos[i],
UserInvite: UserInvite{ToUid: userInfos[i].Uid},
}
if isRenewal {
v, ok := inviteRecordMap[userInfos[i].Uid]
if !ok {
continue
}
if len(v) > 0 {
userInfoMember.UserInviteRecord = v[len(v)-1]
}
}
userInvite, ok2 := userInviteMap[userInfos[i].Uid]
if ok2 {
userInfoMember.UserInvite = userInvite
if !ok1 {
store = storeMap[(userInvite.StoreId)]
userInfoMember.Store = store
}
fromUser, ok3 := fromUserMap[userInvite.FromUid]
if ok3 {
userInfoMember.FromUserInfo = fromUser
}
}
fromStore, ok4 := storeMap[userInfoMember.FromUserInfo.StoreId]
if ok4 {
userInfoMember.FromUserInfo.Store = &fromStore
}
inviteMembers = append(inviteMembers, userInfoMember)
}
if isRenewal {
sort.Sort(ExportUserInviteMemberList(inviteMembers))
}
//UserInviteRecordListSetAssistantName(inviteRecords)
//
//inviteRecordMap := make(map[uint32][]UserInviteRecord, 0)
//for i, _ := range inviteRecords {
// v, ok := inviteRecordMap[inviteRecords[i].ToUid]
// if ok {
// if len(v) >= 2 {
// continue
// }
// }
// if inviteRecords[i].SpendType == 3 && inviteRecords[i].Scan == 0 {
// inviteRecords[i].ShopAssistantName = "自动续费"
// }
//
// inviteRecordMap[inviteRecords[i].ToUid] = append(inviteRecordMap[inviteRecords[i].ToUid], inviteRecords[i])
//}
fileName := "邀请会员"
if storeId == 0 {
fileName = "全部门店邀请会员"
} else {
store, err := GetStore(storeId)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("get store err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return ""
}
fileName = store.Name
}
//url := "http://39.108.188.218:8000/img/export/"
//url := "https://dev.admin.deovo.com/img/export/"
styleBorder := &excelize.Style{
Border: []excelize.Border{{
Type: "left",
Color: "000000",
Style: 1,
}, {
Type: "top",
Color: "000000",
Style: 1,
}, {
Type: "right",
Color: "000000",
Style: 1,
}, {
Type: "bottom",
Color: "000000",
Style: 1,
}},
}
styleFill1 := &excelize.Style{
Border: []excelize.Border{{
Type: "left",
Color: "000000",
Style: 1,
}, {
Type: "top",
Color: "000000",
Style: 1,
}, {
Type: "right",
Color: "000000",
Style: 1,
}, {
Type: "bottom",
Color: "000000",
Style: 1,
}},
Fill: excelize.Fill{
Type: "pattern",
Pattern: 1,
Color: []string{"FFFF00"},
},
}
styleFill2 := &excelize.Style{
Border: []excelize.Border{{
Type: "left",
Color: "000000",
Style: 1,
}, {
Type: "top",
Color: "000000",
Style: 1,
}, {
Type: "right",
Color: "000000",
Style: 1,
}, {
Type: "bottom",
Color: "000000",
Style: 1,
}},
Fill: excelize.Fill{
Type: "pattern",
Pattern: 1,
Color: []string{"FFEFDB"},
},
}
//url := "https://dev.admin.deovo.com/load/export/"
fileName = time.Now().Format(TimeFormat) + fileName + ".xlsx"
fSheet := "Sheet1"
file := excelize.NewFile()
//streamWriter, err := file.NewStreamWriter("Sheet1")
//if err != nil {
// fmt.Println(err)
//}
styleBorderId, err := file.NewStyle(styleBorder)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
styleFillId1, err := file.NewStyle(styleFill1)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
styleFillId2, err := file.NewStyle(styleFill2)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
//headline := []string{"门店名称", "店员id", "店员姓名", "用户注册时间", "最近登录时间", "会员id", "会员昵称", "用户手机号", "会员等级", "注册会员时间", "会员状态"}
headline := []interface{}{"门店名称", "店员id", "店员姓名", "店员门店", "用户注册时间", "最近登录时间", "用户id", "用户昵称", "用户手机号", "会员等级", "注册会员时间",
"开通_店员id", "开通_店员名称", "开通_扫码时间", "续费_店员id", "续费_店员名称", "续费_扫码时间"}
if cooperativeId != 0 {
headline = []interface{}{"门店名称", "店员id", "店员姓名", "店员门店", "用户注册时间", "最近登录时间", "用户id", "会员等级", "注册会员时间",
"开通_店员id", "开通_店员名称", "开通_扫码时间", "续费_店员id", "续费_店员名称", "续费_扫码时间"}
}
headLength := len(headline)
for i, _ := range headline {
cell, _ := excelize.CoordinatesToCellName(1+i, 1)
err = file.SetCellValue(fSheet, cell, headline[i])
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
idx := i
if cooperativeId == 0 {
if idx+1 > 11 && idx+1 <= 14 {
err = file.SetCellStyle(fSheet, cell, cell, styleFillId1)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
} else if idx+1 > 14 && idx+1 <= 17 {
err = file.SetCellStyle(fSheet, cell, cell, styleFillId2)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
} else {
err = file.SetCellStyle(fSheet, cell, cell, styleBorderId)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
} else {
if idx+1 > 9 && idx+1 <= 12 {
err = file.SetCellStyle(fSheet, cell, cell, styleFillId1)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
} else if idx+1 > 12 && idx+1 <= 15 {
err = file.SetCellStyle(fSheet, cell, cell, styleFillId2)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
} else {
err = file.SetCellStyle(fSheet, cell, cell, styleBorderId)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
}
}
//if err = streamWriter.SetRow(cell, headline); err != nil {
// fmt.Println(err)
//}
for rowId := 0; rowId < len(inviteMembers); rowId++ {
invite := inviteMembers[rowId]
fromStoreName := ""
if invite.FromUserInfo.Store != nil {
fromStoreName = invite.FromUserInfo.Store.Name
}
record := []interface{}{}
if cooperativeId != 0 {
record = []interface{}{invite.Store.Name, fmt.Sprintf("%d", invite.FromUserInfo.Uid),
invite.FromUserInfo.ShopAssistantName, fromStoreName,
invite.ToUserInfo.CreatedAt.Format(TimeFormat), invite.ToUserInfo.LastLoginAt.Format(TimeFormat),
fmt.Sprintf("%d", invite.ToUserInfo.Uid), MemberLevelToString(invite.UserInvite.MemberLevel),
invite.UserInvite.MemberOpenTime.Format(TimeFormat),
//GetUserInviteStatus(invite.MemberStatus),
}
} else {
record = []interface{}{invite.Store.Name, fmt.Sprintf("%d", invite.FromUserInfo.Uid),
invite.FromUserInfo.ShopAssistantName, fromStoreName,
invite.ToUserInfo.CreatedAt.Format(TimeFormat), invite.ToUserInfo.LastLoginAt.Format(TimeFormat),
fmt.Sprintf("%d", invite.ToUserInfo.Uid), invite.ToUserInfo.WxName, invite.ToUserInfo.Tel,
MemberLevelToString(invite.ToUserInfo.MemberLevel),
invite.ToUserInfo.OpenMemberTime.Format(TimeFormat),
//GetUserInviteStatus(invite.ToUserInfo.MemberStatus),
}
//MemberLevelToString(invite.UserInvite.MemberLevel),
//invite.UserInvite.MemberOpenTime.Format(TimeFormat),
//GetUserInviteStatus(invite.MemberStatus)}
}
userInviteRecordList, ok := inviteRecordMap[invite.ToUid]
if ok {
for i, _ := range userInviteRecordList {
if i == 0 && userInviteRecordList[i].SpendType != 2 {
record = append(record, []interface{}{"", "", ""}...)
}
record = append(record, []interface{}{userInviteRecordList[i].FromUid, userInviteRecordList[i].ShopAssistantName, userInviteRecordList[i].CreatedAt.Format(TimeFormat)}...)
}
}
if len(record) < headLength {
record = append(record, make([]interface{}, headLength-len(record))...)
}
for i, _ := range record {
cell, _ := excelize.CoordinatesToCellName(1+i, rowId+2)
err = file.SetCellValue(fSheet, cell, record[i])
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
err = file.SetCellStyle(fSheet, cell, cell, styleBorderId)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("file set value err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
//if err := streamWriter.SetRow(cell, record); err != nil {
// fmt.Println(err)
//}
}
//if err := streamWriter.Flush(); err != nil {
// fmt.Println(err)
//}
if err := file.SaveAs("/www/server/images/export/" + fileName); err != nil {
//if err := file.SaveAs("./" + fileName); err != nil {
fmt.Println(err)
}
return ExportUrl + fileName
}
type ExportUserInviteMemberList []UserInviteMember
func (s ExportUserInviteMemberList) Len() int {
//返回传入数据的总数
return len(s)
}
func (s ExportUserInviteMemberList) Swap(i, j int) {
//两个对象满足Less()则位置对换
//表示执行交换数组中下标为i的数据和下标为j的数据
s[i], s[j] = s[j], s[i]
}
func (s ExportUserInviteMemberList) Less(i, j int) bool {
//按字段比较大小,此处是降序排序
//返回数组中下标为i的数据是否小于下标为j的数据
return s[i].UserInviteRecord.ActionTime.After(s[j].UserInviteRecord.ActionTime)
}
func GetUserInviteStatus(status uint8) string {
switch status {
case 1:
return "未注册"
case 2:
return "已注册"
case 3:
return "取消会员"
}
return ""
}
func IsUserInfoByUid(uid uint32) (bool, error) {
//userInfo := new(UserInfo)
var count int64
err := orm.Eloquent.Debug().Table("user").Where("uid = ?", uid).Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return false, err
}
if count == 0 {
return true, errors.New("user not exist")
}
return true, nil
}
func GetUserInfoByUid(uid uint32) (UserInfo, error) {
//userInfo := new(UserInfo)
var userInfo UserInfo
err := orm.Eloquent.Debug().Table("user").Where("uid = ?", uid).Find(&userInfo).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return userInfo, err
}
return userInfo, nil
}
1.sys_user表增加uid字段； 2.优化新增/编辑商品资料接口，统一入参，新增商品条码字段； 3.修改库存详情接口，新增扫码字段，添加校验逻辑； 4.新增扫码模糊查询接口； 5.优化新增/编辑零售订单接口； 6.新增查询零售明细接口及excel导出逻辑； 7.新增查询小票数据接口； 8.优化用户登陆接口，内部员工小程序侧可使用erp功能；
2024-01-06 08:48:35 +00:00
func GetSysUserInfoByUid(uid uint32) (SysUser, error) {
//userInfo := new(UserInfo)
var userInfo SysUser
err := orm.Eloquent.Debug().Table("sys_user").Where("uid = ?", uid).Find(&userInfo).Error
if err != nil {
logger.Error("err:", logger.Field("err", err))
return userInfo, err
}
return userInfo, nil
}
fix:
2023-09-16 02:56:39 +00:00
type UserDepositRefundRecordListReq struct {
//StoreId uint32 `json:"store_id"` // 门店id
Uid uint32 `json:"uid"` // 用户id
PageNum int `json:"pageIndex"`
PageSize int `json:"pageSize"`
Status uint32 `json:"status"`
}
type UserDepositRefundRecordListResp struct {
List []DepositRefundRecord `json:"list"`
Count uint32 `json:"count"`
PageNum int `json:"pageIndex"`
}
func (m *UserDepositRefundRecordListReq) DepositRefundRecordList() (*UserDepositRefundRecordListResp, error) {
qs := orm.Eloquent.Table("deposit_refund_record")
if m.Status != 0 {
qs = qs.Where("status=?", m.Status)
}
if m.Uid != 0 {
qs = qs.Where("uid=?", m.Uid)
}
page := m.PageNum - 1
if page < 0 {
page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
resp := &UserDepositRefundRecordListResp{PageNum: m.PageNum}
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("count err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.Count = uint32(count)
var depositRefunds []DepositRefundRecord
err = qs.Order("status ASC").Order("id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&depositRefunds).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.List = depositRefunds
return resp, nil
}
type GroupSendMessageCreateTemplateListReq struct {
Status uint32 `json:"status"` // 1-待发送 2-已发送
Title string `json:"title"`
PageNum int `json:"pageIndex"`
PageSize int `json:"pageSize"`
}
type GroupSendMessageCreateTemplateListResp struct {
List []GroupSendMessageTemplate `json:"list"`
Count uint32 `json:"count"`
PageNum int `json:"pageIndex"`
}
func (m *GroupSendMessageCreateTemplateListReq) List() (*GroupSendMessageCreateTemplateListResp, error) {
qs := orm.Eloquent.Table("group_send_message_template")
if m.Status != 0 {
qs = qs.Where("status=?", m.Status)
}
if m.Title != "" {
qs = qs.Where("title LIKE '%" + m.Title + "%'")
}
page := m.PageNum - 1
if page < 0 {
page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
resp := &GroupSendMessageCreateTemplateListResp{PageNum: m.PageNum}
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("count err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.Count = uint32(count)
var groupSends []GroupSendMessageTemplate
err = qs.Order("id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&groupSends).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.List = groupSends
return resp, nil
}
func CreateInviteMemberReport() {
date := time.Now().AddDate(0, 0, 1)
if date.Day() != 1 {
return
}
var cooperatives []CooperativeBusiness
err := orm.Eloquent.Table("cooperative_business").Find(&cooperatives).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("cooperative err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return
}
for i, _ := range cooperatives {
cooperatives[i].InviteMemberReport()
}
}
func (m *CooperativeBusiness) InviteMemberReport() {
var users []UserInfo
err := orm.Eloquent.Table("user").Where("cooperative_business_id=?", m.ID).Where("user_type=2").Find(&users).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("cooperative err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return
}
for i, _ := range users {
m.UserInviteReport(users[i])
}
}
func (m *CooperativeBusiness) UserInviteReport(userInfo UserInfo) {
//end := InDayZero(1)
//start := end.AddDate(0, -1, 0)
reportTime := time.Now().AddDate(0, 0, 1).Format("2006-01")
//var userInvites []UserInvite
//qs := orm.Eloquent.Table("user_invite").Where("from_uid=?", userInfo.Uid).
// Where("member_status=?", 2).Where("user_type=?", 2).
// Where("member_open_time>?", start).Where("member_open_time<?", end)
//qs = qs.Where("action=2").Where("spend_type=2")
//err := qs.Find(&userInvites).Error
//if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("cooperative err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return
//}
//reportTime := start.Format("2006-01")
//m.SetMemberDeductConfig()
m.SetAssistantMemberDeductConfig(uint32(userInfo.StoreId))
if m.CooperativeAssistantMemberDeduct == nil {
logger.Error("cooperative assistant member deduct is nil")
return
}
exist, err := QueryRecordExist(fmt.Sprintf(
"SELECT * FROM invite_member_report WHERE cooperative_business_id=%d AND date='%s' AND store_id=%d AND uid=%d",
userInfo.CooperativeBusinessId, reportTime, userInfo.StoreId, userInfo.Uid))
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("cooperative member promotion record exist err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return
}
report := &InviteMemberReport{
Uid: userInfo.Uid,
StoreId: uint32(userInfo.StoreId),
GoldCount: 0,
PlatinumCount: 0,
BlackGoldCount: 0,
Date: reportTime,
DeductAmount: 0,
CooperativeBusinessId: userInfo.CooperativeBusinessId,
CooperativeName: userInfo.CooperativeName,
GoldDeduct: m.CooperativeAssistantMemberDeduct.GoldDeduct,
PlatinumDeduct: m.CooperativeAssistantMemberDeduct.PlatinumDeduct,
BlackGoldDeduct: m.CooperativeAssistantMemberDeduct.BlackGoldDeduct,
}
//for i, _ := range userInvites {
// switch userInvites[i].MemberLevel {
// case 2:
// report.GoldCount += 1
// case 4:
// report.PlatinumCount += 1
// case 5:
// report.BlackGoldCount += 1
// }
//}
//report.DeductAmount += report.GoldCount * m.CooperativeAssistantMemberDeduct.GoldDeduct
//report.DeductAmount += report.PlatinumCount * m.CooperativeAssistantMemberDeduct.PlatinumDeduct
//report.DeductAmount += report.BlackGoldCount * m.CooperativeAssistantMemberDeduct.BlackGoldDeduct
if exist {
//err = orm.Eloquent.Save(report).Error
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("invite member report err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
//}
logger.Error("member report exist ")
return
}
//if len(userInvites) == 0 {
// err = orm.Eloquent.Create(report).Error
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("Create report err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// }
// return
//}
err = orm.Eloquent.Create(report).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("Create report err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
func GetSysUser(suid interface{}) (SysUser, error) {
fmt.Println("sysUid:", suid)
var sUser SysUser
err := orm.Eloquent.Table("sys_user").Where(fmt.Sprintf("user_id=%.0f", suid.(float64))).Find(&sUser).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("invite member report err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return sUser, err
}
return sUser, nil
}
type AssistantInviteMemberReportReq struct {
CooperativeBusinessId uint32 `json:"cooperative_business_id"`
//ParaCooperativeId uint32 `json:"para_cooperative_id"`
StoreId uint32 `json:"store_id"` // 门店id
SysUser SysUser `json:"sys_user"`
Date string `json:"date"`
Page int `json:"pageIndex"`
PageSize int `json:"pageSize"`
}
func (m *AssistantInviteMemberReportReq) List() ([]InviteMemberReport, int64, error) {
var memberReport []InviteMemberReport
var users []UserInfo
err := orm.Eloquent.Table("user").Where("user_type=2").Where("shop_assistant_name=''").Find(&users).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return memberReport, 0, err
}
uids := make([]uint32, 0, len(users))
for i, _ := range users {
uids = append(uids, users[i].Uid)
}
qs := orm.Eloquent.Table("invite_member_report")
if m.SysUser.UserId != 1 {
qs = qs.Where("cooperative_business_id=?", m.SysUser.CooperativeBusinessId)
} else {
qs = qs.Where("cooperative_business_id=?", m.CooperativeBusinessId)
}
if len(uids) > 0 {
qs = qs.Where("uid NOT IN (?)", uids)
}
if m.StoreId != 0 {
qs = qs.Where("store_id=?", m.StoreId)
}
if m.Date != "" {
qs = qs.Where("date=?", m.Date)
}
//qs := NewInviteMemberReportQuerySet(DB).UidEq(m.Uid)
var count int64
err = qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("count err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return memberReport, 0, err
}
page := m.Page - 1
if page < 0 {
page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
//totalPage := int(count)/m.PageSize + 1
err = qs.Order("store_id DESC,id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&memberReport).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return memberReport, count, err
}
//assistant := GetUserByUid(m.Uid)
//cooperative := new(CooperativeBusiness)
//cooperative.ID = assistant.CooperativeBusinessId
//cooperative.SetAssistantMemberDeductConfig(uint32(assistant.StoreId))
//fmt.Println("CooperativeBusinessId:", assistant.CooperativeBusinessId, assistant.StoreId)
//fmt.Println("CooperativeAssistantMemberDeduct:", cooperative.CooperativeAssistantMemberDeduct)
//if len(memberReport) > 0 {
// memberReport[len(memberReport)-1].GoldDeduct = cooperative.CooperativeAssistantMemberDeduct.GoldDeduct
// memberReport[len(memberReport)-1].PlatinumDeduct = cooperative.CooperativeAssistantMemberDeduct.PlatinumDeduct
// memberReport[len(memberReport)-1].BlackGoldDeduct = cooperative.CooperativeAssistantMemberDeduct.BlackGoldDeduct
//
// report := memberReport[len(memberReport)-1]
// fmt.Println("report:", report)
// memberReport[len(memberReport)-1].DeductAmount += report.GoldCount * report.GoldDeduct
// memberReport[len(memberReport)-1].DeductAmount += report.PlatinumCount * report.PlatinumDeduct
// memberReport[len(memberReport)-1].DeductAmount += report.BlackGoldCount * report.BlackGoldDeduct
//}
memberReport = InviteMemberReportListSetUser(memberReport)
return memberReport, count, nil
}
func InviteMemberReportListSetUser(list []InviteMemberReport) []InviteMemberReport {
ids := make([]uint32, 0, len(list))
for i, _ := range list {
ids = append(ids, list[i].Uid)
}
if len(ids) == 0 {
return list
}
infoMap, err := GetUserInfoMap(ids)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("user info map err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return list
}
for i, _ := range list {
v, ok := infoMap[list[i].Uid]
if ok {
list[i].UserInfo = &v
}
fmt.Println("UserInfo:", v)
}
return list
}
func InviteMemberReportListSetStore(list []InviteMemberReport) []InviteMemberReport {
ids := make([]uint32, 0, len(list))
for i, _ := range list {
ids = append(ids, list[i].StoreId)
}
if len(ids) == 0 {
return list
}
storeMap := GetStoreMapByIds(ids)
//infoMap, err := GetUserInfoMap(ids)
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("user info map err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return list
//}
for i, _ := range list {
v, ok := storeMap[uint64(list[i].StoreId)]
if ok {
list[i].Store = v
}
fmt.Println("UserInfo:", v)
}
return list
}
func GetCooperativeBusinessId(c *gin.Context) (uint32, error) {
data, _ := c.Get(jwtauth.JwtPayloadKey)
sysUid, ok := data.(jwtauth.MapClaims)["identity"]
if !ok {
logger.Error("sys uid err")
app.Error(c, http.StatusInternalServerError, errors.New("sys uid err"), "查询失败")
return 0, errors.New("sys uid err")
}
sysUser, err := GetSysUser(sysUid)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("sys user err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
app.Error(c, http.StatusInternalServerError, err, "查询失败")
return 0, err
}
//req.CooperativeBusinessId = sysUser.CooperativeBusinessId
return sysUser.CooperativeBusinessId, nil
}
func GetSysUserByCtx(c *gin.Context) (*SysUser, error) {
//data, _ := c.Get(jwtauth.JwtPayloadKey)
//sysUid, ok := data.(jwtauth.MapClaims)["identity"]
//if !ok {
// logger.Error("sys uid err")
// app.Error(c, http.StatusInternalServerError, errors.New("sys uid err"), "查询失败")
// return nil, errors.New("sys uid err")
//}
//sysUser, err := GetSysUser(sysUid)
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("sys user err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// app.Error(c, http.StatusInternalServerError, err, "查询失败")
// return nil, err
//}
//req.CooperativeBusinessId = sysUser.CooperativeBusinessId
//return &sysUser, nil
data, _ := c.Get(jwtauth.JwtPayloadKey)
mapClaims := data.(jwtauth.MapClaims)
sysUid := float64(0)
if v, ok := mapClaims["identity"]; ok {
sysUid = v.(float64)
}
//fmt.Println("sysUid:", sysUid)
//req.SysUid = fmt.Sprintf("%.0f", sysUid)
var sysUser SysUser
err := orm.Eloquent.Table("sys_user").Where("user_id=?", uint32(sysUid)).Find(&sysUser).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("sys user err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
app.Error(c, http.StatusInternalServerError, err, "操作失败")
return &sysUser, err
}
return &sysUser, nil
}
//type CooperativeStockExportReq struct {
// CooperativeBusinessId uint32 `json:"cooperative_business_id"`
// StoreId uint32 `json:"store_id"` // 门店id
//}
//
//func (r *CooperativeStockExportReq) Export() {
//
//}
//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货
// gen:qs
type UserOpenMemberRecord struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
OpenNo string `json:"open_no" gorm:"index"`
OrderId uint32 `json:"order_id" gorm:"index"`
OrderType uint32 `json:"order_type"`
MemberLevel uint32 `json:"member_level"`
MemberExpire time.Time `json:"member_expire"` // 会员到期时间
Order *Order `json:"order" gorm:"-"`
ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`
GoodsOrder *GoodsOrder `json:"goods_order" gorm:"-"`
//Attach string `json:"attach"`
}
func (o *UserOpenMemberRecord) TableName() string {
return "user_open_member_record"
}
func (m *UserOpenMemberRecord) Refund(outTradeNo string, amount uint32) error {
configInfo, err := PayConfigInfo()
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("config info err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
//configInfo.NotifyUrl = "https://dev.switch.deovo.com:8004/api/v1/wxpay_refund/notice"
err = orm.Eloquent.Create(m).Error
//err = m.Insert()
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("insert user open member record err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
orderRefund := pay.OrderRefund{
OutTradeNo: outTradeNo,
OutRefundNo: m.OpenNo,
NotifyUrl: configInfo.RefundNotifyUrl,
Amount: pay.OrderRefundAmount{
Refund: amount,
Total: amount,
Currency: "CNY",
},
}
err = pay.TransactionOrderRefund(orderRefund)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
func (m *UserOpenMemberRecord) MallGoodsOrderRefund(outTradeNo string) error {
if m.GoodsOrder == nil {
return errors.New("goods order is nil")
}
if m.OpenNo == "" {
m.OpenNo = GetOrderSn()
}
m.Uid = uint32(m.GoodsOrder.Uid)
m.OrderId = m.GoodsOrder.ID
err := m.Refund(outTradeNo, m.GoodsOrder.Rm)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("refund err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return err
}
return nil
}
func GetOrderSn() string {
var orderSn string
for {
//orderSn = utils.GetSerialNo32HEXString()
orderSn = utils.GenSerialNo()
var count int64
err := orm.Eloquent.Table("user_open_member_record").Where("open_no=?", orderSn).Count(&count)
//count, err := NewUserOpenMemberRecordQuerySet(DB).OpenNoEq(orderSn).Count()
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
if count == 0 {
break
}
}
return orderSn
}
func (m *OperationLog) AddLog() {
defer func() {
if err := recover(); err != nil {
重构日志
2023-10-14 08:19:04 +00:00
fmt.Println("recover err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}()
go func() {
err := orm.Eloquent.Create(m).Error
if err != nil {
logger.Error("create operation log err:")
}
}()
}
func SendMessageMemberRenewal() {
//user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0))
//start := TodayZero().AddDate(0, 1, 0)
////end := start.AddDate(0, 0, 1)
//end := start
//fmt.Println("end:", end.Format(TimeFormat))
//var users []UserInfo
//err := orm.Eloquent.Table("user").Where("member_level IN (2,4,5)").Where("member_expire < ?", end).Find(&users).Error
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("cooperative err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return
//}
fmt.Println("发送续费短息开始:")
start := TodayZero().AddDate(0, 0, GetActivityRenewalConfig().PopTrap)
end := start.AddDate(0, 0, 1)
var users []UserInfo
err := orm.Eloquent.Table("user").Where("member_level IN (2,4,5)").
Where("member_expire>?", start).Where("member_expire<?", end).Find(&users).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("cooperative err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return
}
切换绿城短信
2023-10-08 07:05:33 +00:00
tels := make([]string, 0)
fix:
2023-09-16 02:56:39 +00:00
uids := make([]uint32, 0, len(users))
for i, _ := range users {
if users[i].Tel != "" {
切换绿城短信
2023-10-08 07:05:33 +00:00
tels = append(tels, users[i].Tel)
fix:
2023-09-16 02:56:39 +00:00
fmt.Println("user:", users[i].Uid, users[i].Tel)
uids = append(uids, users[i].Uid)
}
}
切换绿城短信
2023-10-08 07:05:33 +00:00
if len(tels) > 0 {
修改短信主体
2023-10-18 02:17:05 +00:00
message := "【go2switch】提醒：您的租卡会员时长仅剩余一个月，现在续费最高立减200元！赶快进入小程序领取优惠吧~"
切换绿城短信
2023-10-08 07:05:33 +00:00
err = GtSendMessage(tels, message)
fix:
2023-09-16 02:56:39 +00:00
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Errorf("SmsSend err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return
}
//fmt.Println("tels:", tels)
//fmt.Printf("uids:", uids)
renewalLogs, err := GetActionUserRenewalLogMulti(uids, UserRenewalLogSendMessage)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("renewalLogs err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
renewalLogMap := make(map[uint32]UserRenewalLog, 0)
for i, _ := range renewalLogs {
renewalLogMap[renewalLogs[i].Uid] = renewalLogs[i]
}
for i, _ := range users {
renewalLog := &UserRenewalLog{
Uid: users[i].Uid,
Action: UserRenewalLogSendMessage,
MemberExpire: users[i].MemberExpire,
Type: 0,
Serial: uint32(users[i].MemberExpire.Unix()),
}
v, _ := renewalLogMap[users[i].Uid]
renewalLog.RenewalNum = v.RenewalNum + 1
err = orm.Eloquent.Create(renewalLog).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("create renewal log err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
}
fmt.Println("发送续费短息完成...")
}
//func PayConfigInfo() (*PayConfig, error) {
// payConfig := new(PayConfig)
// var configAllocation Config
// err := NewConfigQuerySet(DB).NameEq(ConfigNamePay).One(&configAllocation)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return payConfig, err
// }
//
// err = json.Unmarshal([]byte(configAllocation.Value), payConfig)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return payConfig, err
// }
//
// return payConfig, nil
//}
//type PayConfig struct {
// MemberFee uint32 `json:"member_fee"`
// DepositFee uint32 `json:"deposit_fee"`
// NotifyUrl string `json:"notify_url"`
// RefundNotifyUrl string `json:"refund_notify_url"`
//}
type MemberStatisticDaily struct {
Model
MemberLevel uint32 `json:"member_level"`
Date string `json:"date"`
DateTime time.Time `json:"date_time"`
Increase int64 `json:"increase"`
Expire int64 `json:"expire"`
Net int64 `json:"net"`
Accumulative int64 `json:"accumulative"`
// member_statistic_daily
}
func IndexMemberStatistic() {
fmt.Println("会员数据统计开始")
levels := []uint32{2, 4, 5}
today := TodayZero()
//today, _ = time.Parse(TimeFormat, "2022-08-09 00:00:00")
for i, _ := range levels {
IndexMemberLevelStatistic(levels[i], today)
}
fmt.Println("会员数据统计完成...")
}
func IndexMemberLevelStatistic(level uint32, date time.Time) {
var (
increase, expire, net, accumulative, origination int64
)
startDate := date.AddDate(0, 0, -1)
endDate := date
err := orm.Eloquent.Table("user").Where("member_level=?", level).
Where("open_member_time>?", startDate).
Where("open_member_time<?", endDate).Count(&increase).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("increase err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
err = orm.Eloquent.Table("user").Where("member_level=?", level).
Where("member_expire>?", startDate).
Where("member_expire<?", endDate).Count(&expire).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("increase err:%#v", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
//// TODO
//var statisticDaily MemberStatisticDaily
//err = orm.Eloquent.Table("member_statistic_daily").Where("member_level=?", level).
// //Where("open_member_time>?", time.Time{}).
// Where("date=?", startDate.AddDate(0, 0, -1).Format(DateFormat)).
// Find(&statisticDaily).Error
//if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("increase err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
//}
//fmt.Println("increase:", increase)
//fmt.Println("expire:", expire)
memberRecordType := 0
if level == 2 {
memberRecordType = 4
} else if level == 4 {
memberRecordType = 5
} else if level == 5 {
memberRecordType = 6
}
if memberRecordType != 0 {
err = orm.Eloquent.Table("user_member_record").Where("type=?", memberRecordType).
Where("created_at>?", startDate).Where("created_at<?", endDate).Count(&origination).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("origination err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
increase += origination
net = increase - expire
//accumulative = statisticDaily.Accumulative + increase
err = orm.Eloquent.Table("user").Where("member_level=?", level).
Where("member_expire>?", time.Now()).Count(&accumulative).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("increase err:%#v", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
fmt.Println("net:", net)
daily := &MemberStatisticDaily{
MemberLevel: level,
Date: startDate.Format(DateFormat),
DateTime: startDate,
Increase: increase,
Expire: expire,
Net: net,
Accumulative: accumulative,
}
err = orm.Eloquent.Create(&daily).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("create member statistic daily err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
}
type MemberStatisticDailyListReq struct {
MemberLevel uint32 `json:"member_level"`
//StartDate string `json:"start_date"`
//EndDate string `json:"end_date"`
StartDate time.Time `json:"start_date"`
EndDate time.Time `json:"end_date"`
Days uint32 `json:"days"`
IsExport uint32 `json:"is_export"` // 1-导出
PageNum int `json:"pageIndex"`
PageSize int `json:"pageSize"`
}
type MemberStatisticDailyListRsp struct {
Count int64 `json:"count"`
List []MemberStatisticDaily `json:"list"`
PageIndex int `json:"pageIndex"`
Url string `json:"url"`
}
func (m *MemberStatisticDailyListReq) List() (*MemberStatisticDailyListRsp, error) {
rsp := &MemberStatisticDailyListRsp{
PageIndex: m.PageNum,
}
m.PageNum = m.PageNum - 1
if m.PageNum < 0 {
m.PageNum = 0
}
if m.Days > 0 {
m.PageSize = int(m.Days)
}
qs := orm.Eloquent.Table("member_statistic_daily")
//if m.StartDate != "" {
// start, _ := time.Parse(DateTimeFormat, m.StartDate)
// qs = qs.Where("date_time>=?", start)
//}
//if m.EndDate != "" {
// end, _ := time.Parse(DateTimeFormat, m.EndDate)
// qs = qs.Where("date_time<=?", end)
//}
if !m.StartDate.IsZero() {
qs = qs.Where("date_time>=?", m.StartDate)
}
if !m.EndDate.IsZero() {
qs = qs.Where("date_time<=?", m.EndDate)
}
if m.Days > 0 {
//end := TodayZero()
//start := end.AddDate(0, 0, int(m.Days)*(-1))
qs = qs.Where("date_time>=?", m.StartDate)
qs = qs.Where("date_time<=?", m.EndDate)
}
if m.MemberLevel != 0 {
qs = qs.Where("member_level=?", m.MemberLevel)
}
var dailys []MemberStatisticDaily
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("count err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return rsp, err
}
rsp.Count = count
//err = qs.Order("id DESC").Offset(m.PageNum * m.PageSize).Limit(m.PageSize).Find(&dailys).Error
if m.IsExport == 1 {
err = qs.Order("date_time DESC").Find(&dailys).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("dailys err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return rsp, err
}
listExport, err := MemberStatisticDailyListExport(dailys)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("list export err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
rsp.Url = listExport
} else {
err = qs.Order("date_time DESC").Offset(m.PageNum * m.PageSize).Limit(m.PageSize).Find(&dailys).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("dailys err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return rsp, err
}
rsp.List = dailys
}
return rsp, nil
}
func MemberStatisticDailyListExport(dailys []MemberStatisticDaily) (string, error) {
file := excelize.NewFile()
streamWriter, err := file.NewStreamWriter("Sheet1")
if err != nil {
fmt.Println(err)
}
//url := "http://39.108.188.218:8000/img/export/"
fileName := "会员统计" + time.Now().Format("2006-01-02 15:04:05") + ".xlsx"
title := []interface{}{"时间", "新增会员数", "会员过期数", "净增会员数", "累计会员数"}
cell, _ := excelize.CoordinatesToCellName(1, 1)
if err = streamWriter.SetRow(cell, title); err != nil {
fmt.Println(err)
}
var row []interface{}
for rowId := 0; rowId < len(dailys); rowId++ {
row = []interface{}{dailys[rowId].Date, dailys[rowId].Increase, dailys[rowId].Expire, dailys[rowId].Net, dailys[rowId].Accumulative}
cell, _ := excelize.CoordinatesToCellName(1, rowId+2)
if err := streamWriter.SetRow(cell, row); err != nil {
fmt.Println(err)
}
}
if err := streamWriter.Flush(); err != nil {
fmt.Println(err)
}
if err := file.SaveAs("/www/server/images/export/" + fileName); err != nil {
fmt.Println(err)
}
return ExportUrl + fileName, nil
}
func UserInviteRecordListSetAssistantName(records []UserInviteRecord) {
uids := make([]uint32, 0, len(records))
for i, _ := range records {
if records[i].ShopAssistantName == "" {
uids = append(uids, records[i].FromUid)
}
}
infoMap, err := GetUserInfoMap(uids)
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("info map err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
}
for i, _ := range records {
v, ok := infoMap[records[i].FromUid]
if ok && records[i].ShopAssistantName == "" {
records[i].ShopAssistantName = v.ShopAssistantName
}
}
}
type ExpireMemberSmsSendListReq struct {
Status uint32 `json:"status"` // 1-待发送 2-已发送
Tel string `json:"tel"`
//StartTime string `json:"start_time"` // 开始时间
//EndTime string `json:"end_time"` // 结束时间
StartTime time.Time `json:"start_time"` // 开始时间
EndTime time.Time `json:"end_time"` // 结束时间
PageNum int `json:"page_num"`
PageSize int `json:"page_size"`
}
type ExpireMemberSmsSendListResp struct {
List []ExpireMemberSmsSend `json:"list"`
Count uint32 `json:"count"`
PageNum int `json:"pageIndex"`
}
func (m *ExpireMemberSmsSendListReq) List() (*ExpireMemberSmsSendListResp, error) {
resp := &ExpireMemberSmsSendListResp{PageNum: m.PageNum}
qs := orm.Eloquent.Table("expire_member_sms_send")
if m.Status != 0 {
qs = qs.Where("status=?", m.Status)
}
if m.Tel != "" {
qs = qs.Where("tel LIKE '%" + m.Tel + "%'")
}
//if m.StartTime != "" {
// parse, err := time.Parse(DateTimeFormat, m.StartTime)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Errorf("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return resp, err
// }
// qs = qs.Where("send_time > ?", parse)
//}
//if m.EndTime != "" {
// parse, err := time.Parse(DateTimeFormat, m.EndTime)
// if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Errorf("err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return resp, err
// }
// parse = parse.AddDate(0, 0, 1)
// qs = qs.Where("send_time < ?", parse)
//}
if !m.StartTime.IsZero() {
qs = qs.Where("send_time > ?", m.StartTime)
}
if !m.EndTime.IsZero() {
parse := m.EndTime.AddDate(0, 0, 1)
qs = qs.Where("send_time < ?", parse)
}
page := m.PageNum - 1
if page < 0 {
page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
var count int64
err := qs.Count(&count).Error
if err != nil {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("count err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.Count = uint32(count)
var smsSends []ExpireMemberSmsSend
err = qs.Order("id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&smsSends).Error
if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
logger.Error("err:", logger.Field("err", err))
fix:
2023-09-16 02:56:39 +00:00
return resp, err
}
resp.List = smsSends
return resp, nil
}
//func (m *MemberStatisticDailyListReq) Export() (string, error) {
// qs := orm.Eloquent.Table("member_statistic_daily")
// if !m.StartDate.IsZero() {
// qs = qs.Where("date_time>=?", m.StartDate)
// }
// if !m.EndDate.IsZero() {
// qs = qs.Where("date_time<=?", m.EndDate)
// }
// if m.Days > 0 {
// qs = qs.Where("date_time>=?", m.StartDate)
// qs = qs.Where("date_time<=?", m.EndDate)
// }
// if m.MemberLevel != 0 {
// qs = qs.Where("member_level=?", m.MemberLevel)
// }
// var dailys []MemberStatisticDaily
// err := qs.Order("date_time DESC").Find(&dailys).Error
// if err != nil && err != RecordNotFound {
重构日志
2023-10-14 08:19:04 +00:00
// logger.Error("dailys err:",logger.Field("err",err))
fix:
2023-09-16 02:56:39 +00:00
// return "", err
// }
//
// file := excelize.NewFile()
// streamWriter, err := file.NewStreamWriter("Sheet1")
// if err != nil {
// fmt.Println(err)
// }
//
// url := "http://39.108.188.218:8000/img/export/"
// fileName := "/www/server/images/export/" + "会员统计" + time.Now().Format("2006-01-02 15:04:05") + ".xlsx"
//
// title := []interface{}{"时间", "新增会员数", "会员过期数", "净增会员数", "累计会员数"}
// cell, _ := excelize.CoordinatesToCellName(1, 1)
// if err = streamWriter.SetRow(cell, title); err != nil {
// fmt.Println(err)
// }
// var row []interface{}
// for rowId := 0; rowId < len(dailys); rowId++ {
// row = []interface{}{dailys[rowId].Date, dailys[rowId].Increase, dailys[rowId].Expire, dailys[rowId].Net, dailys[rowId].Accumulative}
// cell, _ := excelize.CoordinatesToCellName(1, rowId+2)
// if err := streamWriter.SetRow(cell, row); err != nil {
// fmt.Println(err)
// }
// }
// if err := streamWriter.Flush(); err != nil {
// fmt.Println(err)
// }
// if err := file.SaveAs(fileName); err != nil {
// fmt.Println(err)
// }
// return url + fileName, nil
//}
标记用户
2023-09-26 05:56:34 +00:00
func MarkUser(uid []uint32, mark int8) error {
return orm.Eloquent.Table("user").
Where("uid in (?)", uid).
Update("mark", mark).Error
}
手机尾号
2023-09-26 08:11:16 +00:00
// CheckPhoneExt 检测手机尾号是否一致
func (m *UserInfo) CheckPhoneExt(ext string, length int) bool {
if ext == "" || m.Tel == "" {
return false
}
total := len(m.Tel)
if total >= length {
sub := m.Tel[total-4:]
return sub == ext
} else {
return false
}
}
1.增加零售订单相关接口； 2.增加查询会员手机号接口； 3.修改库存导入串码规则； 4.查询库存详情增加出参求和字段； 5.日志初始化位置调整；
2023-12-19 10:21:44 +00:00
type TelListReq struct {
PhoneNum string `json:"phone_num" binding:"required"`
PageIndex int `json:"pageIndex"` // 页码
PageSize int `json:"pageSize"` // 页面条数
}
type TelListResp struct {
List []UserInfo `json:"list"`
Total int `json:"total"` // 总条数
PageIndex int `json:"pageIndex"` // 页码
PageSize int `json:"pageSize"` // 每页展示条数
}
func (m *TelListReq) GetTelList() (*TelListResp, error) {
resp := &TelListResp{
PageIndex: m.PageIndex,
PageSize: m.PageSize,
}
page := m.PageIndex - 1
if page < 0 {
page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
var count int64
qs := orm.Eloquent.Table("user").Where("tel like ?", "%"+m.PhoneNum+"%")
err := qs.Count(&count).Error
if err != nil {
logger.Error("count err:", logger.Field("err", err))
return nil, err
}
var userInfo []UserInfo
err = qs.Order("id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&userInfo).Error
if err != nil {
logger.Error("find err:", logger.Field("err", err))
return nil, err
}
resp.List = userInfo
//跟之前保持一致
resp.Total = int(count)
resp.PageIndex = page + 1
resp.PageSize = m.PageSize
return resp, nil
}
Reference in New Issue Copy Permalink