fix:签到领积分

controller/game_card.go

@@ -715,6 +715,7 @@ func PushWXPayRefundNotice(c *gin.Context) {
 	//if err != nil {
 	//	logger.Error(err)
 	//}
+
 	mchID := "1609877389"
 	mchAPIv3Key := "DeovoMingHuiRengTianTang45675123"                        // 商户APIv3密钥
 	mchCertificateSerialNumber := "7540301D8FD52CCF7D6267DCF7CD2BC0AB467EFF" // 商户证书序列号
@@ -745,41 +746,46 @@ 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)
+		plaintext := new(WxPayRefundPlaintext)
-	err = json.Unmarshal([]byte(notifyReq.Resource.Plaintext), plaintext)
+		err = json.Unmarshal([]byte(notifyReq.Resource.Plaintext), plaintext)
-	if err != nil {
+		if err != nil {
-		logger.Error("unmarshal plaintext err:", err)
+			logger.Error("unmarshal plaintext err:", err)
-		return
+			return
-	}
+		}
-
+		count, err := model.NewFundRecordQuerySet(model.DB).RefundIdEq(plaintext.RefundId).Count()
-	openMemberRecord := new(model.UserOpenMemberRecord)
+		if err != nil {
-
+			logger.Error("count refund id err:", err)
-	err = model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(plaintext.OutTradeNo).One(openMemberRecord)
+			return
-	if err != nil {
+		}
-		logger.Error("user open member record err:", err)
+		if count == 0 {
-		return
+			openMemberRecord := new(model.UserOpenMemberRecord)
-	}
+			err = model.NewUserOpenMemberRecordQuerySet(model.DB).OpenNoEq(plaintext.OutTradeNo).One(openMemberRecord)
-	fundRecord := &model.FundRecord{
+			if err != nil {
-		Uid:           openMemberRecord.Uid,
+				logger.Error("user open member record err:", err)
-		FundType:      model.FundTypeExpressFeeRefund,
+				return
-		Amount:        int64(plaintext.Amount.Refund) * (-1),
+			}
-		TransactionId: plaintext.TransactionId,
+			fundRecord := &model.FundRecord{
-		OutTradeNo:    plaintext.OutTradeNo,
+				Uid:           openMemberRecord.Uid,
-		RefundId:      plaintext.RefundId,
+				FundType:      model.FundTypeExpressFeeRefund,
-		Status:        2,
+				Amount:        int64(plaintext.Amount.Refund) * (-1),
-		Remark:        "邮费退款",
+				TransactionId: plaintext.TransactionId,
-	}
+				OutTradeNo:    plaintext.OutTradeNo,
-	err = model.DB.Create(fundRecord).Error
+				RefundId:      plaintext.RefundId,
-	if err != nil {
+				Status:        2,
-		logger.Error("create fund record err:", err)
+				Remark:        "邮费退款",
-		return
+			}
+			err = model.DB.Create(fundRecord).Error
+			if err != nil {
+				logger.Error("create fund record err:", err)
+				return
+			}
+		}
 	}
 
 	RespNotice(c, "SUCCESS", "成功")

controller/order.go

@@ -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()
 

controller/user.go

@@ -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-黑金会员
 // 开通会员
 // 升级会员

lib/utils/csttime.go

@@ -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)
 }

model/autogenerated_user.go

@@ -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 {

model/config.go

@@ -27,9 +27,10 @@ type PayConfig struct {
 }
 
 const (
-	ConfigNamePay      = "pay_config"       // 支付配置
+	ConfigNamePay          = "pay_config"           // 支付配置
-	ConfigNameMember   = "member_config"    // 会员配置
+	ConfigNameMember       = "member_config"        // 会员配置
-	ConfigNameMemberVm = "member_vm_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
 //}

model/model_test.go

@@ -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))
 }

model/share_card.go

@@ -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  共享卡半年收回 测试上线修改

model/task.go

@@ -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

model/user.go

@@ -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,14 +128,15 @@ const (
 // gen:qs
 type FundRecord struct {
 	Model
-	Uid           uint32 `json:"uid"`
+	Uid           uint32 `json:"uid"  gorm:"index"`
-	FundType      string `json:"fund_type"` //  -member_gold   -member_platinum  -member_black_gold
+	FundType      string `json:"fund_type"  gorm:"index"` //  -member_gold   -member_platinum  -member_black_gold
 	Amount        int64  `json:"amount"`
-	TransactionId string `json:"transaction_id"` // 支付单号
+	TransactionId string `json:"transaction_id"  gorm:"index"` // 支付单号
-	OutTradeNo    string `json:"out_trade_no"`
+	OutTradeNo    string `json:"out_trade_no" gorm:"index"`
-	RefundId      string `json:"refund_id"`
+	RefundId      string `json:"refund_id"  gorm:"index"`
-	Status        uint32 `json:"status"` //  1-待支付 2-已支付 3-已退款
+	PaymentNo     string `json:"payment_no"  gorm:"index"` // 付款单号
-	Remark        string `json:"remark"` // 备注
+	Status        uint32 `json:"status"`                   //  1-待支付 2-已支付 3-已退款
+	Remark        string `json:"remark"`                   // 备注
 }
 
 // gen:qs
@@ -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
 }
 

model/user_vm.go

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

router/router_app.go

@@ -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,8 +85,9 @@ 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("member_config", controller.MemberConfigList) // 开通会员配置
+		user.POST("attendance/detail", controller.UserAttendanceDetail)            // 签到详情
+		user.POST("member_config", controller.MemberConfigList)                    // 开通会员配置
 
 		user.POST("common_problem/list", controller.CommonProblemList) // 常见问题列表
 		//user.POST("service/wechat_id", controller.GetCustomerServiceWechatId) // 获取客服微信号