get rid of useless stuff, more splitting

Author: Your Name

src/config.rs

@@ -3,8 +3,6 @@ use once_cell::sync::Lazy;
 use poise::serenity_prelude::{ChannelId, GuildId, RoleId, UserId};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fs::File, io::Write};
-use ts_rs::TS;
-use utoipa::ToSchema;
 
 pub static CURRENT_ENV: Lazy<&str> = Lazy::new(|| {
     let current_env = include_bytes!("../current-env");
@@ -124,8 +122,7 @@ pub struct PanelConfig {
     pub panel_response_scope: String,
 }
 
-#[derive(Serialize, Deserialize, TS, ToSchema, Clone, Default)]
-#[ts(export, export_to = ".generated/CdnScopeData.ts")]
+#[derive(Serialize, Deserialize, Clone, Default)]
 pub struct CdnScopeData {
     /// Path in local fs (or remote if support is added)
     pub path: String,

src/panelapi/actions/baseanalytics.rs

@@ -0,0 +1,69 @@
+use crate::panelapi::auth::check_auth;
+use crate::panelapi::core::{AppState, Error};
+use crate::panelapi::types::analytics::BaseAnalytics;
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+
+pub async fn base_analytics(state: &AppState, login_token: String) -> Result<Response, Error> {
+    check_auth(&state.pool, &login_token)
+        .await
+        .map_err(Error::new)?;
+
+    let bot_counts = sqlx::query!("SELECT type, COUNT(*) FROM bots GROUP BY type")
+        .fetch_all(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+    let server_counts = sqlx::query!("SELECT type, COUNT(*) FROM servers GROUP BY type")
+        .fetch_all(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+    let ticket_counts = sqlx::query!("SELECT open, COUNT(*) FROM tickets GROUP BY open")
+        .fetch_all(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+    let total_users = sqlx::query!("SELECT COUNT(*) FROM users")
+        .fetch_one(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+    let total_changelogs = sqlx::query!("SELECT COUNT(*) FROM changelogs")
+        .fetch_one(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+    Ok((
+        StatusCode::OK,
+        Json(BaseAnalytics {
+            bot_counts: bot_counts
+                .iter()
+                .map(|b| (b.r#type.clone(), b.count.unwrap_or_default()))
+                .collect(),
+            server_counts: server_counts
+                .iter()
+                .map(|s| (s.r#type.clone(), s.count.unwrap_or_default()))
+                .collect(),
+            ticket_counts: ticket_counts
+                .iter()
+                .map(|t| {
+                    (
+                        if t.open {
+                            "open".to_string()
+                        } else {
+                            "closed".to_string()
+                        },
+                        t.count.unwrap_or_default(),
+                    )
+                })
+                .collect(),
+            total_users: total_users.count.unwrap_or_default(),
+            changelogs_count: total_changelogs.count.unwrap_or_default(),
+        }),
+    )
+        .into_response())
+}

src/panelapi/actions/getuser.rs

@@ -0,0 +1,28 @@
+use crate::impls::dovewing::{get_platform_user, DovewingSource};
+use crate::panelapi::auth::check_auth;
+use crate::panelapi::core::{AppState, Error};
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+
+pub async fn get_user(
+    state: &AppState,
+    login_token: String,
+    user_id: String,
+) -> Result<Response, Error> {
+    check_auth(&state.pool, &login_token)
+        .await
+        .map_err(Error::new)?;
+
+    let user = get_platform_user(
+        &state.pool,
+        DovewingSource::Discord(state.cache_http.clone()),
+        &user_id,
+    )
+    .await
+    .map_err(Error::new)?;
+
+    Ok((StatusCode::OK, Json(user)).into_response())
+}

src/panelapi/actions/mod.rs

@@ -1,2 +1,8 @@
 pub mod authorize;
+pub mod baseanalytics;
+pub mod getuser;
 pub mod hello;
+pub mod searchentitys;
+pub mod updatepartners;
+pub mod updatestaffmembers;
+pub mod updatestaffposition;

src/panelapi/actions/searchentitys.rs

@@ -0,0 +1,130 @@
+use crate::impls::dovewing::{get_platform_user, DovewingSource};
+use crate::impls::target_types::TargetType;
+use crate::impls::utils::get_entity_managers;
+use crate::panelapi::auth::check_auth;
+use crate::panelapi::core::{AppState, Error};
+use crate::panelapi::types::entity::{PartialBot, PartialEntity, PartialServer};
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+
+pub async fn search_entitys(
+    state: &AppState,
+    login_token: String,
+    target_type: TargetType,
+    query: String,
+) -> Result<Response, Error> {
+    check_auth(&state.pool, &login_token)
+        .await
+        .map_err(Error::new)?;
+
+    match target_type {
+        TargetType::Bot => {
+            let queue = sqlx::query!(
+            "
+            SELECT bot_id, client_id, type, approximate_votes, shards, library, invite_clicks, clicks,
+            servers, last_claimed, claimed_by, approval_note, short, invite FROM bots
+            INNER JOIN internal_user_cache__discord discord_users ON bots.bot_id = discord_users.id
+            WHERE bot_id = $1 OR client_id = $1 OR discord_users.username ILIKE $2 ORDER BY bots.created_at
+            ",
+            query,
+            format!("%{}%", query)
+        )
+        .fetch_all(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+            let mut bots = Vec::new();
+
+            for bot in queue {
+                let owners = get_entity_managers(TargetType::Bot, &bot.bot_id, &state.pool)
+                    .await
+                    .map_err(Error::new)?;
+
+                let user = get_platform_user(
+                    &state.pool,
+                    DovewingSource::Discord(state.cache_http.clone()),
+                    &bot.bot_id,
+                )
+                .await
+                .map_err(Error::new)?;
+
+                bots.push(PartialEntity::Bot(PartialBot {
+                    bot_id: bot.bot_id,
+                    client_id: bot.client_id,
+                    user,
+                    r#type: bot.r#type,
+                    votes: bot.approximate_votes,
+                    shards: bot.shards,
+                    library: bot.library,
+                    invite_clicks: bot.invite_clicks,
+                    clicks: bot.clicks,
+                    servers: bot.servers,
+                    claimed_by: bot.claimed_by,
+                    last_claimed: bot.last_claimed,
+                    approval_note: bot.approval_note,
+                    short: bot.short,
+                    mentionable: owners.mentionables(),
+                    invite: bot.invite,
+                }));
+            }
+
+            Ok((StatusCode::OK, Json(bots)).into_response())
+        }
+        TargetType::Server => {
+            let queue = sqlx::query!(
+            "
+            SELECT server_id, name, total_members, online_members, short, type, approximate_votes, invite_clicks,
+            clicks, nsfw, tags, premium, claimed_by, last_claimed FROM servers
+            WHERE server_id = $1 OR name ILIKE $2 ORDER BY created_at
+            ",
+            query,
+            format!("%{}%", query)
+        )
+        .fetch_all(&state.pool)
+        .await
+        .map_err(Error::new)?;
+
+            let mut servers = Vec::new();
+
+            for server in queue {
+                let owners =
+                    get_entity_managers(TargetType::Server, &server.server_id, &state.pool)
+                        .await
+                        .map_err(Error::new)?;
+
+                servers.push(PartialEntity::Server(PartialServer {
+                    server_id: server.server_id.clone(),
+                    name: server.name,
+                    avatar: format!(
+                        "{}/servers/avatars/{}.webp",
+                        crate::config::CONFIG.cdn_url,
+                        server.server_id
+                    ),
+                    total_members: server.total_members,
+                    online_members: server.online_members,
+                    short: server.short,
+                    r#type: server.r#type,
+                    votes: server.approximate_votes,
+                    invite_clicks: server.invite_clicks,
+                    clicks: server.clicks,
+                    nsfw: server.nsfw,
+                    tags: server.tags,
+                    premium: server.premium,
+                    claimed_by: server.claimed_by,
+                    last_claimed: server.last_claimed,
+                    mentionable: owners.mentionables(),
+                }));
+            }
+
+            Ok((StatusCode::OK, Json(servers)).into_response())
+        }
+        _ => Ok((
+            StatusCode::NOT_IMPLEMENTED,
+            "Searching this target type is not implemented".to_string(),
+        )
+            .into_response()),
+    }
+}