chore: reduce meta complexity

Author: JayDwee

api/src/discord.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 use cached::proc_macro::cached;
 use http::StatusCode;
-use lambda_http::tracing::{error, info};
+use lambda_http::tracing::{error, info, warn};
 use tokio::time::sleep;
 use twilight_http::{Client, Error, Response};
 use twilight_http::api_error::ApiError;
@@ -33,6 +33,7 @@ where
                 match e.kind() {
                     ErrorType::Response { error: ApiError::Ratelimited(ratelimited), ..} => {
                             attempts += 1;
+                            warn!("Rate limited, retrying in {} seconds", ratelimited.retry_after);
                             sleep(Duration::from_secs_f64(ratelimited.retry_after)).await;
                             continue;
                         }

api/src/meta/mod.rs

@@ -1,3 +1,4 @@
+use std::ops::{Add, Sub};
 use std::sync::Arc;
 use std::time::Duration;
 use axum::{Extension, Json, Router};
@@ -7,15 +8,16 @@ use http::StatusCode;
 use lambda_http::tracing::{error, info};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
-use tokio::time::sleep;
+use tokio::time::{sleep, Instant};
 use tower_http::cors::CorsLayer;
 use twilight_http::Client;
 use twilight_model::guild::{Guild, Role};
 use twilight_model::id::Id;
 use twilight_model::id::marker::GuildMarker;
+use twilight_model::user::CurrentUserGuild;
 use twilight_model::util::ImageHash;
 use crate::AppState;
-use crate::discord::{get_current_user_guilds_no_cache, get_current_user_guilds_prime_cache, get_guild, get_guild_prime_cache};
+use crate::discord::{get_current_user_guilds_prime_cache, get_guild, get_guild_prime_cache};
 use crate::utils::member_guilds;
 
 pub fn router() -> Router<AppState> {
@@ -29,6 +31,24 @@ pub fn setup(discord_bot: Arc<Client>) {
     tokio::spawn(refresh_meta_cache(discord_bot));
 }
 
+
+#[derive(Debug, Serialize, Deserialize)]
+struct PartialGuildMeta {
+    id: Id<GuildMarker>,
+    name: String,
+    icon: Option<ImageHash>,
+}
+impl From<CurrentUserGuild> for PartialGuildMeta {
+    fn from(guild: CurrentUserGuild) -> Self {
+        PartialGuildMeta {
+            id: guild.id,
+            name: guild.name,
+            icon: guild.icon,
+        }
+    }
+}
+
+
 #[derive(Debug, Serialize, Deserialize)]
 struct GuildMeta {
     id: Id<GuildMarker>,
@@ -52,19 +72,17 @@ async fn get_guilds_meta(
     Extension(discord_user): Extension<Arc<Client>>,
     State(app_state): State<AppState>,
 ) -> Result<Json<Value>, StatusCode> {
-    let member_guilds = member_guilds(&discord_user, &app_state.discord_bot).await?;
-
-    let mut meta = vec![];
-    for member_guild in &member_guilds {
-        meta.push(GuildMeta::from(get_guild(member_guild.id, &app_state.discord_bot).await?))
-    }
+    Ok(Json(json!(
+        member_guilds(&discord_user, &app_state.discord_bot).await?
+        .into_iter().map(PartialGuildMeta::from).collect::<Vec<PartialGuildMeta>>()
+    )))
 
-    Ok(Json(json!(meta)))
 }
 
 async fn refresh_meta_cache(discord_bot: Arc<Client>) {
     loop {
         info!("Refreshing meta cache");
+        let time = Instant::now();
         match get_current_user_guilds_prime_cache(&*discord_bot).await {
             Ok(guilds) => {
                 info!("Refreshing meta cache: {}", guilds.len());
@@ -76,6 +94,7 @@ async fn refresh_meta_cache(discord_bot: Arc<Client>) {
                 error!("refresh_meta_cache error: {:#?}", e);
             }
         }
-        sleep(Duration::from_secs(50)).await;
+        info!("{:?} {:?} Waiting {} seconds",time, Instant::now(), (time.sub(Instant::now()).add(Duration::from_secs(50))).as_secs());
+        sleep((time.sub(Instant::now())).add(Duration::from_secs(50))).await;
     }
 }

ui/src/helpers/meta.js

@@ -1,14 +1,22 @@
-import {GuildMeta} from "../stores/meta.js";
+import {PartialGuildMeta} from "../stores/meta.js";
 import {isGuildAdmin} from "./discord.js";
 
 
 export async function fetchGuildMetaMap(token) {
-  return (await GuildMeta.fetchAll(token)).reduce((acc, guildMeta) => {
-    guildMeta.roleMeta = guildMeta.roles.reduce((acc, role) => acc.set(role.id, role), new Map());
+  return (await PartialGuildMeta.fetchAll(token)).reduce((acc, guildMeta) => {
+    // guildMeta.roleMeta = guildMeta.roles.reduce((acc, role) => acc.set(role.id, role), new Map());
     return acc.set(guildMeta.id, guildMeta);
   }, new Map());
 }
 
+export function filterByMember(guildMetaMap, currentUserGuildMetaMap) {
+  let adminGuilds = new Map();
+  for (let guildMeta of guildMetaMap.values()) {
+    adminGuilds.set(guildMeta.id, guildMeta);
+  }
+  return adminGuilds
+}
+
 export function filterByAdmin(guildMetaMap, currentUserGuildMetaMap) {
   let adminGuilds = new Map();
   for (let guildMeta of guildMetaMap.values()) {

ui/src/pages/verify/VerifyView.vue

@@ -1,13 +1,7 @@
 <script setup>
 
-import MicrosoftIcon from "../../components/icons/MicrosoftIcon.vue";
-import GoogleIcon from "../../components/icons/GoogleIcon.vue";
 import DiscordAuthButton from "../../components/auth/DiscordAuthButton.vue";
 import {onMounted, ref, toRef} from "vue";
-import MicrosoftAuthButton from "../../components/verify/MicrosoftAuthButton.vue";
-import GoogleAuthButton from "../../components/verify/GoogleAuthButton.vue";
-import axios from "axios";
-import EmailAuthText from "../../components/verify/EmailAuthText.vue";
 import {User} from "../../stores/user.js";
 import LinkedAccountsTable from "../../components/verify/LinkedAccountsTable.vue";
 import LinkAccountButton from "../../components/verify/LinkAccountButton.vue";

ui/src/stores/meta.js

@@ -15,21 +15,20 @@ export class RoleMeta {
   }
 }
 
-export class GuildMeta {
-  constructor(id, name, icon, roles) {
+export class PartialGuildMeta {
+  constructor(id, name, icon) {
     this.id = id;
     this.name = name;
     this.icon = icon;
-    this.roles = roles;
   }
 
   static fromJson(json) {
-    return new GuildMeta(json['id'], json['name'], json['icon'], json['roles'].map(RoleMeta.fromJson));
+    return new PartialGuildMeta(json['id'], json['name'], json['icon']);
   }
 
   static async fetchAll(token) {
     let r = await axios.get(`${VITE_KB_API_URL}/meta/guilds`,
       { headers: { 'Authorization': 'Discord ' + token } });
-    return r.data.map(GuildMeta.fromJson);
+    return r.data.map(PartialGuildMeta.fromJson);
   }
 }