453 lines
13 KiB
Go
453 lines
13 KiB
Go
package taskrecordmod
|
|
|
|
import (
|
|
"91porn-server/common/db"
|
|
"91porn-server/common/log"
|
|
"91porn-server/common/timeutil"
|
|
"91porn-server/models"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
)
|
|
|
|
const table = models.Task
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
// initIndex 索引设置
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{ //batch set indexes //value is the type 1 or -1
|
|
{
|
|
Keys: bson.D{{"createdAt", -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "uid", Value: -1}, {Key: "taskId", Value: -1}, {Key: "recordTime", Value: -1}},
|
|
},
|
|
}
|
|
_, err := coll(nil).CreateIndex(many)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("user model set index err ==>[%+v]", err))
|
|
}
|
|
}
|
|
|
|
func Init() {
|
|
mdb = db.Init(table)
|
|
initIndex()
|
|
}
|
|
|
|
func InsertOne(cfg Task) error {
|
|
if _, err := coll(nil).InsertOne(cfg); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 添加任务记录
|
|
func AddTaskRecord(uid uint64) (taskRecord *Task, err error) {
|
|
now := time.Now()
|
|
receiveTime := timeutil.BeginningOfDay(now)
|
|
taskRecord = &Task{
|
|
UID: uid,
|
|
SignRecord: []primitive.ObjectID{},
|
|
SignTime: receiveTime,
|
|
JewelBoxRecord: []primitive.ObjectID{},
|
|
JewelBoxReceiveTime: receiveTime,
|
|
ConsumerFeedbackRecord: []primitive.ObjectID{},
|
|
ConsumerFeedbackReceiveTime: receiveTime,
|
|
CreateTime: now,
|
|
}
|
|
if _, err = coll(nil).InsertOne(&taskRecord); err != nil {
|
|
return nil, err
|
|
}
|
|
return
|
|
}
|
|
|
|
func InsertTask(t *db.MongoTool, filter bson.M, update bson.M) error {
|
|
var item *Task
|
|
if err := coll(t).FindOneAndUpsert(&item, filter, bson.M{"$set": update}); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertTask", table, "FindOneAndUpsert", err),
|
|
log.Any("filter", filter),
|
|
log.Any("update", update),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CurrentCountUpdate 评论值更新
|
|
func CurrentCountUpdate(t *db.MongoTool, filter bson.M) error {
|
|
_, err := coll(t).UpdateOne(filter, bson.M{"$inc": bson.M{"count": 1}})
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CurrentCountUpdate", models.Task, "UpdateOne", err),
|
|
log.Any("filter", filter),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetByUID(uid uint64) (*Task, error) {
|
|
var out Task
|
|
if err := coll(nil).FindOne(&out, bson.M{"uid": uid}); err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetByUID", models.Task, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
if out.ID.IsZero() {
|
|
return nil, nil
|
|
}
|
|
return &out, nil
|
|
}
|
|
|
|
// SignUpdate 签到更新
|
|
func SignUpdate(t *db.MongoTool, uid uint64, taskID primitive.ObjectID) error {
|
|
update := bson.M{
|
|
"$set": bson.M{"signTime": time.Now()},
|
|
"$addToSet": bson.M{"signRecord": taskID},
|
|
}
|
|
result, err := coll(t).UpdateOne(bson.M{"uid": uid}, update)
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "SignUpdate", models.Task, "UpdateOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return err
|
|
}
|
|
if result.ModifiedCount == 0 {
|
|
err = errors.New("task UpdateOne ModifiedCount err")
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "SignUpdate", models.Task, "result.ModifiedCount == 0", err),
|
|
log.Any("uid", uid),
|
|
log.Any("addToSet", taskID),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 活跃值更新
|
|
func CurrentValueUpdate(t *db.MongoTool, uid uint64, currentValue int64) error {
|
|
result, err := coll(t).UpdateOne(bson.M{"uid": uid}, bson.M{"$inc": bson.M{"currentValue": currentValue}})
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CurrentValueUpdate", models.Task, "UpdateOne", err),
|
|
log.Any("uid", uid),
|
|
log.Any("currentValue", currentValue),
|
|
)
|
|
return err
|
|
}
|
|
if result.ModifiedCount == 0 {
|
|
err = errors.New("task UpdateOne ModifiedCount err")
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CurrentValueUpdate", models.Task, "result.ModifiedCount == 0", err),
|
|
log.Any("uid", uid),
|
|
log.Any("currentValue", currentValue),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 签到重置
|
|
func SignReset(uid uint64) (out *Task, err error) {
|
|
now := timeutil.BeginningOfDay(time.Now())
|
|
if err = coll(nil).FindOneAndUpdate(&out, bson.M{"uid": uid}, bson.M{
|
|
"$set": bson.M{
|
|
"currentValue": 0,
|
|
"signTime": now,
|
|
"jewelBoxRecord": []primitive.ObjectID{},
|
|
"jewelBoxReceiveTime": now,
|
|
"signRecord": []primitive.ObjectID{},
|
|
},
|
|
}); err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "SignReset", models.Task, "FindOneAndUpdate", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 消费返利重置
|
|
func ConsumerFeedbackReset(uid uint64) (out *Task, err error) {
|
|
now := timeutil.BeginningOfDay(time.Now())
|
|
err = coll(nil).FindOneAndUpdate(&out, bson.M{"uid": uid}, bson.M{
|
|
"$set": bson.M{
|
|
"consumerFeedbackRecord": []primitive.ObjectID{},
|
|
"consumerFeedbackReceiveTime": now,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ConsumerFeedbackReset", models.Task, "FindOneAndUpdate", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 充值有礼重置
|
|
func ChessRechargePoliteReset(uid uint64) (out *Task, err error) {
|
|
now := timeutil.BeginningOfDay(time.Now())
|
|
if err = coll(nil).FindOneAndUpdate(&out, bson.M{"uid": uid}, bson.M{
|
|
"$set": bson.M{
|
|
"chessRechargePoliteRecord": []primitive.ObjectID{},
|
|
"chessRechargePoliteReceiveTime": now,
|
|
},
|
|
}); err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ConsumerFeedbackReset", models.Task, "FindOneAndUpdate", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 福利记录更新
|
|
func BoonRecordUpdate(t *db.MongoTool, uid uint64, taskID primitive.ObjectID, configType ConfigType) error {
|
|
update := bson.M{
|
|
"$set": bson.M{"signTime": time.Now()},
|
|
}
|
|
switch configType {
|
|
case Sign:
|
|
update["$addToSet"] = bson.M{"signRecord": taskID}
|
|
update["$set"] = bson.M{"signTime": time.Now()}
|
|
case JewelBox:
|
|
update["$addToSet"] = bson.M{"jewelBoxRecord": taskID}
|
|
update["$set"] = bson.M{"jewelBoxReceiveTime": time.Now()}
|
|
case ConsumerFeedback:
|
|
update["$addToSet"] = bson.M{"consumerFeedbackRecord": taskID}
|
|
update["$set"] = bson.M{"consumerFeedbackReceiveTime": time.Now()}
|
|
}
|
|
result, err := coll(t).UpdateOne(bson.M{"uid": uid}, update)
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "SignUpdate", models.Task, "UpdateOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return err
|
|
}
|
|
if result.ModifiedCount == 0 {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail", "SignUpdate", models.Task, "result.ModifiedCount == 0"),
|
|
log.Any("uid", uid),
|
|
log.Any("addToSet", taskID),
|
|
)
|
|
return errors.New("task UpdateOne ModifiedCount err")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 是否完成一次性任务
|
|
func IsOnceTaskComplete(t *db.MongoTool, uid uint64, taskId primitive.ObjectID) (bool, error) {
|
|
var tsk Task
|
|
if err := coll(t).FindOne(&tsk, bson.M{"uid": uid, "type": OnceTask}); err != nil {
|
|
return false, err
|
|
}
|
|
if tsk.ID.IsZero() {
|
|
return false, nil
|
|
}
|
|
for _, v := range tsk.OnceTask {
|
|
if taskId == v {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
// IsDownloadTaskComplete 是否完成一次性任务 - 下载任务
|
|
func IsDownloadTaskComplete(t *db.MongoTool, uid uint64, taskId primitive.ObjectID) (int, error) {
|
|
var tsk Task
|
|
if err := coll(t).FindOne(&tsk, bson.M{"uid": uid, "taskId": taskId}); err != nil {
|
|
return 0, err
|
|
}
|
|
if tsk.ID.IsZero() {
|
|
return 0, nil
|
|
}
|
|
|
|
return tsk.Status, nil
|
|
}
|
|
|
|
func CompleteOnceTask(t *db.MongoTool, uid uint64, taskId primitive.ObjectID) error {
|
|
var tsk Task
|
|
if err := coll(t).FindOne(&tsk, bson.M{"uid": uid, "type": OnceTask}); err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
if tsk.ID.IsZero() {
|
|
receiveTime := timeutil.BeginningOfDay(now)
|
|
_, err := coll(t).InsertOne(&Task{
|
|
UID: uid,
|
|
Type: OnceTask,
|
|
SignRecord: []primitive.ObjectID{},
|
|
SignTime: receiveTime,
|
|
JewelBoxRecord: []primitive.ObjectID{},
|
|
JewelBoxReceiveTime: receiveTime,
|
|
ConsumerFeedbackRecord: []primitive.ObjectID{},
|
|
ConsumerFeedbackReceiveTime: receiveTime,
|
|
OnceTask: []primitive.ObjectID{taskId},
|
|
CreateTime: now,
|
|
})
|
|
return err
|
|
}
|
|
for _, v := range tsk.OnceTask {
|
|
if v == taskId { // 已经完成了
|
|
return nil
|
|
}
|
|
}
|
|
if len(tsk.OnceTask) == 0 {
|
|
_, err := coll(t).UpdateOne(bson.M{"_id": tsk.ID}, bson.M{"$set": bson.M{"onceTask": []primitive.ObjectID{taskId}}})
|
|
return err
|
|
}
|
|
_, err := coll(t).UpdateOne(bson.M{"_id": tsk.ID}, bson.M{"$addToSet": bson.M{"onceTask": taskId}})
|
|
return err
|
|
}
|
|
|
|
func GetUserRecordByTime(uid uint64, taskId primitive.ObjectID, record time.Time) (*Task, error) {
|
|
var out *Task
|
|
if err := coll(nil).FindOne(&out, bson.M{"uid": uid, "taskId": taskId, "recordTime": record}); err != nil {
|
|
log.Error(
|
|
fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetUserRecordByTime", models.Task, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetUserTaskRecordByUid 查询用户任务记录
|
|
func GetUserTaskRecordByUid(uid uint64, t ConfigType, taskId primitive.ObjectID) (*Task, error) {
|
|
var out *Task
|
|
if err := coll(nil).FindOne(&out, bson.M{"uid": uid, "type": t, "taskId": taskId}); err != nil {
|
|
log.Error(
|
|
fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetUserTaskRecordByUid", models.Task, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetUserTask 查询用户任务记录
|
|
func GetUserTask(uid uint64, taskId primitive.ObjectID) (Task, error) {
|
|
var out Task
|
|
if err := coll(nil).FindOne(&out, bson.M{"uid": uid, "taskId": taskId}); err != nil {
|
|
log.Error(
|
|
fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetUserTaskRecordByUid", models.Task, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return out, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func UpdateStatusById(t *db.MongoTool, id primitive.ObjectID, status int) (out *Task, err error) {
|
|
update := bson.M{"$set": bson.M{"updateTime": time.Now(), "status": status}, "$inc": bson.M{"stage": 1}}
|
|
if err = coll(t).FindOneAndUpdate(&out, bson.M{"_id": id}, update); err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdateStatusById", models.Task, "UpdateStatusById", err),
|
|
log.Any("id", id.Hex()),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func UpsertOne(filter, updateDate bson.M) (err error) {
|
|
if _, err = coll(nil).UpsertOne(filter, updateDate); err != nil {
|
|
log.Error("UpsertOne error",
|
|
log.Any("filter", filter),
|
|
log.Any("updateDate", updateDate),
|
|
log.E(err))
|
|
return err
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetSignRecord 取用户签到任务记录
|
|
func GetSignRecord(uid uint64) (*Task, error) {
|
|
var out *Task
|
|
if err := coll(nil).FindOne(&out, bson.M{"uid": uid, "type": Sign}); err != nil {
|
|
log.Error(
|
|
fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetUserRecordByType", models.Task, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// TaskSignUpdate 更新用户签到记录
|
|
func TaskSignUpdate(t *db.MongoTool, uid uint64, taskID primitive.ObjectID) error {
|
|
filter := bson.M{
|
|
"uid": uid,
|
|
"type": Sign,
|
|
}
|
|
update := bson.M{"$addToSet": bson.M{"signRecord": taskID}}
|
|
result, err := coll(t).UpdateOne(filter, update)
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "RecordUpdate", models.Task, "UpdateOne", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return err
|
|
}
|
|
if result.ModifiedCount == 0 {
|
|
err = errors.New("task sign UpdateOne ModifiedCount err")
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "RecordUpdate", models.Task, "result.ModifiedCount == 0", err),
|
|
log.Any("uid", uid),
|
|
log.Any("taskID", taskID),
|
|
log.Any("configType:sign", Sign),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TaskSignInit 任务记录初始化
|
|
func TaskSignInit(uid uint64) (*Task, error) {
|
|
now := time.Now()
|
|
receiveTime := timeutil.BeginningOfDay(now)
|
|
taskRecord := &Task{
|
|
UID: uid,
|
|
SignRecord: []primitive.ObjectID{},
|
|
SignTime: receiveTime,
|
|
JewelBoxRecord: []primitive.ObjectID{},
|
|
JewelBoxReceiveTime: receiveTime,
|
|
ConsumerFeedbackRecord: []primitive.ObjectID{},
|
|
ConsumerFeedbackReceiveTime: receiveTime,
|
|
TaskType: 0,
|
|
Type: Sign,
|
|
CreateTime: now,
|
|
}
|
|
if _, err := coll(nil).InsertOne(&taskRecord); err != nil {
|
|
return nil, err
|
|
}
|
|
return taskRecord, nil
|
|
}
|
|
|
|
// TaskSignReset 任务重置
|
|
func TaskSignReset(uid uint64) (*Task, error) {
|
|
var (
|
|
out *Task
|
|
now = timeutil.BeginningOfDay(time.Now())
|
|
)
|
|
if err := coll(nil).FindOneAndUpdate(&out, bson.M{"uid": uid, "type": Sign}, bson.M{
|
|
"$set": bson.M{
|
|
"signRecord": []primitive.ObjectID{},
|
|
"signTime": now,
|
|
},
|
|
}, options.FindOneAndUpdate().SetReturnDocument(options.After)); err != nil {
|
|
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "TaskReset", models.Task, "FindOneAndUpdate", err),
|
|
log.Any("uid", uid),
|
|
log.Any("configType:sign", Sign),
|
|
)
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|