task manager minor refactor

gamercade_app/src/app.rs

@@ -1,4 +1,5 @@
 use eframe::egui::{self, Ui};
+use gamercade_interface::platform::FrontPageRequest;
 
 use crate::{
     local_directory::LocalDirectory,
@@ -41,6 +42,14 @@ impl eframe::App for App {
             //     self.tasks.tags.send_request(TagRequest::Initialize)
             // }
 
+            if ui.button("Front Page").clicked() {
+                self.tasks
+                    .platform
+                    .send(crate::task_manager::PlatformRequest::FrontPage(
+                        FrontPageRequest {},
+                    ))
+            }
+
             ui.horizontal(|ui| {
                 ui.selectable_value(&mut self.active_mode, AppMode::Arcade, "Arcade");
                 ui.selectable_value(&mut self.active_mode, AppMode::Library, "Library");
@@ -88,6 +97,9 @@ impl App {
                 TaskNotification::DownloadRomComplete(complete) => {
                     println!("TODO: Release download complete")
                 }
+                TaskNotification::FrontPageResponse(front_page_response) => {
+                    println!("TODO: Got Response: {front_page_response:?}");
+                }
             }
         }
     }

gamercade_app/src/local_directory/game.rs

@@ -6,21 +6,9 @@ pub struct Game {
     pub id: i64,
     pub title: String,
     pub short_description: String,
-    pub long_description: Option<String>,
-    pub releases: Vec<GameRelease>,
+    pub long_description: String,
     pub tags: Vec<TagId>,
-    pub rating: Option<f32>,
-    pub images: Vec<GameImage>,
-}
-
-pub struct GameRelease {
-    pub id: i64,
-    pub checksum: i64,
-    pub name: String,
-}
-
-pub struct GameImage {
-    pub path: String,
+    pub rating: f32,
 }
 
 const UPSERT_GAMES_QUERIES: &str = "
@@ -31,19 +19,10 @@ CREATE TABLE IF NOT EXISTS games (
     short_description TEXT NOT NULL,
     long_description TEXT NOT NULL,
     rating REAL,
+    file_checksum INTEGER,
     UNIQUE(title)
 ) STRICT;
 
-CREATE TABLE IF NOT EXISTS releases(
-    id INTEGER PRIMARY KEY,
-    file_checksum BLOB,
-    game_id INTEGER NOT NULL,
-    release_name TEXT NOT NULL,
-    FOREIGN KEY (game_id) REFERENCES games (id),
-    UNIQUE(game_id, file_checksum),
-    UNIQUE(game_id, release_name)
-) STRICT;
-
 CREATE TABLE IF NOT EXISTS game_tags(
     id INTEGER PRIMARY KEY,
     game_id INTEGER NOT NULL,

gamercade_app/src/task_manager/auth.rs

@@ -1,3 +1,5 @@
+use std::fmt::Debug;
+
 use gamercade_interface::{
     auth::{
         auth_service_client::AuthServiceClient, login_request::Provider, LoginRequest,
@@ -47,6 +49,15 @@ pub enum AuthRequest {
     SignUp(SignUpRequest),
 }
 
+impl Debug for AuthRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Login(_) => f.write_str("Login(Fields Hidden)"),
+            Self::SignUp(_) => f.write_str("SignUp(Fields Hidden)"),
+        }
+    }
+}
+
 impl TaskRequest<AuthManagerState> for AuthRequest {
     async fn handle_request(
         self,

gamercade_app/src/task_manager/authors.rs

@@ -58,6 +58,7 @@ impl TaskRequest<AuthorManagerState> for AuthorRequest {
     }
 }
 
+#[derive(Debug)]
 pub enum AuthorRequest {
     Initialize,
 }

gamercade_app/src/task_manager/game.rs

@@ -51,9 +51,3 @@ impl TaskRequest<GameManagerState> for GameRequest {
         }
     }
 }
-
-impl GameManager {
-    pub fn send(&mut self, request: GameRequest) {
-        self.sender.try_send(request).unwrap()
-    }
-}

gamercade_app/src/task_manager/mod.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{fmt::Debug, sync::Arc};
 
 use tokio::sync::{
     mpsc::{channel, Sender},
@@ -23,6 +23,9 @@ pub use rom::*;
 mod game;
 pub use game::*;
 
+mod platform;
+pub use platform::*;
+
 const SUPER_TASK_CHANNEL_SIZE: usize = 256;
 const TASK_CHANNEL_LENGTH: usize = 8;
 
@@ -34,7 +37,7 @@ pub struct TaskManager<STATE, REQUEST> {
 impl<STATE, REQUEST> TaskManager<STATE, REQUEST>
 where
     STATE: Default + Send + 'static,
-    REQUEST: Send + 'static + TaskRequest<STATE>,
+    REQUEST: Send + 'static + TaskRequest<STATE> + Debug,
 {
     pub fn new(notification_tx: Sender<TaskNotification>) -> Self {
         let state = Arc::new(Mutex::new(STATE::default()));
@@ -59,6 +62,10 @@ where
 
         client_sender
     }
+
+    pub fn send(&self, message: REQUEST) {
+        self.sender.try_send(message).unwrap()
+    }
 }
 
 pub trait TaskRequest<STATE: Send> {

gamercade_app/src/task_manager/platform.rs

@@ -0,0 +1,53 @@
+use gamercade_interface::{
+    platform::{
+        platform_service_client::PlatformServiceClient, FrontPageRequest, GameSearchRequest,
+    },
+    Session,
+};
+use tokio::sync::OnceCell;
+use tonic::{transport::Channel, Request};
+
+use crate::urls::{WithSession, SERVICE_IP_GRPC};
+
+use super::{TaskManager, TaskNotification, TaskRequest};
+
+pub type PlatformManager = TaskManager<PlatformManagerState, PlatformRequest>;
+
+async fn init_platform_client() -> PlatformServiceClient<Channel> {
+    PlatformServiceClient::connect(SERVICE_IP_GRPC)
+        .await
+        .unwrap()
+}
+
+#[derive(Default)]
+pub struct PlatformManagerState {
+    client: OnceCell<PlatformServiceClient<Channel>>,
+}
+
+#[derive(Debug)]
+pub enum PlatformRequest {
+    FrontPage(FrontPageRequest),
+    Search(GameSearchRequest),
+}
+
+impl TaskRequest<PlatformManagerState> for PlatformRequest {
+    async fn handle_request(
+        self,
+        sender: &tokio::sync::mpsc::Sender<super::TaskNotification>,
+        state: &tokio::sync::Mutex<PlatformManagerState>,
+    ) {
+        let mut lock = state.lock().await;
+        lock.client.get_or_init(init_platform_client).await;
+        let client = lock.client.get_mut().unwrap();
+
+        match self {
+            PlatformRequest::FrontPage(request) => match client.front_page(request).await {
+                Ok(response) => sender
+                    .try_send(TaskNotification::FrontPageResponse(response.into_inner()))
+                    .unwrap(),
+                Err(err) => println!("front page response err: {err}"),
+            },
+            PlatformRequest::Search(request) => todo!(),
+        }
+    }
+}

gamercade_app/src/task_manager/super_task_manager.rs

@@ -1,9 +1,10 @@
+use gamercade_interface::platform::FrontPageResponse;
 use tokio::sync::mpsc::{channel, Receiver};
 
 use crate::local_directory::{PermissionLevel, PermissionLevelId, Tag, TagId};
 
 use super::{
-    AuthManager, AuthState, AuthorManager, GameManager, RomManager, TagManager,
+    AuthManager, AuthState, AuthorManager, GameManager, PlatformManager, RomManager, TagManager,
     SUPER_TASK_CHANNEL_SIZE,
 };
 
@@ -14,6 +15,9 @@ pub enum TaskNotification {
     AuthStateChanged(AuthState),
     LoginFailed,
     DownloadRomComplete(DownloadRomComplete),
+
+    // Platform
+    FrontPageResponse(FrontPageResponse),
 }
 
 #[derive(Debug)]
@@ -29,6 +33,7 @@ pub struct SuperTaskManager {
     pub auth: AuthManager,
     pub rom: RomManager,
     pub game: GameManager,
+    pub platform: PlatformManager,
 }
 
 impl Default for SuperTaskManager {
@@ -41,6 +46,7 @@ impl Default for SuperTaskManager {
             auth: AuthManager::new(event_tx.clone()),
             rom: RomManager::new(event_tx.clone()),
             game: GameManager::new(event_tx.clone()),
+            platform: PlatformManager::new(event_tx.clone()),
             events,
         }
     }

gamercade_app/src/task_manager/tags.rs

@@ -51,6 +51,7 @@ impl TaskRequest<TagManagerState> for TagRequest {
     }
 }
 
+#[derive(Debug)]
 pub enum TagRequest {
     Initialize,
 }

gamercade_interface/proto/platform.proto

@@ -20,9 +20,8 @@ message GameSearchRequest {
 }
 
 message FrontPageResponse {
-    map<sfixed64, game.GameInfoBasic> data = 1;
-
-    repeated sfixed64 popular_games = 2;
-    repeated sfixed64 top_rated_games = 3;
-    repeated sfixed64 new_games = 4;
+    repeated game.GameInfoBasic games = 1;
+    repeated sfixed64 popular_games_ids = 2;
+    repeated sfixed64 top_rated_games_ids = 3;
+    repeated sfixed64 new_games_ids = 4;
 }

gamercade_interface/src/output/platform.rs

@@ -13,14 +13,14 @@ pub struct GameSearchRequest {
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FrontPageResponse {
-    #[prost(map = "sfixed64, message", tag = "1")]
-    pub data: ::std::collections::HashMap<i64, super::game::GameInfoBasic>,
+    #[prost(message, repeated, tag = "1")]
+    pub games: ::prost::alloc::vec::Vec<super::game::GameInfoBasic>,
     #[prost(sfixed64, repeated, tag = "2")]
-    pub popular_games: ::prost::alloc::vec::Vec<i64>,
+    pub popular_games_ids: ::prost::alloc::vec::Vec<i64>,
     #[prost(sfixed64, repeated, tag = "3")]
-    pub top_rated_games: ::prost::alloc::vec::Vec<i64>,
+    pub top_rated_games_ids: ::prost::alloc::vec::Vec<i64>,
     #[prost(sfixed64, repeated, tag = "4")]
-    pub new_games: ::prost::alloc::vec::Vec<i64>,
+    pub new_games_ids: ::prost::alloc::vec::Vec<i64>,
 }
 /// Generated client implementations.
 pub mod platform_service_client {