Initial Auth Impl + More Caching (#647)

* Port redis to staging

* redis cache on staging

* add back legacy auth callback

* Begin work on new auth flows

* Finish all auth flows

* Finish base session authentication

* run prep + fix clippy

* make compilation work

src/models/ids.rs

@@ -3,6 +3,7 @@ use thiserror::Error;
 pub use super::notifications::NotificationId;
 pub use super::projects::{ProjectId, VersionId};
 pub use super::reports::ReportId;
+pub use super::sessions::SessionId;
 pub use super::teams::TeamId;
 pub use super::threads::ThreadId;
 pub use super::threads::ThreadMessageId;
@@ -113,6 +114,7 @@ base62_id_impl!(ReportId, ReportId);
 base62_id_impl!(NotificationId, NotificationId);
 base62_id_impl!(ThreadId, ThreadId);
 base62_id_impl!(ThreadMessageId, ThreadMessageId);
+base62_id_impl!(SessionId, SessionId);
 
 pub mod base62_impl {
     use serde::de::{self, Deserializer, Visitor};

src/models/mod.rs

@@ -4,6 +4,7 @@ pub mod notifications;
 pub mod pack;
 pub mod projects;
 pub mod reports;
+pub mod sessions;
 pub mod teams;
 pub mod threads;
 pub mod users;

src/models/projects.rs

@@ -165,8 +165,8 @@ impl From<QueryProject> for Project {
             followers: m.follows as u32,
             categories: data.categories,
             additional_categories: data.additional_categories,
-            game_versions: m.game_versions,
-            loaders: m.loaders,
+            game_versions: data.game_versions,
+            loaders: data.loaders,
             versions: data.versions.into_iter().map(|v| v.into()).collect(),
             icon_url: m.icon_url,
             issues_url: m.issues_url,
@@ -449,7 +449,7 @@ impl MonetizationStatus {
 }
 
 /// A specific version of a project
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Version {
     /// The ID of the version, encoded as a base62 string.
     pub id: VersionId,
@@ -633,7 +633,7 @@ impl VersionStatus {
 }
 
 /// A single project file, with a url for the file and the file's hash
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct VersionFile {
     /// A map of hashes of the file.  The key is the hashing algorithm
     /// and the value is the string version of the hash.
@@ -749,6 +749,15 @@ impl FileType {
             FileType::Unknown => "unknown",
         }
     }
+
+    pub fn from_str(string: &str) -> FileType {
+        match string {
+            "required-resource-pack" => FileType::RequiredResourcePack,
+            "optional-resource-pack" => FileType::OptionalResourcePack,
+            "unknown" => FileType::Unknown,
+            _ => FileType::Unknown,
+        }
+    }
 }
 
 /// A specific version of Minecraft

src/models/reports.rs

@@ -1,5 +1,6 @@
 use super::ids::Base62Id;
-use crate::models::ids::{ThreadId, UserId};
+use crate::database::models::report_item::QueryReport as DBReport;
+use crate::models::ids::{ProjectId, ThreadId, UserId, VersionId};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
@@ -40,3 +41,33 @@ impl ItemType {
         }
     }
 }
+
+impl From<DBReport> for Report {
+    fn from(x: DBReport) -> Self {
+        let mut item_id = "".to_string();
+        let mut item_type = ItemType::Unknown;
+
+        if let Some(project_id) = x.project_id {
+            item_id = ProjectId::from(project_id).to_string();
+            item_type = ItemType::Project;
+        } else if let Some(version_id) = x.version_id {
+            item_id = VersionId::from(version_id).to_string();
+            item_type = ItemType::Version;
+        } else if let Some(user_id) = x.user_id {
+            item_id = UserId::from(user_id).to_string();
+            item_type = ItemType::User;
+        }
+
+        Report {
+            id: x.id.into(),
+            report_type: x.report_type,
+            item_id,
+            item_type,
+            reporter: x.reporter.into(),
+            body: x.body,
+            created: x.created,
+            closed: x.closed,
+            thread_id: x.thread_id.map(|x| x.into()),
+        }
+    }
+}

src/models/sessions.rs

@@ -0,0 +1,29 @@
+use super::ids::Base62Id;
+use crate::models::users::UserId;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(from = "Base62Id")]
+#[serde(into = "Base62Id")]
+pub struct SessionId(pub u64);
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Session {
+    pub id: SessionId,
+    pub session: String,
+    pub user_id: UserId,
+
+    pub created: DateTime<Utc>,
+    pub last_login: DateTime<Utc>,
+    pub expires: DateTime<Utc>,
+    pub refresh_expires: DateTime<Utc>,
+
+    pub os: Option<String>,
+    pub platform: Option<String>,
+    pub user_agent: String,
+
+    pub city: Option<String>,
+    pub country: Option<String>,
+    pub ip: String,
+}

