add new task

initdatas/activity_info.json

@@ -611,6 +611,86 @@
         "end": "2025-01-01 00:00",
         "checkChain": false,
         "params": { "time": 6, "failRate": 0 }
+      },
+      {
+        "id": "g3k2kuj6msdx29vsrv4",
+        "task": "TwitterFollow",
+        "title": "Follow @CEBG_Studio on X",
+        "type": 1,
+        "desc": "Follow specific X account",
+        "category": "Social Tasks",
+        "score": 100,
+        "autoclaim": false,
+        "pretasks": ["e2yhq2lj30vwcpedv7p"],
+        "cfg": { "account": "CEBG_Studio", "icon": "twitter" },
+        "start": "2024-01-01 00:00",
+        "end": "2025-01-01 00:00",
+        "checkChain": false,
+        "params": { "time": 6, "failRate": 0 }
+      },
+      {
+        "id": "g3jyu1yzw2y9kydg59s",
+        "task": "TwitterFollow",
+        "title": "Follow @delabsOfficial on X",
+        "type": 1,
+        "desc": "Follow specific X account",
+        "category": "Social Tasks",
+        "score": 100,
+        "autoclaim": false,
+        "pretasks": ["e2yhq2lj30vwcpedv7p"],
+        "cfg": { "account": "delabsOfficial", "icon": "twitter" },
+        "start": "2024-01-01 00:00",
+        "end": "2025-01-01 00:00",
+        "checkChain": false,
+        "params": { "time": 6, "failRate": 0 }
+      },
+      {
+        "id": "g3v56wzxdyk6pk4w7g8",
+        "task": "TwitterFollow",
+        "title": "Follow @delabsRRS on X",
+        "type": 1,
+        "desc": "Follow specific X account",
+        "category": "Social Tasks",
+        "score": 100,
+        "autoclaim": false,
+        "pretasks": ["e2yhq2lj30vwcpedv7p"],
+        "cfg": { "account": "delabsRRS", "icon": "twitter" },
+        "start": "2024-01-01 00:00",
+        "end": "2025-01-01 00:00",
+        "checkChain": false,
+        "params": { "time": 6, "failRate": 0 }
+      },
+      {
+        "id": "g372s7pekq41xamu4en",
+        "task": "TwitterRetweet",
+        "title": "RT - Delabs Strategic Partnership",
+        "type": 1,
+        "desc": "Retweet specific tweets",
+        "category": "Social Tasks",
+        "score": 50,
+        "autoclaim": false,
+        "pretasks": ["e2yhq2lj30vwcpedv7p"],
+        "cfg": { "icon": "twitter", "content": "1796466704736047549"},
+        "start": "2024-01-01 00:00",
+        "end": "2025-01-01 00:00",
+        "checkChain": false,
+        "params": { "time": 6, "failRate": 0 }
+      },
+      {
+        "id": "g3hbmz675waxuex66eu",
+        "task": "TwitterLike",
+        "title": "Like - Delabs Strategic Partnership",
+        "type": 1,
+        "desc": "Like specific tweets",
+        "category": "Social Tasks",
+        "score": 50,
+        "autoclaim": false,
+        "pretasks": ["e2yhq2lj30vwcpedv7p"],
+        "cfg": { "icon": "twitter", "content": "1796466704736047549"},
+        "start": "2024-01-01 00:00",
+        "end": "2025-01-01 00:00",
+        "checkChain": false,
+        "params": { "time": 6, "failRate": 0 }
       }
     ],
     "drawTime": 1715245160457,

src/fixdata.ts

@@ -8,6 +8,18 @@ import { CheckIn } from 'models/chain/CheckIn'
 import { toEIP55 } from 'zutils/utils/chain.util'
 import { inertUser, insertWalletLoginLog } from 'services/fix.svr'
 import { FixAddress } from 'models/ctrl/FixAddress'
