Merge branch 'main' into contests

SysSn13 · web-flow · commit 734721b7811a · 2021-05-27T00:32:27.000+05:30
diff --git a/models/contest.js b/models/contest.js
@@ -14,7 +14,19 @@ const ContestRankingsSchema = new Schema({
         user_slug: String,
         country_code: String,
         country_name: String,
+        data_region: {
+            type: String,
+            default: "US"
+        },
         rank: Number,
+        current_rating:{
+            type: Number,
+            default:-1
+        },
+        predicted_rating:{
+            type: Number,
+            default:-1
+        }
     }]
 })
 
diff --git a/models/users.js b/models/users.js
@@ -0,0 +1,24 @@
+const mongoose = require("mongoose")
+
+const userSchema = new mongoose.Schema({
+    _id:{
+        type: String
+    },
+    attendedContestsCount:{
+        type: Number,
+        default: 0
+    },
+    rating:{
+        type: Number,
+        default: 1500
+    },
+    globalRanking:{
+        type: Number,
+        default:0
+    },
+    lastUpdated:{
+        type: Date,
+        default: Date.now,
+    },
+})
+module.exports = mongoose.model("User",userSchema)
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -11,7 +11,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "axios": "^0.21.1",
     "ejs": "^3.1.6",
     "express": "^4.17.1",
     "express-ejs-layouts": "^2.5.0",
diff --git a/server.js b/server.js
@@ -24,3 +24,5 @@ db.once('open',() => console.log('Connected to Mongoose'))
 app.use('/',indexRouter)
 
 app.listen(process.env.PORT || 3000)
+
+// const predict = require('./services/predict')
diff --git a/services/contests.js b/services/contests.js
@@ -1,10 +1,9 @@
-const axios = require('axios');
 const fetch = require('node-fetch')
 
 const Contest = require('../models/contest')
 let halfHour = 1000*60*30
 
