Renamed directories

service/src/users/mod.rs

@@ -0,0 +1,7 @@
+mod model;
+mod routes;
+mod user_type;
+
+pub use user_type::PgUserType;
+pub use model::*;
+pub use routes::init_routes;

service/src/users/model.rs

@@ -0,0 +1,50 @@
+use std::{future::Future, pin::Pin, sync::RwLock};
+
+use actix_web::{dev::Payload, error::ErrorUnauthorized, web, Error, FromRequest, HttpRequest};
+use actix_identity::Identity;
+use diesel::{query_builder::AsChangeset, prelude::Insertable};
+use log::warn;
+use crate::schema::users;
+use serde::{Serialize, Deserialize};
+
+use super::user_type::UserType;
+
+#[derive(Serialize, Deserialize, AsChangeset, Insertable)]
+#[diesel(table_name = users)]
+pub struct InsertUser {
+  first_name: String,
+  last_name: String,
+  user_type: UserType,
+  favorites: Vec<String>
+}
+
+// impl FromRequest for InsertUser {
+//   type Config = ();
+//   type Error = Error;
+//   type Future = Pin<Box<dyn Future<Output = Result<Self, Error>>>>;
+
+//   fn from_request(req: &HttpRequest, pl: &mut Payload) -> Self::Future {
+//       let fut = Identity::from_request(req, pl);
+//       let sessions: Option<&web::Data<RwLock<Sessions>>> = req.app_data();
+//       if sessions.is_none() {
+//           warn!("sessions is empty(none)!");
+//           return Box::pin(async { Err(ErrorUnauthorized("unauthorized")) });
+//       }
+//       let sessions = sessions.unwrap().clone();
+//       Box::pin(async move {
+//           if let Some(identity) = fut.await?.identity() {
+//               if let Some(user) = sessions
+//                   .read()
+//                   .unwrap()
+//                   .map
+//                   .get(&identity)
+//                   .map(|x| x.clone())
+//               {
+//                   return Ok(user);
+//               }
+//           };
+
+//           Err(ErrorUnauthorized("unauthorized"))
+//       })
+//   }
+// }

service/src/users/routes.rs

@@ -0,0 +1,51 @@
+use actix_web::{get, post, delete, put, web, HttpResponse};
+
+#[get("users")]
+async fn get() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[get("users/{id}")]
+async fn get_all() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[post("users")]
+async fn create() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[delete("users")]
+async fn delete() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[put("users")]
+async fn update() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[get("users/favorites")]
+async fn get_favorites() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[post("users/favorites")]
+async fn add_favorite() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+#[delete("users/favorites")]
+async fn delete_favorite() -> HttpResponse {
+  HttpResponse::NotImplemented().finish()
+}
+
+pub fn init_routes(config: &mut web::ServiceConfig) {
+  config.service(get);
+  config.service(create);
+  config.service(delete);
+  config.service(update);
+  config.service(get_favorites);
+  config.service(add_favorite);
+  config.service(delete_favorite);
+}

service/src/users/user_type.rs

@@ -0,0 +1,35 @@
+use std::io::Write;
+
+use diesel::{sql_types::SqlType, deserialize::{FromSqlRow, FromSql, self}, expression::AsExpression, serialize::{ToSql, Output, self, IsNull}, pg::{Pg, PgValue}};
+use serde::{Serialize, Deserialize};
+
+#[derive(SqlType)]
+#[diesel(postgres_type(name = "User_Type"))]
+pub struct PgUserType;
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, FromSqlRow, AsExpression, Eq)]
+#[diesel(sql_type = PgUserType)]
+pub enum UserType {
+    Admin,
+    User,
+}
+
+impl ToSql<PgUserType, Pg> for UserType {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
+        match *self {
+          Self::Admin => out.write_all(b"admin")?,
+          Self::User => out.write_all(b"user")?,
+        }
+        Ok(IsNull::No)
+    }
+}
+
+impl FromSql<PgUserType, Pg> for UserType {
+    fn from_sql(bytes: PgValue<'_>) -> deserialize::Result<Self> {
+        match bytes.as_bytes() {
+            b"admin" => Ok(Self::Admin),
+            b"user" => Ok(Self::User),
+            _ => Err("Unrecognized enum variant".into()),
+        }
+    }
+}