📦 login reward + fix

Author: Kile

api/src/routes/common/discord_auth.rs

@@ -75,8 +75,6 @@ async fn verify_discord_token(token: &str) -> Result<DiscordUser, DiscordAuthErr
         .send()
         .await;
 
-    println!("Response: {response:?}");
-
     match response {
         Ok(resp) => {
             if resp.status().is_success() {

api/src/routes/userinfo.rs

@@ -48,6 +48,7 @@ pub struct ErrorResponse {
 pub struct UserInfoRequest {
     pub user_id: String,
     pub email: Option<String>,
+    pub from_admin: bool
 }
 
 #[get("/userinfo")]
@@ -62,59 +63,43 @@ pub async fn get_userinfo_by_id(
     auth: DiscordAuth,
     user_id: Option<&str>,
 ) -> Result<Json<FlatUserInfoResponse>, Status> {
-    let is_specific_user = user_id.is_some();
     let target_user_id = user_id
         .map(|s| s.to_string())
         .unwrap_or_else(|| auth.0.id.clone());
-    println!("Looking for user ID: {target_user_id}");
 
     // Check if the authenticated user can access this user's data
     if !auth.can_access_user(&target_user_id) {
-        println!("Access denied for user: {target_user_id}");
         return Err(Status::Forbidden);
     }
 
-    get_userinfo_by_user_id(auth, target_user_id, is_specific_user).await
+    let from_admin: bool = auth.0.id != target_user_id;
+    get_userinfo_by_user_id(auth, target_user_id, from_admin).await
 }
 
 async fn get_userinfo_by_user_id(
     auth: DiscordAuth,
     user_id: String,
-    is_specific_user: bool,
+    from_admin: bool,
 ) -> Result<Json<FlatUserInfoResponse>, Status> {
-    println!("Looking for user with ID: {user_id}");
-
     // Make request to Killua bot
     // Don't send email if this is a specific user request (admin accessing other user's data)
-    let email = if is_specific_user {
+    let email = if from_admin {
         None
     } else {
         auth.0.email.clone()
     };
-    let request_data = UserInfoRequest { user_id, email };
+    let request_data = UserInfoRequest { user_id, email, from_admin };
 
     match make_request("user/info", request_data, 0_u8).await {
         Ok(response) => {
-            println!("Response: {response}");
             match serde_json::from_str::<FlatUserInfoResponse>(&response) {
                 Ok(user_data) => {
-                    println!("Successfully retrieved user data");
                     Ok(Json(user_data))
                 }
-                Err(_e) => match serde_json::from_str::<ErrorResponse>(&response) {
-                    Ok(error) => {
-                        println!("Error: {0}", error.error);
-                        Err(Status::InternalServerError)
-                    }
-                    Err(e) => {
-                        println!("Unknown error: {e:?}");
-                        Err(Status::InternalServerError)
-                    }
-                },
+                Err(_e) => Err(Status::InternalServerError)
             }
         }
-        Err(e) => {
-            println!("Failed to get user info: {e:?}");
+        Err(_e) => {
             Err(Status::InternalServerError)
         }
     }

killua/cogs/api.py

@@ -9,7 +9,7 @@
 from zmq import ROUTER, Poller, POLLIN
 from zmq.asyncio import Context
 from io import BytesIO
-from logging import warning, info
+from asyncio import create_task
 from PIL import Image, ImageDraw, ImageChops
 
 from killua.bot import BaseBot
@@ -429,7 +429,9 @@ async def stats(self, _) -> dict:
             "guilds": len(self.client.guilds),
             "shards": self.client.shard_count,
             "registered_users": await DB.teams.count_documents({}),
-            "user_installs": (await self.client.application_info()).approximate_user_install_count,
+            "user_installs": (
+                await self.client.application_info()
+            ).approximate_user_install_count,
             "last_restart": self.client.startup_datetime.timestamp(),
         }
 
@@ -488,7 +490,7 @@ def jsonify(self, obj):
         """Helper function to convert objects to JSON transferable format"""
         return self._convert_snowflakes(self._convert_datetime(obj))
 
-    async def user_info(self, data) -> dict:
+    async def user_info(self, data: dict) -> dict:
         """Gets user info by Discord ID and returns it with display name and avatar URL"""
         user_id = data.get("user_id")
         if not user_id:
@@ -515,7 +517,7 @@ async def user_info(self, data) -> dict:
 
         # Return flat dictionary structure with all user data and Discord info
         response_data = {
-            "id": user_data.id, 
+            "id": user_data.id,
             "email": user_data.email,
             "display_name": user.display_name,
             "avatar_url": str(user.avatar.url) if user.avatar else None,
@@ -537,9 +539,7 @@ async def user_info(self, data) -> dict:
             "lootboxes": user_data.lootboxes,
             "boosters": user_data.boosters,
             "weekly_cooldown": (
-                user_data.weekly_cooldown
-                if user_data.weekly_cooldown
-                else None
+                user_data.weekly_cooldown if user_data.weekly_cooldown else None
             ),
             "action_settings": user_data.action_settings,
             "action_stats": user_data.action_stats,
@@ -549,7 +549,35 @@ async def user_info(self, data) -> dict:
             "premium_tier": user_data.premium_tier,
         }
 
+        if data.get("from_admin", False) is False:
+            # Fire and forget background task
+            create_task(self._register_login(user, user_data))
+
         return self.jsonify(response_data)
 
+    async def _register_login(self, user: discord.User, user_data: User) -> None:
+        """The actual background work you want to do"""
+        first_login = await user_data.register_login()
+        if not first_login:
+            return
+
+        # Add free golden lootbox and 1000 Jenny to user
+        await user_data.add_lootbox(4)
+        await user_data.add_jenny(1000)
+
+        # Try to send the user a DM about their reward
+        if user:
+            try:
+                await user.send(
+                    embed=discord.Embed.from_dict(
+                        {
+                            "title": "Thank you for checking out Killua's new website!",
+                            "description": "You've received a free golden lootbox and 1000 Jenny!",
+                            "color": 0x3E4A78,
+                        }
+                    )
+                )
+            except discord.HTTPException:
+                pass # Ignore failure
 
 Cog = IPCRoutes

killua/cogs/dev.py

@@ -352,9 +352,9 @@ async def api_stats(self, ctx: commands.Context):
         data = []
         for key, val in cast(dict, json["usage"]).items():
             if not key in API_ROUTES:
-                spam += val["requests"]
+                spam += val["request_count"]
                 continue
-            reqs: int = cast(dict, val).get("requests")
+            reqs: int = cast(dict, val).get("request_count")
             successful_res: int = cast(dict, val).get("successful_responses")
 
             embed.add_field(

killua/cogs/prometheus.py

@@ -64,16 +64,16 @@ async def update_api_stats(self):
         reqs = 0
         not_spam = 0
         for key, val in cast(dict, json["usage"]).items():
-            reqs += val["requests"]
+            reqs += val["request_count"]
             if not key in API_ROUTES:
                 continue
-            not_spam += val["requests"]
-            new_requests = val["requests"] - self.api_previous.get(key, {}).get(
-                "requests", 0
+            not_spam += val["request_count"]
+            new_requests = val["request_count"] - self.api_previous.get(key, {}).get(
+                "request_count", 0
             )
             if key not in self.api_previous:
                 self.api_previous[key] = {}
-            self.api_previous[key]["requests"] = val["requests"]
+            self.api_previous[key]["request_count"] = val["request_count"]
             API_REQUESTS_COUNTER.labels(key, "requests").inc(amount=new_requests)
             new_success = val["successful_responses"] - self.api_previous.get(
                 key, {}

killua/utils/classes/user.py

@@ -815,3 +815,11 @@ async def register_user_installed_usage(self) -> None:
             return  # No unnecessary database calls
         self.has_user_installed = True
         await self._update_val("user_installed", True)
+
+    async def register_login(self) -> bool:
+        """Registers that a user logged into the website and returns True if it was the first time"""
+        if "logged_into_website" in self.achievements:
+            return False
+        self.achievements.append("logged_into_website")
+        await self._update_val("achievements", self.achievements)
+        return True