-const getContestRankings = async function(contestSlug) {
+const fetchContestRankings = async function(contestSlug) {
 
     let contest = await Contest.findById(contestSlug)
     if(contest===null || contest.rankings.length===0){
@@ -15,14 +14,16 @@ const getContestRankings = async function(contestSlug) {
             let response = await fetch(`https://leetcode.com/contest/api/ranking/${contestSlug}/?pagination=1&region=global`);
             response = await response.json()
             let contest_id = response.total_rank[0].contest_id
-            
-            let pages = Math.floor(response.user_num/25)
+            // TODO: remove hard coded lines
+            let pages = 10//Math.floor(response.user_num/25)
             for(let i=1;i<=pages;i++){
+                console.log("fetching page no.: "+ i)
                 let res = await fetch(`https://leetcode.com/contest/api/ranking/${contestSlug}/?pagination=${i}&region=global`);
                 res = await res.json()
                 for(ranks of res.total_rank){
-                    let {username , user_slug , country_code , country_name , rank} = ranks
-                    let ranking = {username , user_slug , country_code , country_name , rank}
+                    let {username , user_slug , country_code , country_name ,data_region, rank} = ranks
+                    let ranking = {username, user_slug, country_code, country_name, data_region, rank}
+                    ranking["_id"] = username
                     rankings.push(ranking)
                 }
             }
@@ -49,19 +50,19 @@ const getContestRankings = async function(contestSlug) {
                 await Contest.findByIdAndUpdate(contestSlug, updatedContest)
                 console.log(`Updated Rankings in  contest ${contestSlug}`)
             }
+            return newContest
         } 
         catch (error) {
             console.error(error);
+            return null
         }
     }
     else{
         console.log("Aldready in db");
+        return contest
     }
-
 }
 
-
-
 const fetchContest = async () => {
 
     try {
@@ -115,15 +116,16 @@ const fetchContest = async () => {
     catch(error){
         console.log(error)
     }
-
-
-
 }
+const getContestRankings = async function(contestSlug){
+    let contest = await Contest.findById(contestSlug)
+    if(!contest){
+        contest = await fetchContestRankings(contestSlug)
+    }
+    return contest
+} 
 
-
-
-
-
-module.exports.getContestRankings = getContestRankings
+// exports 
 module.exports.fetchContest = fetchContest
-
+exports.getContestRankings = getContestRankings
+exports.fetchContestRankings = fetchContestRankings
diff --git a/services/predict.js b/services/predict.js
@@ -0,0 +1,91 @@
+const contests = require("./contests")
+const Contest = require("../models/contest") 
+const users = require("./users")
+
+
+// https://leetcode.com/discuss/general-discussion/468851/New-Contest-Rating-Algorithm-(Coming-Soon)
+
+function meanWinningPercentage(ratingA,ratingB){
+    return 1/(1+Math.pow(10,(ratingB-ratingA)/400))
+}
+function getExpectedRank(rankList,participantsData,userRating){
+    //  sum over all other participants of probabilities to win + 1
+    let seed = 0
+    rankList.map(rank =>{
+        if(participantsData[rank._id].rating!=-1){
+            seed += meanWinningPercentage(participantsData[rank._id].rating,userRating)
+        }
+    })
+    return seed
+}
+
+function geometricMean(eRank,rank){
+    return Math.sqrt(eRank*rank)
+}
+
+function getRating(rankList,participantsData,GMean){
+    let l = 1,r = 100000,mid,seed
+    while(r-l>0.1){
+        mid = l + (r-l)/2;
+        seed = 1 + getExpectedRank(rankList,participantsData,mid)
+        if(seed > GMean){
+            // to reduce seed -> increase ERating
+            l = mid
+        } else {
+            // to increase seed -> decrease ERating
+            r  = mid
+        }
+    }
+    return mid
+}
+
+// function to get all contest participants' rating before contest
+async function getParticipantsData(rankList){
+    let participantsData = {}
+
+    let promises = rankList.map( async (participant) =>{
+        try{
+            user = await users.getUser(participant._id,participant.data_region)
+            if(user===null){
+                participantsData[participant._id] = {"rating":-1,"rank":participant.rank}
+            }
+            else{
+                participantsData[participant._id] = {"rating":user.rating,"rank":participant.rank}
+            }
+        } catch(err){
+            console.error(err)
+        }
+    });
+    await Promise.all(promises)
+    return participantsData
+}
+const predict = async (contestSlug)=> {
+    try{
+        contestData = await contests.getContestRankings(contestSlug)
+        if(!contestData)
+            return
+        // console.log(contestData._id)
+        participantsData = await getParticipantsData(contestData.rankings)
+        // console.log(contestData.rankings,participantsData)
+        for(let i=0;i<contestData.rankings.length;i++){
+            const participant = contestData.rankings[i]
+            if(participantsData[participant._id].rating===-1){
+                continue
+            }
+            const currentRating = participantsData[participant._id].rating
+            const expectedRank = 0.5 + getExpectedRank(contestData.rankings,participantsData,currentRating) //seed
+            const GMean = geometricMean(expectedRank,participantsData[participant._id].rank)
+            const expectedRating = getRating(contestData.rankings,participantsData,GMean)
+            // TODO: handle initial value case of function f
+            const delta  = (2/9)*(expectedRating-currentRating)
+            const predictedRating = currentRating+delta
+            contestData.rankings[i].predicted_rating = predictedRating 
+            // console.log(participant._id,currentRating,expectedRank,GMean,expectedRating,delta,predictedRating)
+        }
+        await Contest.findByIdAndUpdate(contestSlug,contestData)
+    } catch(err){
+        console.log(err)
+    }
+}
+
+exports.predict = predict
diff --git a/services/users.js b/services/users.js
@@ -0,0 +1,106 @@
+const User = require("../models/users")
+const fetch = require('node-fetch');
+const oneDay = 24 * 60 * 60 * 1000;
+const fs =  require("fs")
+const BASE_URL = "https://leetcode.com"
+const BASE_CN_URL = "https://leetcode-cn.com"
+
+const fetchUserInfo = async function (username,dataRegion="US") {
+    try {
+        console.log(`fetching user ${username}'s info from leetcode...`)
+        let attenedContestCount,rating,globalRanking
+        if(dataRegion=="CN"){
+            var resp = await fetch(BASE_CN_URL+"/graphql", {
+                "headers": {
+                  "accept": "*/*",
+                  "accept-language": "en",
+                  "content-type": "application/json",
+                  "sec-ch-ua": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"90\", \"Google Chrome\";v=\"90\"",
+                  "sec-ch-ua-mobile": "?0",
+                  "sec-fetch-dest": "empty",
+                  "sec-fetch-mode": "cors",
+                  "sec-fetch-site": "same-origin",
+                  "sec-gpc": "1",
+                  "x-definition-name": "userProfilePublicProfile",
+                  "x-operation-name": "userPublicProfile",
+                },
+                "referrer": "https://leetcode-cn.com/u/ayamt/",
+                "referrerPolicy": "strict-origin-when-cross-origin",
+                "body": `{"operationName":"userPublicProfile","variables":{"userSlug":"${username}"},"query":"query userPublicProfile($userSlug: String!) {\\n  userProfilePublicProfile(userSlug: $userSlug) {\\n  profile {\\n      userSlug\\n      realName\\n  contestCount\\n  ranking {\\n  currentLocalRanking\\n        currentGlobalRanking\\n        currentRating\\n}\\n }\\n}\\n}\\n\"}`,
+                "method": "POST",
+                "mode": "cors"
+              })
+            resp = await resp.json()
+            if(resp.errors){
+                return null
+            }
+            resp  = resp.data.userProfilePublicProfile.profile
+
+            attenedContestCount = resp.contestCount
+            if (resp.ranking){
+                rating = parseFloat(resp.ranking.currentRating)
+                globalRanking = resp.ranking.currentGlobalRanking
+            }
+        }
+        else{
+            var resp = await fetch(BASE_URL+"/graphql", {
+                "headers": {
+                    "accept": "*/*",
+                    "accept-language": "en-GB,en-US;q=0.9,en;q=0.8,hi;q=0.7,ru;q=0.6",
+                    "content-type": "application/json",
+                    "sec-ch-ua": `" Not A;Brand";v="99", "Chromium";v="90", "Google Chrome";v="90"`,
+                    "sec-ch-ua-mobile": "?0",
+                    "sec-fetch-dest": "empty",
+                    "sec-fetch-mode": "cors",
+                    "sec-fetch-site": "same-origin",
+                    "sec-gpc": "1",
+                    "x-newrelic-id": "UAQDVFVRGwEAXVlbBAg=",
+                },
+                "referrerPolicy": "strict-origin-when-cross-origin",
+                "body": `{"operationName":"getContestRankingData","variables":{"username":"${username}"},"query":"query getContestRankingData($username: String!) {\\n  userContestRanking(username: $username) {\\n    attendedContestsCount\\n    rating\\n    globalRanking\\n    __typename\\n  }\\n}\\n\"}`,
+                "method": "POST",
+                "mode": "cors"
+            })
+        
+            resp = await resp.json()
+            if (resp.errors){
+                return null
+            }
+            resp = resp.data.userContestRanking
+            if(resp){
+                attenedContestCount = resp.attendedContestsCount
+                rating = resp.rating
+                globalRanking = resp.globalRanking
+            }    
+        }
+        var newUser = new User({
+            _id: username,
+            attendedContestsCount: attenedContestCount,
+            rating: rating,
+            globalRanking: globalRanking,
+            lastUpdated: Date.now()
+        })
+        const user = await User.findById(username)
+        if (user === null) {
+            await newUser.save();
+            console.log("created new user: "+username)
+            
+        } else {
+            await User.findByIdAndUpdate(username, newUser)
+            console.log(`user ${username}'s info updated`)
+        }
+        return newUser
+    } catch (err) {
+        console.error(`Error while fetching user ${username}'s info`,err)
+        return null
+    }
+}
+const getUser = async (username,dataRegion="US")=>{
+    let user = await User.findById(username)
+    if (user===null){
+        user= await fetchUserInfo(username,dataRegion)
+    }
+    return user
+}
+exports.fetchUserInfo = fetchUserInfo
+exports.getUser = getUser
