login tocken continue

server/Cargo.lock

@@ -75,6 +75,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "fastrand"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b394ed3d285a429378d3b384b9eb1285267e7df4b166df24b7a6939a04dc392e"
+dependencies = [
+ "instant",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -215,6 +224,7 @@ checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 name = "hastic"
 version = "0.0.1"
 dependencies = [
+ "fastrand",
  "parking_lot",
  "serde",
  "tokio",

server/Cargo.toml

@@ -10,3 +10,4 @@ tokio = { version = "1", features = ["full"] }
 warp = "0.3"
 parking_lot = "0.11.2"
 serde = { version = "1.0", features = ["derive"] }
+fastrand = "1.5.0"

server/src/api.rs

@@ -16,13 +16,12 @@ impl API {
         API{}
     }
 
-    fn builder(s: &str) -> Result<Response<String>, warp::http::Error> {
+    fn builder<T>(s: T) -> Result<Response<T>, warp::http::Error> {
         return Response::builder()
             .header("Access-Control-Allow-Origin", "*")
             .header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE")
             .header("Access-Control-Allow-Headers", "*")
-            .body(s.to_owned())
-    
+            .body(s)
     }
 
     pub async fn serve() {
@@ -32,6 +31,7 @@ impl API {
         println!("Start server on 8000 port");
         warp::serve(login.
             or(lg)
+            
         )
             .run(([127, 0, 0, 1], 8000))
             .await;

server/src/api/auth.rs

@@ -1,17 +1,32 @@
-use crate::api::API;
-use crate::services::user_service;
+use hastic::services::user_service;
 
+use warp::http::HeaderValue;
 use warp::{Rejection, Reply};
 use warp::filters::method::post;
 use warp::{Filter, http::Response };
 
+use serde::{ Serialize };
+
+#[derive(Serialize)]
+struct SigninResp {
+    token: user_service::AccessToken
+}
 
 pub fn get_route() -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
     return warp::path!("api" / "auth" / "signin")
         .and(post())
         .and(warp::body::json())
         .map(|user: user_service::User| {
-            let s = format!("Hello, {}!", &user.username);
-            API::builder(&s)
+            let token = "asdsad".to_string();
+            // user_service::
+            let j = warp::reply::json(&SigninResp{ token });
+            let mut rs = j.into_response();
+            let hs = rs.headers_mut();
+            hs.insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
+            hs.insert("Access-Control-Allow-Methods", HeaderValue::from_static("POST, GET, OPTIONS, DELETE"));
+            hs.insert("Access-Control-Allow-Headers", HeaderValue::from_static("*"));
+
+            rs
+            // API::builder(j)
         });
 }

server/src/services/user_service.rs

@@ -1,8 +1,14 @@
+use std::{collections::HashSet};
+
 use serde::{ Deserialize, Serialize };
 
+use std::iter::repeat_with;
+
 
 pub type AccessToken = String;
 
+const TOKEN_LENGTH: usize = 20;
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct User {
     pub username: String,
@@ -10,17 +16,24 @@ pub struct User {
 }
 
 pub struct UserService {
-
+    tokens: HashSet<AccessToken>
 }
 
 impl UserService {
     pub fn new() -> UserService {
-        UserService{}
+        UserService{
+            tokens: HashSet::new()
+        }
     }
-    pub fn login(user: &User) -> Option<AccessToken> {
+    pub fn login(&mut self, user: &User) -> Option<AccessToken> {
         if user.username == "admin" && user.password == "admin" {
-            return Some("asdsadsad".to_string());
+            let token: AccessToken = repeat_with(fastrand::alphanumeric).take(TOKEN_LENGTH).collect();
+            self.tokens.insert(token.to_owned());
+            return Some(token);
         }
         return None;
     }
+    pub fn check_token(&self, username: &String, token: &AccessToken ) -> bool {
+        return self.tokens.contains(token);
+    }
 }