use random session of manager session is not available

Author: zefanjajobse

src/connectors/mongo.rs

@@ -2,21 +2,57 @@ use std::env;
 
 use crate::structs::old_games;
 use bf_sparta::cookie::Cookie;
+use bf_sparta::sparta_api;
 use bson::Document;
 use chrono::{DateTime, Utc};
+use futures::StreamExt;
 use mongodb::error::Result;
+use mongodb::options::FindOptions;
 use mongodb::{options::ReplaceOptions, results::UpdateResult, Client, Collection};
 use serde::{Deserialize, Serialize};
 
 pub struct MongoClient {
     pub backend_cookies: Collection<BackendCookie>,
+    pub community_cookies: Collection<CommunityCookie>,
+    pub cookie_check: Collection<CookieCheck>,
     pub community_servers: Collection<Document>,
     pub community_groups: Collection<Document>,
     pub player_list: Collection<Document>,
     pub logging: Collection<Document>,
     pub old_games_servers: Collection<old_games::OldGameServerList>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CookieCheck {
+    pub _id: String,
+    pub prefix: String,
+    #[serde(rename = "personaId")]
+    pub persona_id: String,
+    #[serde(rename = "sessionId")]
+    pub session_id: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CommunityCookie {
+    pub _id: String,
+    pub sid: String,
+    pub remid: String,
+    #[serde(rename = "personaId")]
+    pub persona_id: String,
+    pub username: String,
+    #[serde(rename = "supportedGames")]
+    pub supported_games: Vec<String>,
+}
+
+impl From<CommunityCookie> for Cookie {
+    fn from(cookie: CommunityCookie) -> Self {
+        Cookie {
+            remid: cookie.remid,
+            sid: cookie.sid,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BackendCookie {
     pub _id: String,
@@ -71,6 +107,8 @@ impl MongoClient {
         let gamestats_db = client.database("gamestats");
 
         Ok(MongoClient {
+            cookie_check: db.collection("cookieCheck"),
+            community_cookies: db.collection("communityCookies"),
             backend_cookies: db.collection("backendCookies"),
             community_servers: db.collection("communityServers"),
             community_groups: db.collection("communityGroups"),
@@ -166,6 +204,56 @@ impl MongoClient {
         ))
     }
 
+    pub async fn get_random_cookie(&mut self) -> anyhow::Result<Cookie> {
+        let mut cookie_check = self
+            .cookie_check
+            .find(bson::doc! {})
+            .with_options(
+                FindOptions::builder()
+                    .sort(bson::doc! {"timeStamp": -1})
+                    .build(),
+            )
+            .await?;
+        let mut result_cookie = None;
+        while let Some(maybe_check) = cookie_check.next().await {
+            let check = maybe_check?;
+            match self
+                .community_cookies
+                .find_one(bson::doc! {"_id": check._id})
+                .await
+            {
+                Ok(e) => {
+                    if let Some(cookie) = e {
+                        match sparta_api::get_token(
+                            cookie.clone().into(),
+                            "pc",
+                            "tunguska",
+                            "en-us",
+                        )
+                        .await
+                        {
+                            Ok(_) => {
+                                result_cookie = Some(cookie);
+                                break;
+                            }
+                            Err(e) => {
+                                log::info!("Cookie not valid, trying another one - {}", e);
+                            }
+                        }
+                    } else {
+                        continue;
+                    }
+                }
+                Err(_) => continue,
+            };
+        }
+
+        Ok(match result_cookie {
+            Some(cookie) => cookie.into(),
+            None => anyhow::bail!("no cookie found"),
+        })
+    }
+
     pub async fn gather_old_title(
         &mut self,
         game_name: &str,

src/main.rs

@@ -117,20 +117,33 @@ async fn main() -> anyhow::Result<()> {
         Ok(_) => cookie.clone(),
         Err(e) => {
             log::warn!("Cookie failed, {} - requesting new cookie", e);
-            let cookie_auth = cookie_request::request_cookie(cookie_request::Login {
+            match cookie_request::request_cookie(cookie_request::Login {
                 email: api_main_account.clone(),
                 pass: env::var("API_MAIN_ACCOUNT_PASSWORD")
                     .expect("API_MAIN_ACCOUNT_PASSWORD wasn't set"),
             })
-            .await?;
-            let cookie = bf_sparta::cookie::Cookie {
-                sid: cookie_auth.sid,
-                remid: cookie_auth.remid,
-            };
-            mongo_client
-                .push_new_cookies(&api_main_account, &cookie, "".to_string())
-                .await?;
-            cookie
+            .await
+            {
+                Ok(cookie_auth) => {
+                    let cookie = bf_sparta::cookie::Cookie {
+                        sid: cookie_auth.sid,
+                        remid: cookie_auth.remid,
+                    };
+                    mongo_client
+                        .push_new_cookies(&api_main_account, &cookie, "".to_string())
+                        .await?;
+                    cookie
+                }
+                Err(e) => {
+                    log::warn!(
+                        "Requesting new cookie failed, {} - using one from the manager",
+                        e
+                    );
+
+                    let cookie = mongo_client.get_random_cookie().await?;
+                    cookie
+                }
+            }
         }
     };