minghui/mh_server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix:签到领积分

Browse Source
This commit is contained in:
li 2022-04-26 14:28:41 +08:00
parent d8dc78f590
commit 510a62fb85
13 changed files with 2176 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
controller/game_card.go
View File

@ -715,6 +715,7 @@ func PushWXPayRefundNotice(c *gin.Context) {
//if err != nil {
// logger.Error(err)
//}
mchID := "1609877389"
mchAPIv3Key := "DeovoMingHuiRengTianTang45675123" // 商户APIv3密钥
mchCertificateSerialNumber := "7540301D8FD52CCF7D6267DCF7CD2BC0AB467EFF" // 商户证书序列号
@ -745,22 +746,25 @@ func PushWXPayRefundNotice(c *gin.Context) {
// 处理通知内容
//fmt.Println(notifyReq.Summary)
//fmt.Println(transaction.TransactionId)
//
//transactionJson, _ := json.Marshal(transaction)
//fmt.Println("transactionJson:", string(transactionJson))
//
//notifyReqJson, _ := json.Marshal(notifyReq)
//fmt.Println("notifyReqJson:", string(notifyReqJson))
if notifyReq.EventType == "REFUND.SUCCESS" {
plaintext := new(WxPayRefundPlaintext)
err = json.Unmarshal([]byte(notifyReq.Resource.Plaintext), plaintext)
if err != nil {
logger.Error("unmarshal plaintext err:", err)
return
}
count, err := model.NewFundRecordQuerySet(model.DB).RefundIdEq(plaintext.RefundId).Count()
if err != nil {
logger.Error("count refund id err:", err)
return
}
if count == 0 {
openMemberRecord := new(model.UserOpenMemberRecord)
err = model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(plaintext.OutTradeNo).One(openMemberRecord)
if err != nil {
logger.Error("user open member record err:", err)
@ -781,6 +785,8 @@ func PushWXPayRefundNotice(c *gin.Context) {
logger.Error("create fund record err:", err)
return
}
}
}
RespNotice(c, "SUCCESS", "成功")
return

5
controller/order.go
View File

@ -290,11 +290,6 @@ func RentCardOrderCreate(c *gin.Context) {
return
}
//if req.DeliveryType == 1 {
//}
reqJson, _ := json.Marshal(&req)
fmt.Println("reqJson:", string(reqJson))
// 邮费
orderSn := model.GetOrderSn()

222
controller/user.go
View File

@ -7,6 +7,7 @@ import (
"github.com/gin-gonic/gin"
"mh-server/lib/auth"
"mh-server/lib/status"
"mh-server/lib/utils"
"mh-server/lib/wxpay"
"mh-server/model"
"time"
@ -746,6 +747,227 @@ func MemberConfigList(c *gin.Context) {
RespOK(c, resp)
}
func UserAttendance(c *gin.Context) {
uc := auth.GetCurrentUser(c)
if uc == nil {
RespJson(c, status.Unauthorized, nil)
return
}
//model.NewUserAttendanceRecordQuerySet()
todayZero := utils.TodayZeroDateFormat()
recordExist, err := model.QueryRecordExist(
fmt.Sprintf("SELECT * FROM user_attendance_record WHERE attendance_date = '%s' AND uid=%d", todayZero, uc.Uid))
if err != nil {
logger.Error("record exist err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if recordExist {
logger.Error("user consecutive")
RespJson(c, status.InternalServerError, nil)
return
}
configInfo, err := model.AttendanceVmConfigInfo()
if err != nil {
logger.Error("attendance vm config info err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
attendanceTime := time.Now()
record := &model.UserAttendanceRecord{
Uid: uc.Uid,
AttendanceTime: attendanceTime,
Vm: configInfo.VmDay1,
AttendanceDate: todayZero,
}
var userAttendance model.UserAttendance
err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).One(&userAttendance)
if err != nil && err != model.RecordNotFound {
logger.Error("user attendance err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if err == model.RecordNotFound {
userAttendance = model.UserAttendance{
Uid: uc.Uid,
LatestTime: attendanceTime,
ConsecutiveDays: 1,
IndexDay: 1,
}
err = model.DB.Create(&userAttendance).Error
if err != nil {
logger.Error("create user attendance err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
err = record.Add(model.VmEventAttendance, "连续签到获取积分")
if err != nil {
logger.Error("add user attendance record err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, nil)
return
}
var attendanceRecord model.UserAttendanceRecord
err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().Limit(1).One(&attendanceRecord)
if err != nil && err != model.RecordNotFound {
logger.Error(" user attendance record err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if attendanceRecord.AttendanceDate == "" || attendanceRecord.AttendanceDate != utils.TodayZeroAddDaysDateFormat(-1) {
err = record.Add(model.VmEventAttendance, "连续签到获取积分")
if err != nil {
logger.Error("add user attendance record err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
_, err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetConsecutiveDays(1).
SetIndexDay(1).SetLatestTime(time.Now()).UpdateNum()
if err != nil {
logger.Error("update user attendance err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, nil)
return
}
userAttendance.ConsecutiveDays += 1
userAttendance.IndexDay = userAttendance.ConsecutiveDays % 7
if userAttendance.IndexDay == 0 {
userAttendance.IndexDay = 7
}
record.Vm = configInfo.Vm(userAttendance.ConsecutiveDays)
err = record.Add(model.VmEventAttendance, "连续签到获取积分")
if err != nil {
logger.Error("add user attendance record err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
_, err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetConsecutiveDays(userAttendance.ConsecutiveDays).
SetIndexDay(userAttendance.IndexDay).SetLatestTime(time.Now()).UpdateNum()
if err != nil {
logger.Error("update user attendance err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, nil)
return
}
func UserAttendanceDetail(c *gin.Context) {
uc := auth.GetCurrentUser(c)
if uc == nil {
RespJson(c, status.Unauthorized, nil)
return
//uc = &auth.UserClaims{Uid: 51141053}
}
list := make([]model.AttendanceInfo, 0, 7)
configInfo, err := model.AttendanceVmConfigInfo()
if err != nil {
logger.Error("attendance vm config info err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
todayZero := utils.TodayZeroDateFormat()
//var attendanceRecord model.UserAttendanceRecord
//err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).AttendanceDateEq(utils.TodayZeroAddDaysDateFormat(-1)).One(&attendanceRecord)
//if err != nil && err != model.RecordNotFound {
// logger.Error("user attendance record err:")
// RespJson(c, status.InternalServerError, nil)
// return
//}
recordExist, err := model.QueryRecordExist(
fmt.Sprintf("SELECT * FROM user_attendance_record WHERE attendance_date in ('%s','%s') AND uid=%d", utils.TodayZeroAddDaysDateFormat(-1), todayZero, uc.Uid))
if err != nil {
logger.Error("record exist err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if !recordExist {
for i := 0; i < 7; i++ {
info := model.AttendanceInfo{
IndexDay: uint32(i) + 1,
Date: utils.TodayZeroAddDaysDateFormat(i),
State: 1,
Vm: configInfo.Vm(uint32(i) + 1),
}
list = append(list, info)
}
ret := map[string]interface{}{
"list": list,
"is_attendance": 1,
}
RespOK(c, ret)
return
}
var attendanceRecord model.UserAttendanceRecord
//err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).AttendanceDateEq(todayZero).One(&attendanceRecord)
err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().Limit(1).One(&attendanceRecord)
if err != nil && err != model.RecordNotFound {
logger.Error("user attendance record err:")
RespJson(c, status.InternalServerError, nil)
return
}
var userAttendance model.UserAttendance
err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).One(&userAttendance)
if err != nil && err != model.RecordNotFound {
logger.Error("user attendance record err:")
RespJson(c, status.InternalServerError, nil)
return
}
attendanceDays := int(userAttendance.ConsecutiveDays % 7)
if attendanceDays == 0 && attendanceRecord.AttendanceDate == todayZero {
attendanceDays = 7
}
//attendanceDays += 1
days := attendanceDays
for i := 0; i < 7; i++ {
state := uint32(1)
if attendanceDays > 0 {
state = 2
}
info := model.AttendanceInfo{
IndexDay: uint32(i) + 1,
//Date: utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
//Date: utils.TodayZeroAddDaysDateFormat(i + 1 - days),
Date: utils.TodayZeroAddDaysDateFormat(i - days),
State: state,
Vm: configInfo.Vm(uint32(i) + 1),
}
list = append(list, info)
attendanceDays--
}
isAttendance := 1
if attendanceRecord.AttendanceDate == todayZero {
isAttendance = 2
}
ret := map[string]interface{}{
"list": list,
"is_attendance": isAttendance,
}
RespOK(c, ret)
return
}
// 升级 1-黄金会员 2-白金会员 3-黑金会员
// 开通会员
// 升级会员

6
lib/utils/csttime.go
View File

@ -11,7 +11,7 @@ const (
DateFormat = "2006-01-02"
)
func TodayZeroFormat() string {
func TodayZeroTimeFormat() string {
return TodayZero().Format(TimeFormat)
}
@ -35,6 +35,10 @@ func TodayZeroAddDays(days int) time.Time {
return TodayZero().AddDate(0, 0, days)
}
func TodayZeroAddDaysDateFormat(days int) string {
return TodayZero().AddDate(0, 0, days).Format(DateFormat)
}
func YesterdayZero() time.Time {
return TodayZeroAddDays(-1)
}

1487
model/autogenerated_task.go Normal file
View File

File diff suppressed because it is too large Load Diff

180
model/autogenerated_user.go
View File

@ -1919,6 +1919,18 @@ func (qs FundRecordQuerySet) OrderAscByOutTradeNo() FundRecordQuerySet {
return qs.w(qs.db.Order("out_trade_no ASC"))
}
// OrderAscByRefundId is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderAscByRefundId() FundRecordQuerySet {
return qs.w(qs.db.Order("refund_id ASC"))
}
// OrderAscByRemark is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderAscByRemark() FundRecordQuerySet {
return qs.w(qs.db.Order("remark ASC"))
}
// OrderAscByStatus is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderAscByStatus() FundRecordQuerySet {
@ -1979,6 +1991,18 @@ func (qs FundRecordQuerySet) OrderDescByOutTradeNo() FundRecordQuerySet {
return qs.w(qs.db.Order("out_trade_no DESC"))
}
// OrderDescByRefundId is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderDescByRefundId() FundRecordQuerySet {
return qs.w(qs.db.Order("refund_id DESC"))
}
// OrderDescByRemark is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderDescByRemark() FundRecordQuerySet {
return qs.w(qs.db.Order("remark DESC"))
}
// OrderDescByStatus is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) OrderDescByStatus() FundRecordQuerySet {
@ -2071,6 +2095,142 @@ func (qs FundRecordQuerySet) OutTradeNoNotlike(outTradeNo string) FundRecordQuer
return qs.w(qs.db.Where("out_trade_no NOT LIKE ?", outTradeNo))
}
// RefundIdEq is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdEq(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id = ?", refundId))
}
// RefundIdGt is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdGt(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id > ?", refundId))
}
// RefundIdGte is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdGte(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id >= ?", refundId))
}
// RefundIdIn is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdIn(refundId ...string) FundRecordQuerySet {
if len(refundId) == 0 {
qs.db.AddError(errors.New("must at least pass one refundId in RefundIdIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("refund_id IN (?)", refundId))
}
// RefundIdLike is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdLike(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id LIKE ?", refundId))
}
// RefundIdLt is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdLt(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id < ?", refundId))
}
// RefundIdLte is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdLte(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id <= ?", refundId))
}
// RefundIdNe is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdNe(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id != ?", refundId))
}
// RefundIdNotIn is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdNotIn(refundId ...string) FundRecordQuerySet {
if len(refundId) == 0 {
qs.db.AddError(errors.New("must at least pass one refundId in RefundIdNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("refund_id NOT IN (?)", refundId))
}
// RefundIdNotlike is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RefundIdNotlike(refundId string) FundRecordQuerySet {
return qs.w(qs.db.Where("refund_id NOT LIKE ?", refundId))
}
// RemarkEq is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkEq(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark = ?", remark))
}
// RemarkGt is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkGt(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark > ?", remark))
}
// RemarkGte is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkGte(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark >= ?", remark))
}
// RemarkIn is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkIn(remark ...string) FundRecordQuerySet {
if len(remark) == 0 {
qs.db.AddError(errors.New("must at least pass one remark in RemarkIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("remark IN (?)", remark))
}
// RemarkLike is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkLike(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark LIKE ?", remark))
}
// RemarkLt is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkLt(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark < ?", remark))
}
// RemarkLte is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkLte(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark <= ?", remark))
}
// RemarkNe is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkNe(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark != ?", remark))
}
// RemarkNotIn is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkNotIn(remark ...string) FundRecordQuerySet {
if len(remark) == 0 {
qs.db.AddError(errors.New("must at least pass one remark in RemarkNotIn"))
return qs.w(qs.db)
}
return qs.w(qs.db.Where("remark NOT IN (?)", remark))
}
// RemarkNotlike is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) RemarkNotlike(remark string) FundRecordQuerySet {
return qs.w(qs.db.Where("remark NOT LIKE ?", remark))
}
// StatusEq is an autogenerated method
// nolint: dupl
func (qs FundRecordQuerySet) StatusEq(status uint32) FundRecordQuerySet {
@ -2329,6 +2489,20 @@ func (u FundRecordUpdater) SetOutTradeNo(outTradeNo string) FundRecordUpdater {
return u
}
// SetRefundId is an autogenerated method
// nolint: dupl
func (u FundRecordUpdater) SetRefundId(refundId string) FundRecordUpdater {
u.fields[string(FundRecordDBSchema.RefundId)] = refundId
return u
}
// SetRemark is an autogenerated method
// nolint: dupl
func (u FundRecordUpdater) SetRemark(remark string) FundRecordUpdater {
u.fields[string(FundRecordDBSchema.Remark)] = remark
return u
}
// SetStatus is an autogenerated method
// nolint: dupl
func (u FundRecordUpdater) SetStatus(status uint32) FundRecordUpdater {
@ -2394,7 +2568,9 @@ var FundRecordDBSchema = struct {
Amount FundRecordDBSchemaField
TransactionId FundRecordDBSchemaField
OutTradeNo FundRecordDBSchemaField
RefundId FundRecordDBSchemaField
Status FundRecordDBSchemaField
Remark FundRecordDBSchemaField
}{
ID: FundRecordDBSchemaField("id"),
@ -2406,7 +2582,9 @@ var FundRecordDBSchema = struct {
Amount: FundRecordDBSchemaField("amount"),
TransactionId: FundRecordDBSchemaField("transaction_id"),
OutTradeNo: FundRecordDBSchemaField("out_trade_no"),
RefundId: FundRecordDBSchemaField("refund_id"),
Status: FundRecordDBSchemaField("status"),
Remark: FundRecordDBSchemaField("remark"),
}
// Update updates FundRecord fields by primary key
@ -2422,7 +2600,9 @@ func (o *FundRecord) Update(db *gorm.DB, fields ...FundRecordDBSchemaField) erro
"amount": o.Amount,
"transaction_id": o.TransactionId,
"out_trade_no": o.OutTradeNo,
"refund_id": o.RefundId,
"status": o.Status,
"remark": o.Remark,
}
u := map[string]interface{}{}
for _, f := range fields {

51
model/config.go
View File

@ -30,6 +30,7 @@ const (
ConfigNamePay = "pay_config" // 支付配置
ConfigNameMember = "member_config" // 会员配置
ConfigNameMemberVm = "member_vm_config" // 会员积分配置
ConfigNameAttendanceVm = "attendance_vm_config" // 签到积分配置
)
func PayConfigInfo() (*PayConfig, error) {
@ -135,6 +136,56 @@ func GetMemberVmConfig(level uint32) (*MemberVmConfig, error) {
return nil, errors.New("level err")
}
type AttendanceVmConfig struct {
VmDay1 uint32 `json:"vm_day_1"`
VmDay2 uint32 `json:"vm_day_2"`
VmDay3 uint32 `json:"vm_day_3"`
VmDay4 uint32 `json:"vm_day_4"`
VmDay5 uint32 `json:"vm_day_5"`
VmDay6 uint32 `json:"vm_day_6"`
VmDay7 uint32 `json:"vm_day_7"`
}
func AttendanceVmConfigInfo() (*AttendanceVmConfig, error) {
attendanceConfig := new(AttendanceVmConfig)
var configAllocation Config
err := NewConfigQuerySet(DB).NameEq(ConfigNameAttendanceVm).One(&configAllocation)
if err != nil {
logger.Error("err:", err)
return attendanceConfig, err
}
err = json.Unmarshal([]byte(configAllocation.Value), attendanceConfig)
if err != nil {
logger.Error("err:", err)
return attendanceConfig, err
}
return attendanceConfig, nil
}
func (m *AttendanceVmConfig) Vm(days uint32) uint32 {
vm := uint32(0)
switch days % 7 {
case 1:
vm = m.VmDay1
case 2:
vm = m.VmDay2
case 3:
vm = m.VmDay3
case 4:
vm = m.VmDay4
case 5:
vm = m.VmDay5
case 6:
vm = m.VmDay6
case 0:
vm = m.VmDay7
}
return vm
}
//type ConfigInterface interface {
// Encode() string
//}

110
model/model_test.go
View File

@ -4,6 +4,9 @@ import (
"crypto/sha512"
"encoding/json"
"fmt"
"mh-server/lib/auth"
"mh-server/lib/utils"
//"github.com/andreburgaud/crypt2go/ecb"
//"github.com/andreburgaud/crypt2go/padding"
"github.com/codinl/go-logger"
@ -124,6 +127,8 @@ func InitTestDB() {
&GameCard{},
&FundRecord{},
&User{},
&UserAttendance{},
&UserAttendanceRecord{},
)
fmt.Println("DB init success")
@ -988,5 +993,108 @@ func TestTimeZeroData(t *testing.T) {
}
func TestWxPayDecode(t *testing.T) {
config := AttendanceVmConfig{
VmDay1: 2,
VmDay2: 4,
VmDay3: 6,
VmDay4: 8,
VmDay5: 10,
VmDay6: 12,
VmDay7: 14,
}
marshal, _ := json.Marshal(&config)
fmt.Println("config:", string(marshal))
}
func TestAtt(t *testing.T) {
InitTestDB()
DB = DBDev
UserAttendanceDays()
}
func UserAttendanceDays() {
uc := &auth.UserClaims{Uid: 31871993}
list := make([]AttendanceInfo, 0, 7)
todayZero := utils.TodayZeroDateFormat()
configInfo, err := AttendanceVmConfigInfo()
if err != nil {
logger.Error("attendance vm config info err:", err)
//RespJson(c, status.InternalServerError, nil)
return
}
var attendanceRecord UserAttendanceRecord
err = NewUserAttendanceRecordQuerySet(DB).UidEq(uc.Uid).AttendanceDateEq(todayZero).One(&attendanceRecord)
if err != nil && err != RecordNotFound {
logger.Error("user attendance record err:")
//RespJson(c, status.InternalServerError, nil)
return
}
if err == RecordNotFound {
for i := 0; i < 7; i++ {
info := AttendanceInfo{
IndexDay: uint32(i) + 1,
Date: utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
State: 1,
Vm: configInfo.Vm(uint32(i) + 1),
}
list = append(list, info)
}
ret := map[string]interface{}{
"list": list,
"is_attendance": 1,
}
retJson, _ := json.Marshal(&ret)
fmt.Println("ret:", string(retJson))
//RespOK(c, ret)
return
}
var userAttendance UserAttendance
err = NewUserAttendanceQuerySet(DB).UidEq(uc.Uid).One(&userAttendance)
if err != nil && err != RecordNotFound {
logger.Error("user attendance record err:")
//RespJson(c, status.InternalServerError, nil)
return
}
attendanceDays := int(userAttendance.ConsecutiveDays % 7)
if attendanceDays == 0 {
attendanceDays = 7
}
days := attendanceDays
fmt.Println("--------attendanceDays:", attendanceDays)
for i := 0; i < 7; i++ {
state := uint32(1)
if attendanceDays > 0 {
state = 2
}
fmt.Println("attendanceDays:", attendanceDays)
info := AttendanceInfo{
IndexDay: uint32(i) + 1,
//Date: utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
Date: utils.TodayZeroAddDaysDateFormat(i + 1 - days),
State: state,
Vm: configInfo.Vm(uint32(i) + 1),
}
list = append(list, info)
attendanceDays--
}
isAttendance := 1
if attendanceRecord.AttendanceDate == todayZero {
isAttendance = 2
}
ret := map[string]interface{}{
"list": list,
"is_attendance": isAttendance,
}
retJson, _ := json.Marshal(&ret)
fmt.Println("ret:", string(retJson))
}

2
model/share_card.go
View File

@ -671,7 +671,7 @@ func (m *ShareCardRetrieveCreateReq) RetrieveCreate() (*ShareCardRetrieve, error
return nil, err
}
//gameIds := make([]uint64, 0)
//for i, _ := range userShareCards {
//for i, _ := range user{
// gameIds = append(gameIds, uint64(userShareCards[i].GameCardId))
//}
//// TODO 共享卡半年收回 测试上线修改

66
model/task.go Normal file
View File

@ -0,0 +1,66 @@
package model
import (
"github.com/codinl/go-logger"
"time"
)
//go:generate goqueryset -in task.go
// gen:qs
//type Task struct {
// Model
//
// Name string `json:"name" gorm:"comment:'任务名称'"`
// NameKey string `json:"name_key" gorm:"comment:'任务名称key'"`
// TaskType string `json:"task_type" gorm:"comment:'任务类型（1 活跃任务 2 日常任务 3 新手任务）'"` // 任务类型
// IsOnline bool `json:"is_online" gorm:"comment:'是否上线（1 上线 2 不上线）'"` // 是否上线
// Sort uint32 `json:"sort" gorm:"comment:'排序'"` // 排序
//}
// gen:qs
type UserAttendance struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
LatestTime time.Time `json:"latest_time" gorm:"index"`
ConsecutiveDays uint32 `json:"consecutive_days" gorm:"index"`
IndexDay uint32 `json:"index_day"`
// user_attendance
}
// gen:qs
type UserAttendanceRecord struct {
Model
Uid uint32 `json:"uid" gorm:"index"`
AttendanceTime time.Time `json:"attendance_time"`
Vm uint32 `json:"vm"`
AttendanceDate string `json:"attendance_date" gorm:"index"`
// user_attendance_record
}
func (m *UserAttendanceRecord) Add(event, describe string) error {
err := UserVmUpdate(m.Uid, int(m.Vm), event, describe)
if err != nil {
logger.Error("update user vm err:", err)
return err
}
err = DB.Create(m).Error
if err != nil {
logger.Error("create user attendance record err:", err)
return err
}
return nil
}
type AttendanceInfo struct {
IndexDay uint32 `json:"index_day"`
Date string `json:"date"`
State uint32 `json:"state"` // 1-未签到 2-签到
Vm uint32 `json:"vm"`
}
// 2 4 6 8 10 12 14

27
model/user.go
View File

@ -109,9 +109,6 @@ type DepositRefundRecord struct {
}
const (
FundTypeMemberFee = "member_fee"
FundTypeMemberDeposit = "member_deposit"
//FundTypeMemberGold = "member_gold" // 黄金会员
//FundTypeMemberPlatinum = "member_platinum" // 白金会员
//FundTypeMemberBlackGold = "member_black_gold" // 黑金会员
@ -119,6 +116,8 @@ const (
//FundTypeMemberPlatinumDeposit = "member_platinum_deposit" // 白金会员押金
//FundTypeMemberBlackGoldDeposit = "member_black_gold_platinum" // 黑金会员押金
FundTypeMemberFee = "member_fee" // 会员费
FundTypeMemberDeposit = "member_deposit" // 押金
FundTypeExpressFee = "express_fee" // 邮费
FundTypeUpgradeMember = "upgrade_member" // 升级会员
FundTypeMemberExpireDelay = "member_expire_delay" // 滞纳金
@ -129,12 +128,13 @@ const (
// gen:qs
type FundRecord struct {
Model
Uid uint32 `json:"uid"`
FundType string `json:"fund_type"` // -member_gold -member_platinum -member_black_gold
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"` // 支付单号
OutTradeNo string `json:"out_trade_no"`
RefundId string `json:"refund_id"`
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"` // 备注
}
@ -337,16 +337,7 @@ func (m *UserOpenMemberRecord) ShareCardRetrieveRefund(outTradeNo string) error
// logger.Error("err:", err)
// return err
//}
//
////FundRecord{
//// Uid: m.Uid,
//// FundType: FundTypeExpressFeeRefund,
//// Amount: int64(m.Order.PayPrice) * (-1),
//// TransactionId: "",
//// OutTradeNo: "",
//// Status: 0,
//// Remark: "",
////}
return nil
}

1
model/user_vm.go
View File

@ -11,6 +11,7 @@ const (
VmEventOpenMember = "open_member"
VmEventInvite1Member = "invite_1_member"
VmEventInvite2Member = "invite_2_member"
VmEventAttendance = "attendance"
)
// 用户积分

4
router/router_app.go
View File

@ -71,6 +71,7 @@ func ConfigAppRouter(r gin.IRouter) {
user := api.Group("user")
{
user.Use(auth.UserAccessAuth) //
user.POST("data", controller.UserData) // 用户数据
user.POST("user_info/upload", controller.UserInfoUpload) // 上传用户信息
@ -84,7 +85,8 @@ func ConfigAppRouter(r gin.IRouter) {
user.POST("refund_deposit_record", controller.UserDepositRefundRecordList) // 押金记录
user.POST("expire_delay", controller.UserMemberExpireDelayingInfo) // 滞纳金详情
user.POST("expire_delay_pay", controller.UserMemberExpireDelayingPay) // 滞纳金支付
user.POST("attendance", controller.UserAttendance) // 签到
user.POST("attendance/detail", controller.UserAttendanceDetail) // 签到详情
user.POST("member_config", controller.MemberConfigList) // 开通会员配置
user.POST("common_problem/list", controller.CommonProblemList) // 常见问题列表