diff options
author | Akshay <[email protected]> | 2020-12-24 05:21:40 +0000 |
---|---|---|
committer | Akshay <[email protected]> | 2020-12-24 05:21:40 +0000 |
commit | 9d2b6ee10ec5359cc91769d430485c8c869ba1a8 (patch) | |
tree | b2d541e575ab6e3f70cb709f156f06afca085881 /src/handlers/users.rs | |
parent | 7c65421328552b08e64df25e224fe9d54d363e6e (diff) |
monorepo
Diffstat (limited to 'src/handlers/users.rs')
-rw-r--r-- | src/handlers/users.rs | 148 |
1 files changed, 0 insertions, 148 deletions
diff --git a/src/handlers/users.rs b/src/handlers/users.rs deleted file mode 100644 index 24fb591..0000000 --- a/src/handlers/users.rs +++ /dev/null | |||
@@ -1,148 +0,0 @@ | |||
1 | use crate::models::{Customer, NewCustomer}; | ||
2 | use crate::schema::customer::dsl::*; | ||
3 | use crate::TPool; | ||
4 | |||
5 | use actix_identity::Identity; | ||
6 | use actix_web::{web, HttpResponse, Responder}; | ||
7 | use bcrypt::{hash, verify, DEFAULT_COST}; | ||
8 | use diesel::prelude::*; | ||
9 | use log::{error, info}; | ||
10 | use serde::Deserialize; | ||
11 | |||
12 | pub async fn new_user( | ||
13 | pool: web::Data<TPool>, | ||
14 | item: web::Json<NewCustomer>, | ||
15 | ) -> impl Responder { | ||
16 | info!("Creating ... {:?}", item.username); | ||
17 | let conn = pool.get().unwrap(); | ||
18 | let hashed_item = NewCustomer { | ||
19 | password: hash(&item.password, DEFAULT_COST).unwrap(), | ||
20 | ..(item.into_inner()) | ||
21 | }; | ||
22 | diesel::insert_into(customer) | ||
23 | .values(hashed_item) | ||
24 | .execute(&conn) | ||
25 | .expect("Coundn't connect to DB"); | ||
26 | HttpResponse::Ok().body("Inserted successfully!") | ||
27 | } | ||
28 | |||
29 | pub async fn name_exists( | ||
30 | pool: web::Data<TPool>, | ||
31 | item: String, | ||
32 | ) -> impl Responder { | ||
33 | let conn = pool.get().unwrap(); | ||
34 | info!("target: {:?}", item); | ||
35 | if (customer | ||
36 | .filter(username.eq(&item)) | ||
37 | .limit(1) | ||
38 | .load::<Customer>(&conn) | ||
39 | .expect("Coundn't connect to DB")) | ||
40 | .len() | ||
41 | > 0 | ||
42 | { | ||
43 | HttpResponse::Ok().body("true") | ||
44 | } else { | ||
45 | HttpResponse::Ok().body("false") | ||
46 | } | ||
47 | } | ||
48 | |||
49 | #[derive(Deserialize)] | ||
50 | pub struct Login { | ||
51 | username: String, | ||
52 | password: String, | ||
53 | } | ||
54 | |||
55 | pub async fn login( | ||
56 | pool: web::Data<TPool>, | ||
57 | cookie: Identity, | ||
58 | login_details: web::Json<Login>, | ||
59 | ) -> impl Responder { | ||
60 | info!("Login hit"); | ||
61 | if let Some(uname) = cookie.identity() { | ||
62 | info!("Found existing cookie: {:?}", cookie.identity()); | ||
63 | return HttpResponse::Ok().finish(); | ||
64 | } | ||
65 | let conn = pool.get().unwrap(); | ||
66 | let entered_pass = &login_details.password; | ||
67 | let selected_user = customer | ||
68 | .filter(username.eq(&login_details.username)) | ||
69 | .limit(1) | ||
70 | .first::<Customer>(&conn) | ||
71 | .expect("Couldn't connect to DB"); | ||
72 | let hashed_pass = selected_user.password; | ||
73 | if verify(entered_pass, &hashed_pass).unwrap() { | ||
74 | cookie.remember(login_details.username.clone()); | ||
75 | info!( | ||
76 | "Successful login: {} {}", | ||
77 | selected_user.username, selected_user.email_id | ||
78 | ); | ||
79 | HttpResponse::Ok().finish() | ||
80 | } else { | ||
81 | HttpResponse::Unauthorized().finish() | ||
82 | } | ||
83 | } | ||
84 | |||
85 | pub async fn logout(cookie: Identity) -> impl Responder { | ||
86 | cookie.forget(); | ||
87 | HttpResponse::Found().header("location", "/").finish() | ||
88 | } | ||
89 | |||
90 | pub async fn user_details( | ||
91 | uname: web::Path<String>, | ||
92 | pool: web::Data<TPool>, | ||
93 | ) -> impl Responder { | ||
94 | let conn = pool.get().unwrap(); | ||
95 | let uname = uname.into_inner(); | ||
96 | info!("Fetching info for: \"{}\"", uname); | ||
97 | let selected_user = customer | ||
98 | .filter(username.eq(&uname)) | ||
99 | .limit(1) | ||
100 | .first::<Customer>(&conn); | ||
101 | match selected_user { | ||
102 | Ok(m) => { | ||
103 | info!("Found user: {}", uname); | ||
104 | HttpResponse::Ok().json(m) | ||
105 | } | ||
106 | Err(_) => { | ||
107 | error!("User not found: {}", uname); | ||
108 | HttpResponse::NotFound().finish() | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | |||
113 | #[derive(Deserialize, Debug)] | ||
114 | pub struct ChangePassword { | ||
115 | old_password: String, | ||
116 | new_password: String, | ||
117 | } | ||
118 | |||
119 | pub async fn change_password( | ||
120 | cookie: Identity, | ||
121 | password_details: web::Json<ChangePassword>, | ||
122 | pool: web::Data<TPool>, | ||
123 | ) -> impl Responder { | ||
124 | info!("Change password request: {:?}", password_details); | ||
125 | let conn = pool.get().unwrap(); | ||
126 | if let Some(uname) = cookie.identity() { | ||
127 | let entered_pass = &password_details.old_password; | ||
128 | let new_password = &password_details.new_password; | ||
129 | let selected_user = customer | ||
130 | .filter(username.eq(&uname)) | ||
131 | .limit(1) | ||
132 | .first::<Customer>(&conn) | ||
133 | .expect("Couldn't connect to DB"); | ||
134 | let hashed_pass = selected_user.password; | ||
135 | if verify(entered_pass, &hashed_pass).unwrap() { | ||
136 | let hashed_new_password = | ||
137 | hash(&new_password, DEFAULT_COST).unwrap(); | ||
138 | diesel::update(customer.filter(id.eq(selected_user.id))) | ||
139 | .set(password.eq(hashed_new_password)) | ||
140 | .execute(&conn) | ||
141 | .unwrap(); | ||
142 | return HttpResponse::Ok().body("Changed password successfully"); | ||
143 | } else { | ||
144 | return HttpResponse::Ok().body("Invalid password"); | ||
145 | } | ||
146 | } | ||
147 | return HttpResponse::Unauthorized().body("Login first"); | ||
148 | } | ||