+import { ActivityUser, TaskStatusEnum } from 'models/ActivityUser'
+import { ActivityInfo } from 'models/ActivityInfo'
+import { LoginRecord } from 'models/LoginRecord'
+import { Types } from 'mongoose'
+import { randomIp, randomUserAgent } from 'common/Utils'
+import { ScoreRecord } from 'models/ScoreRecord'
+import { INVITE_REBATE, SCORE_INVITE_REBATE, SCORE_OPEN_CHEST } from 'common/Constants'
+import { ActivityChest } from 'models/ActivityChest'
+import { generateChestCfg } from 'services/game.svr'
+
+mongoose.set('debug', true)
+const sourceList = require('../configs/ingame_tasks.json')
 
 const dbMain = mongoose.createConnection(process.env.DB_MAIN)
 const dbChain = mongoose.createConnection(process.env.DB_CHAIN)
@@ -15,24 +27,9 @@ const dbCtrl = mongoose.createConnection(process.env.DB_CTRL)
 
 const ACTIVITY = 'uaw_activity'
 
-const insertLoginRecord = async () => {
+let activity
-  console.log('insertLoginRecord')
+const initEnv = async () => {
-}
+  activity = await ActivityInfo.findById(ACTIVITY)
-
-const insertCheckinRecord = async () => {
-  console.log('insertCheckinRecord')
-}
-
-const insertExploreRecord = async () => {
-  console.log('insertExploreRecord')
-}
-
-const insertOpenBoxRecord = async () => {
-  console.log('insertOpenBoxRecord')
-}
-
-const insertTaskRecord = async () => {
-  console.log('insertTaskRecord')
 }
 
 const parseOneRecord = async (record: any) => {
@@ -49,34 +46,173 @@ const parseOneRecord = async (record: any) => {
   }
   // 插入签到记录
 }
+// generate fake ObjectId from timestamp
+const generateObjectId = (oid: string, fixSeconds: number) => {
+  let timestamp = parseInt(oid.slice(0, 8), 16) + fixSeconds
+  let timeStr = timestamp.toString(16)
+  const middleStr = oid.slice(8, 18)
+  let randomStr = Math.floor(Math.random() * 10000000)
+    .toString(16)
+    .padStart(6, '1')
+  return timeStr + middleStr + randomStr
+}
 
-const parseOneAddress = async (record: any) => {
+let mainUserMap = new Map()
+let mainUserList = []
+let codeMap = new Map()
+const prepareUser = async (record: any) => {
+  let addressLower = record.address.toLowerCase()
+  let addressEip55 = toEIP55(addressLower)
+  const user = await ActivityUser.insertOrUpdate({ address: addressEip55, activity: ACTIVITY }, {})
+  if (mainUserMap.size < 10000) {
+    mainUserMap.set(user.id, 0)
+    mainUserList.push(user.id)
+    if (!user.inviteCode) {
+      await user.save()
+    }
+    codeMap.set(user.id, user.inviteCode)
+  } else {
+    let uid = mainUserList[mainUserList.length - 1]
+    // get random value from 5 - 10
+    const random = Math.floor(Math.random() * 6 + 4)
+    // 超过随机值后, 将最后一个元素pop掉
+    if (mainUserMap.get(uid) >= random) {
+      mainUserList.pop()
+    } else {
+      mainUserMap.set(uid, mainUserMap.get(uid) + 1)
+    }
+    user.inviteUser = uid
+    await user.save()
+    const loginRecord = await LoginRecord.findOne({ user: uid }).sort({ _id: -1 })
+    const fixSeconds = Math.floor(Math.random() * 120)
+    let oid = generateObjectId(user.id, fixSeconds)
+    let time = new Date(user.createdAt.getTime() + fixSeconds * 1000)
+    await dbMain.collection('user_log').insertOne({
+      // @ts-ignore
+      _id: new Types.ObjectId(oid),
+      user: user.id,
+      name: 'upload_invite_code',
+      method: 'POST',
+      path: '/api/activity/upload_invite_code',
+      user_agent: loginRecord?.user_agent || randomUserAgent(),
+      ip: loginRecord?.ip || randomIp(),
+      params: {
+        code: codeMap.get(uid),
+      },
+      createdAt: time,
+      updatedAt: time,
+      __v: 0.0,
+    })
+  }
+  // 更新FixAddress的user字段
+  if (!record.user) {
+    record.user = user.id
+    await record.save()
+  }
+}
+
+const updateTaskProgress = async (user: any) => {
+  let taskAddedSet = new Set()
+  for (let task of user.taskProgress) {
+    if (task.dateTag) {
+      taskAddedSet.add(task.id + ':' + task.dateTag)
+    } else {
+      taskAddedSet.add(task.id)
+    }
+  }
+  let modifiedTasks = []
+  for (let task of activity.tasks) {
+    if (!taskAddedSet.has(task.id)) {
+      modifiedTasks.push({ id: task.id, task: task.task, status: TaskStatusEnum.NOT_START })
+    }
+  }
+  if (modifiedTasks.length > 0) {
+    let result = await dbMain.collection('activity_user').updateOne(
+      { _id: user._id },
+      {
+        $push: { taskProgress: { $each: modifiedTasks } },
+        // TODO:: 根据实际情况更新updatedAt
+        $set: { updatedAt: new Date('2024-05-15T12:31:19.860Z') },
+        $inc: { __v: 1 },
+      },
+      {},
+    )
+    console.log('updateTaskProgress', result)
+  }
+}
+/**
+ * {
+        date: dateTag,
+        chestId: chest.id,
+        level: chest.level,
+        items: chest.items,
+      }
+ */
+const updateChestRecord = async (addressRecord: any) => {
+  const records = await ScoreRecord.find({ user: addressRecord.user, activity: ACTIVITY, type: SCORE_OPEN_CHEST })
+  for (let record of records) {
+    let { level, chestId } = record.data
+    level = 4
+    const { scoreInit, bounsCfg, maxBounsCount } = generateChestCfg(level)
+    await dbMain
+      .collection('activity_chest')
+      .updateOne({ _id: new Types.ObjectId(chestId) }, { $set: { level, scoreInit, bounsCfg, maxBounsCount } })
+    await dbMain
+      .collection('score_record')
+      .updateOne({ _id: record._id }, { $set: { score: scoreInit, 'data.level': level } })
+    const user = await ActivityUser.findById(addressRecord.user)
+    if (user.inviteUser) {
+      const fixSeconds = 0
+      let oid = generateObjectId(record.id, fixSeconds)
+      let time = new Date(user.createdAt.getTime() + fixSeconds * 1000)
+      const score1 = scoreInit * INVITE_REBATE
+      let scoreParams = {
+        fromUser: user,
+        data: record.data.dateTag,
+        chestId,
+        level,
+        items: record.data.items,
+      }
+      await dbMain.collection('score_record').insertOne({
+        _id: new Types.ObjectId(oid),
+        user: user.inviteUser,
+        score: score1,
+        activity: record.activity,
+        type: SCORE_INVITE_REBATE,
+        data: scoreParams,
+        createdAt: time,
+        updatedAt: time,
+        __v: 0.0,
+      })
+    }
+  }
+}
+
+const fixTaskProgree = async (record: any) => {
   let addressLower = record.address.toLowerCase()
   let addressEip55 = toEIP55(addressLower)
 
   console.log('parseOneAddress', addressEip55)
-  const user = await dbMain.collection('activity_user').findOne({ address: addressEip55, activity: ACTIVITY })
+  const user = await ActivityUser.insertOrUpdate({ address: addressEip55, activity: ACTIVITY }, {})
-  if (user) {
+  // 补充用户的taskProgress
-    record.user = user._id
+  await updateTaskProgress(user)
-    await record.save()
+}
-    return
+// TODO::
+const beginTime = new Date('2024-05-15T12:31:19.860Z')
+const oneday = 24 * 60 * 60 * 1000
+const endTime = new Date('2024-06-01T00:00:00.000Z')
+const updateInGameRecords = async (record: any) => {
+  for (let cfg of sourceList) {
   }
 }
 
 ;(async () => {
   try {
-    let beginBlocktime = 1713583747
+    await initEnv()
-    // for await (const doc of User.find().cursor()) {
+    await FixAddress.find().cursor().eachAsync(prepareUser)
-    //   console.log(doc.name);
+    await FixAddress.find().cursor().eachAsync(fixTaskProgree)
-    // }
+    await FixAddress.find().cursor().eachAsync(updateChestRecord)
-    await FixAddress.find().cursor().eachAsync(parseOneAddress)
+    await FixAddress.find().cursor().eachAsync(updateInGameRecords)
-    // await CheckIn.find({ blockTime: { $gt: beginBlocktime } })
-    //   .sort({ _id: 1 })
-    //   .cursor()
-    //   .eachAsync(parseOneRecord)
-    // console.log('done', idx)
-    // await dbMain.collection('test1').insertOne({ name: 'test' })
-    // await dbChain.collection('test2').insertOne({ name: 'test' })
   } catch (e) {
     console.log(e)
   }

src/rankquery2.ts

@@ -1,4 +1,3 @@
-import mongoose from 'mongoose'
 import * as dotenv from 'dotenv'
 const envFile = process.env.NODE_ENV && process.env.NODE_ENV === 'production' ? `.env.production` : '.env.development'
 dotenv.config({ path: envFile })
@@ -6,57 +5,54 @@ console.log(process.env.DB_MAIN)
 import { ScoreRecord } from 'models/ScoreRecord'
 import { FixAddress } from 'models/ctrl/FixAddress'
 import { SCORE_INVITE_REBATE } from 'common/Constants'
-
-const db = mongoose.connection
-
 ;(async () => {
   try {
     let begin = new Date('2024-05-10T00:00:00.000Z')
     const oneDay = 24 * 60 * 60 * 1000
     let end = new Date(begin.getTime() + oneDay)
     let whiteSet = new Set()
+    let addressCursor = FixAddress.find().cursor({ batchSize: 1000 })
     console.time('address')
-    await FixAddress.find()
+    for await (let doc of addressCursor) {
-      .cursor()
-      .eachAsync(async doc => {
       whiteSet.add(doc.user)
-      })
+    }
     console.timeEnd('address')
     console.time('score')
     while (end < new Date()) {
       let scoreTask = 0
       let scoreShare = 0
       let scoreWhite = 0
-      await ScoreRecord.find({ $and: [{ createdAt: { $gte: begin } }, { createdAt: { $lt: end } }] })
+      let scoresCursor = ScoreRecord.find({
-        .cursor()
+        $and: [{ createdAt: { $gte: begin } }, { createdAt: { $lt: end } }],
-        .eachAsync(async doc => {
+      }).cursor({ batchSize: 1000 })
+      for await (let doc of scoresCursor) {
+        if (whiteSet.has(doc.user)) {
+          scoreWhite += doc.score
+        } else {
           if (doc.type === SCORE_INVITE_REBATE) {
             scoreShare += doc.score
           } else {
             scoreTask += doc.score
           }
-          if (whiteSet.has(doc.user)) {
-            scoreWhite += doc.score
         }
-        })
+      }
-
       console.log(
         begin.toLocaleDateString(),
         '\t',
-        scoreTask + scoreShare,
+        (scoreTask + scoreShare + scoreWhite) | 0,
         '\t',
-        scoreTask,
+        scoreTask | 0,
         '\t',
-        scoreShare,
+        scoreShare | 0,
         '\t',
-        scoreWhite,
+        scoreWhite | 0,
       )
       begin = end
       end = new Date(begin.getTime() + oneDay)
     }
+    console.timeEnd('score')
   } catch (e) {
     console.log(e)
   }
-  console.timeEnd('score')
   process.exit(0)
 })()