src/models/threads.rs

@@ -82,3 +82,44 @@ impl ThreadType {
         }
     }
 }
+
+impl Thread {
+    pub fn from(data: crate::database::models::Thread, users: Vec<User>, user: &User) -> Self {
+        let thread_type = data.type_;
+
+        Thread {
+            id: data.id.into(),
+            type_: thread_type,
+            messages: data
+                .messages
+                .into_iter()
+                .filter(|x| {
+                    if let MessageBody::Text { private, .. } = x.body {
+                        !private || user.role.is_mod()
+                    } else {
+                        true
+                    }
+                })
+                .map(|x| ThreadMessage {
+                    id: x.id.into(),
+                    author_id: if users
+                        .iter()
+                        .find(|y| x.author_id == Some(y.id.into()))
+                        .map(|x| x.role.is_mod() && !user.role.is_mod())
+                        .unwrap_or(false)
+                    {
+                        None
+                    } else {
+                        x.author_id.map(|x| x.into())
+                    },
+                    body: x.body,
+                    created: x.created,
+                })
+                .collect(),
+            members: users
+                .into_iter()
+                .filter(|x| !x.role.is_mod() || user.role.is_mod())
+                .collect(),
+        }
+    }
+}

src/models/users.rs

@@ -37,7 +37,6 @@ impl Default for Badges {
 #[derive(Serialize, Deserialize, Clone)]
 pub struct User {
     pub id: UserId,
-    pub kratos_id: Option<String>, // None if legacy user unconnected to Minos/Kratos
     pub username: String,
     pub name: Option<String>,
     pub email: Option<String>,
@@ -48,11 +47,11 @@ pub struct User {
     pub badges: Badges,
     pub payout_data: Option<UserPayoutData>,
     pub github_id: Option<u64>,
-    pub discord_id: Option<u64>,
-    pub google_id: Option<u128>,
-    pub microsoft_id: Option<u64>,
-    pub apple_id: Option<u64>,
-    pub gitlab_id: Option<u64>,
+    // pub discord_id: Option<u64>,
+    // pub google_id: Option<u128>,
+    // pub microsoft_id: Option<u64>,
+    // pub apple_id: Option<u64>,
+    // pub gitlab_id: Option<u64>,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -136,7 +135,6 @@ impl From<DBUser> for User {
     fn from(data: DBUser) -> Self {
         Self {
             id: data.id.into(),
-            kratos_id: data.kratos_id,
             username: data.username,
             name: data.name,
             email: None,
@@ -147,11 +145,11 @@ impl From<DBUser> for User {
             badges: data.badges,
             payout_data: None,
             github_id: None,
-            discord_id: None,
-            google_id: None,
-            microsoft_id: None,
-            apple_id: None,
-            gitlab_id: None,
+            // discord_id: None,
+            // google_id: None,
+            // microsoft_id: None,
+            // apple_id: None,
+            // gitlab_id: None,
         }
     }
 }