From 057382f8d138c63cdc48b0facd9bf4a4a229057a Mon Sep 17 00:00:00 2001
From: Akshay <nerdy@peppe.rs>
Date: Sun, 4 Oct 2020 13:23:46 +0530
Subject: init

---
 src/handlers/users.rs | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 src/handlers/users.rs

(limited to 'src/handlers/users.rs')

diff --git a/src/handlers/users.rs b/src/handlers/users.rs
new file mode 100644
index 0000000..e6b0415
--- /dev/null
+++ b/src/handlers/users.rs
@@ -0,0 +1,106 @@
+use crate::models::{Member, NewMember};
+use crate::schema::members::dsl::*;
+use crate::TPool;
+
+use actix_identity::Identity;
+use actix_web::{web, HttpResponse, Responder};
+use bcrypt::{hash, verify, DEFAULT_COST};
+use diesel::prelude::*;
+use log::{error, info};
+use serde::Deserialize;
+
+pub async fn new_user(
+    pool: web::Data<TPool>,
+    item: web::Json<NewMember>,
+) -> impl Responder {
+    let conn = pool.get().unwrap();
+    let hashed_item = NewMember {
+        password: hash(&item.password, DEFAULT_COST).unwrap(),
+        ..(item.into_inner())
+    };
+    diesel::insert_into(members)
+        .values(hashed_item)
+        .execute(&conn)
+        .expect("Coundn't connect to DB");
+    HttpResponse::Ok().body("Inserted successfully!")
+}
+
+pub async fn name_exists(
+    pool: web::Data<TPool>,
+    item: String,
+) -> impl Responder {
+    let conn = pool.get().unwrap();
+    info!("target: {:?}", item);
+    if (members
+        .filter(username.eq(&item))
+        .limit(1)
+        .load::<Member>(&conn)
+        .expect("Coundn't connect to DB"))
+    .len()
+        > 0
+    {
+        HttpResponse::Ok().body("true")
+    } else {
+        HttpResponse::Ok().body("false")
+    }
+}
+
+#[derive(Deserialize)]
+pub struct Login {
+    username: String,
+    password: String,
+}
+
+pub async fn login(
+    pool: web::Data<TPool>,
+    cookie: Identity,
+    login_details: web::Json<Login>,
+) -> impl Responder {
+    info!("Login hit");
+    let conn = pool.get().unwrap();
+    let entered_pass = &login_details.password;
+    let selected_user = members
+        .filter(username.eq(&login_details.username))
+        .limit(1)
+        .first::<Member>(&conn)
+        .expect("Couldn't connect to DB");
+    let hashed_pass = selected_user.password;
+    if verify(entered_pass, &hashed_pass).unwrap() {
+        cookie.remember(login_details.username.clone());
+        info!(
+            "Successful login: {} {}",
+            selected_user.username, selected_user.email_id
+        );
+        HttpResponse::Ok().finish()
+    } else {
+        HttpResponse::Unauthorized().finish()
+    }
+}
+
+pub async fn logout(cookie: Identity) -> impl Responder {
+    cookie.forget();
+    HttpResponse::Found().header("location", "/").finish()
+}
+
+pub async fn user_details(
+    uname: web::Path<String>,
+    pool: web::Data<TPool>,
+) -> impl Responder {
+    let conn = pool.get().unwrap();
+    let uname = uname.into_inner();
+    info!("Fetching info for: \"{}\"", uname);
+    let selected_user = members
+        .filter(username.eq(&uname))
+        .limit(1)
+        .first::<Member>(&conn);
+    match selected_user {
+        Ok(m) => {
+            info!("Found user: {}", uname);
+            HttpResponse::Ok().json(m)
+        }
+        Err(_) => {
+            error!("User not found: {}", uname);
+            HttpResponse::NotFound().finish()
+        }
+    }
+}
-- 
cgit v1.2.3