Last cleanup

Reviewed-on: Roflin/gamenight#9

.gitignore

@@ -1,4 +1,4 @@
-/target
+/target/
+**/*.rs.bk
+Cargo.lock
 .vscode
-Rocket.toml
-*.sqlite

Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "gamenight"
-version = "0.1.0"
-authors = ["Dennis Brentjes <d.brentjes@gmail.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-rocket = { version = "0.5.0-rc.1", features = ["default", "json"] }
-libsqlite3-sys = { version = ">=0.8.0, <0.19.0", features = ["bundled"] }
-rocket_sync_db_pools = { version = "0.1.0-rc.1", features =  ["diesel_sqlite_pool"] }
-diesel = { version = "1.4.8", features = ["sqlite"] }
-diesel_migrations = "1.4.0"
-rocket_dyn_templates = { version = "0.1.0-rc.1", features = ["handlebars"] }
-chrono = "0.4.19"
-serde = "1.0.136"
-

Rocket.toml.example

@@ -1,4 +0,0 @@
-#Copy this file over to Rocket.toml after changing all relevant values.
-
-[global.databases]
-gamenight_database = { url = "gamenight.sqlite" }

backend-actix/.gitignore

@@ -0,0 +1,3 @@
+target
+src/models/
+docs/

backend-actix/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "backend-actix"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+gamenight-database = { path = "../gamenight-database"}
+actix-web = "4"
+actix-cors = "0.7"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+uuid = { version = "1.3.0", features = ["serde", "v4"] }
+chrono = { version = "0.4", features = ["serde"] }
+jsonwebtoken = "9.3"
+validator = { version = "0.20", features = ["derive"] }
+rand_core = { version = "0.9" }
+env_logger = "0.11"
+tracing-actix-web = "0.7"

backend-actix/build.rs

@@ -0,0 +1,29 @@
+use std::{fs::{exists, read_dir, remove_dir_all, File}, io::Write, process::Command};
+
+
+fn main() {
+
+    if exists("src/models").unwrap() {
+        remove_dir_all("src/models").unwrap();
+    }
+ 
+    let _ = 
+        Command::new("openapi-generator")
+            .args(["generate", "-i", "gamenight-api.yaml", "-g", "rust", "--global-property", "models"])
+            .output()
+            .expect("Failed to generate models sources for the gamenight API");
+
+    let mut file = File::create("src/models/mod.rs").unwrap();
+    let paths = read_dir("./src/models").unwrap();
+    for path in paths {
+        let path = path.unwrap();
+        let path = path.path();
+        let stem = path.file_stem().unwrap();
+        if stem == "mod" {
+            continue
+        }
+    
+        let line = format!("pub mod {};\n", stem.to_str().unwrap());
+        let _ = file.write(line.as_bytes()).unwrap();
+    }
+}

backend-actix/gamenight-api.yaml

@@ -0,0 +1,249 @@
+openapi: 3.0.0
+info:
+  title: Gamenight
+  version: '1.0'
+  contact:
+    name: Dennis Brentjes
+    email: dennis@brentj.es
+    url: 'https://brentj.es'
+  description: Api specifaction for a Gamenight server
+  license:
+    name: MIT
+servers:
+  - url: 'http://localhost:8080'
+    description: Gamenight
+paths:
+  /token:
+    get:
+      summary: ''
+      operationId: get-token
+      responses:
+        '200':
+          $ref: '#/components/responses/TokenResponse'
+        '401':
+          $ref: '#/components/responses/FailureResponse'
+      requestBody:
+        $ref: '#/components/requestBodies/LoginRequest'
+      description: Submit your credentials to get a JWT-token to use with the rest of the api.
+      parameters: []
+  /user:
+    post:
+      summary: ''
+      operationId: post-register
+      requestBody:
+        $ref: '#/components/requestBodies/RegisterRequest'
+      responses:
+        '200':
+          description: ''
+        '422':
+          $ref: '#/components/responses/FailureResponse'
+      description: 'Create a new user given a registration token and user information, username and email must be unique, and password and password_repeat must match.'
+    parameters: []
+    get:
+      description: 'Get a user from primary id'
+      parameters: []
+      responses:
+        '200':
+          $ref: '#/components/responses/UserResponse'
+  /gamenights:
+    get:
+      summary: Your GET endpoint
+      responses:
+        '200':
+          $ref: '#/components/responses/GamenightsResponse'
+        '400':
+          $ref: '#/components/responses/FailureResponse'
+        '401':
+          $ref: '#/components/responses/FailureResponse'
+      operationId: get-gamenights
+      security:
+        - JWT-Auth: []
+      description: Retrieve the list of gamenights on this gamenight server. Requires authorization.
+  /gamenight:
+    post:
+      summary: ''
+      operationId: post-gamenight
+      responses:
+        '200':
+          description: OK
+        '401':
+          $ref: '#/components/responses/FailureResponse'
+        '422':
+          $ref: '#/components/responses/FailureResponse'
+      security:
+        - JWT-Auth: []
+      requestBody:
+        $ref: '#/components/requestBodies/AddGamenight'
+      description: 'Add a gamenight by providing a name and a date, only available when providing an JWT token.'
+    get:
+      summary: ''
+      operationId: get-gamenight
+      responses:
+        '200':
+          $ref: '#/components/responses/GamenightResponse'
+        '401':
+          $ref: '#/components/responses/FailureResponse'
+        '422':
+          $ref: '#/components/responses/FailureResponse'
+      requestBody:
+        $ref: '#/components/requestBodies/GetGamenight'
+      security:
+        - JWT-Auth: []
+components:
+  schemas:
+    Gamenight:
+      title: Gamenight
+      type: object
+      properties:
+        id:
+          type: string
+        name:
+          type: string
+        datetime:
+          type: string
+        owner_id:
+          type: string
+        participants:
+          type: array
+          items:
+            type: string
+      required:
+        - id
+        - name
+        - datetime
+        - owner_id
+    Failure:
+      title: Failure
+      type: object
+      properties:
+        message:
+          type: string
+      description: 'Failure Reason'
+    Token:
+      title: Token
+      type: object
+      properties:
+        jwt_token:
+          type: string
+    Login:
+      title: Login
+      type: object
+      properties:
+        username:
+          type: string
+        password:
+          type: string
+      required:
+        - username
+        - password
+    Registration:
+      title: Registration
+      type: object
+      properties:
+        username:
+          type: string
+        email:
+          type: string
+        password:
+          type: string
+        password_repeat:
+          type: string
+        registration_token:
+          type: string
+      required:
+        - username
+        - email
+        - password
+        - password_repeat
+        - registration_token
+    AddGamenightRequestBody:
+      title: AddGamenightRequestBody
+      type: object
+      properties:
+        name:
+          type: string
+        datetime:
+          type: string
+    User:
+      type: object
+      properties:
+        id:
+          type: string
+        username:
+          type: string
+        email:
+          type: string
+      required:
+        - username
+  requestBodies:
+    LoginRequest:
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Login'
+    RegisterRequest:
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Registration'
+    AddGamenight:
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/AddGamenightRequestBody'
+    GetGamenight:
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              id:
+                type: string
+  responses:
+    TokenResponse:
+      description: Example response
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Token'
+    FailureResponse:
+      description: Example response
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Failure'
+        application/xml:
+          schema:
+            type: object
+            properties:
+              message:
+                type: string
+            required:
+              - message
+    GamenightsResponse:
+      description: Example response
+      content:
+        application/json:
+          schema:
+            type: array
+            items:
+              $ref: '#/components/schemas/Gamenight'
+    GamenightResponse:
+      description: A gamenight being hosted
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Gamenight'
+    UserResponse:
+      description: A user in the gamenight system
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/User'
+  securitySchemes:
+    JWT-Auth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT
+      description: ''
+

backend-actix/src/main.rs

@@ -0,0 +1,51 @@
+#[allow(unused_imports)]
+pub mod models;
+pub mod request;
+
+use actix_cors::Cors;
+use actix_web::middleware::Logger;
+use actix_web::HttpServer;
+use actix_web::App;
+use actix_web::http;
+use actix_web::web;
+use request::{*, login, register, gamenights};
+use tracing_actix_web::TracingLogger;
+use gamenight_database::*;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    let url = "postgres://root:root@127.0.0.1/gamenight";
+    
+    let pool = get_connection_pool(url);
+
+    let mut conn = pool.get_conn();
+    run_migration(&mut conn);
+
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    HttpServer::new(move || {
+        let cors = Cors::default()
+            .allowed_origin("0.0.0.0")
+            .allowed_origin_fn(|_origin, _req_head| { true })
+        .allowed_methods(vec!["GET", "POST"])
+        .allowed_headers(vec![http::header::AUTHORIZATION, http::header::ACCEPT])
+        .allowed_header(http::header::CONTENT_TYPE)
+        .max_age(3600);
+
+        App::new()
+            .wrap(cors)
+            .wrap(Logger::default())
+            .wrap(TracingLogger::default())
+            .app_data(web::Data::new(pool.clone()))
+            .service(login)
+            .service(register)
+            .service(gamenights)
+            .service(gamenight_post)
+            .service(gamenight_get)
+            .service(get_user)
+            .service(get_user_unauthenticated)
+    })
+    .bind(("::1", 8080))?
+    .run()
+    .await
+}

backend-actix/src/request/authorization.rs

@@ -0,0 +1,80 @@
+use std::future::{Ready, ready};
+
+use actix_web::{FromRequest, http, HttpRequest, dev::Payload, web::Data};
+use chrono::Utc;
+use jsonwebtoken::{encode, Header, EncodingKey, decode, DecodingKey, Validation};
+use serde::{Serialize, Deserialize};
+use uuid::Uuid;
+
+use gamenight_database::{user::{get_user, Role, User}, DbPool};
+
+use super::error::ApiError;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Claims {
+    exp: i64,
+    uid: Uuid
+}
+
+pub struct AuthUser {
+    pub id: Uuid,
+    pub username: String,
+    pub email: String,
+    pub role: Role,
+}
+
+impl From<User> for AuthUser  {
+    fn from(value: User) -> Self {
+        Self{
+            id: value.id,
+            username: value.username,
+            email: value.email,
+            role: value.role,
+        }
+    }
+}
+
+fn get_claims(req: &HttpRequest) -> Result<Claims, ApiError>  {
+    let token = req.headers()
+        .get(http::header::AUTHORIZATION)
+        .map(|h| h.to_str().unwrap().split_at(7).1.to_string());
+
+    let token = token.ok_or(ApiError{
+        status: 400,
+        message: "JWT-token was not specified in the Authorization header as Bearer: token".to_string()
+    })?;
+
+    let secret = "secret";
+    Ok(decode::<Claims>(token.as_str(), &DecodingKey::from_secret(secret.as_bytes()), &Validation::default())?.claims)
+}
+
+pub fn get_token(user: &User) -> Result<String, ApiError> {
+    let claims = Claims {
+        exp: Utc::now().timestamp() + chrono::Duration::days(7).num_seconds(),
+        uid: user.id,
+    };
+
+    let secret = "secret";
+    Ok(encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(secret.as_bytes()))?)
+}
+
+impl FromRequest for AuthUser {
+    type Error = ApiError;
+    type Future = Ready<Result<Self, Self::Error>>;
+
+    fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {
+        ready(
+            (|| -> Result<AuthUser, ApiError>{
+                let pool = req.app_data::<Data<DbPool>>().expect("No database configured");
+                let mut conn = pool.get().expect("couldn't get db connection from pool");
+                let uid = get_claims(req)?.uid;
+                let user = get_user(&mut conn, uid)?;
+                
+                Ok(user.into())
+            })()
+        )
+    }
+}

backend-actix/src/request/error.rs

@@ -0,0 +1,91 @@
+use std::fmt::{Display, Formatter, Result};
+use actix_web::{ResponseError, error::BlockingError, HttpResponse, http::{header::ContentType, StatusCode}};
+use serde::{Serialize, Deserialize};
+use validator::ValidationErrors;
+
+use gamenight_database::error::DatabaseError;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ApiError {
+    #[serde(skip_serializing)]
+    pub status: u16,
+    pub message: String
+}
+
+impl Display for ApiError {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl ResponseError for ApiError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::build(StatusCode::from_u16(self.status).unwrap())
+        .content_type(ContentType::json())
+        .body(serde_json::to_string(&self).unwrap())
+    }    
+}
+
+impl From<DatabaseError> for ApiError {
+    fn from(value: DatabaseError) -> Self {
+        ApiError {
+            //Todo, split this in unrecoverable and schema error
+            status: 500,
+            message: value.0
+        }
+    }
+}
+
+impl From<BlockingError> for ApiError {
+    fn from(value: BlockingError) -> Self {
+        ApiError {
+            status: 500,
+            message: value.to_string()
+        }
+    }
+}
+
+impl From<serde_json::Error> for ApiError {
+    fn from(value: serde_json::Error) -> Self {
+        ApiError {
+            status: 500,
+            message: value.to_string()
+        }
+    }
+}
+
+impl From<jsonwebtoken::errors::Error> for ApiError {
+    fn from(value: jsonwebtoken::errors::Error) -> Self {
+        ApiError {
+            status: 500,
+            message: value.to_string() 
+        }
+    }
+}
+
+impl From<ValidationErrors> for ApiError {
+    fn from(value: ValidationErrors) -> Self {
+        ApiError {
+            status: 422,
+            message: value.to_string()
+        }
+    }
+}
+
+impl From<chrono::ParseError> for ApiError {
+    fn from(value: chrono::ParseError) -> Self {
+        ApiError {
+            status: 422,
+            message: value.to_string()
+        }
+    }
+}
+
+impl From<uuid::Error> for ApiError {
+    fn from(value: uuid::Error) -> Self {
+        ApiError {
+            status: 422,
+            message: value.to_string()
+        }
+    }
+}

backend-actix/src/request/gamenight_handlers.rs

@@ -0,0 +1,66 @@
+use actix_web::{get, web, Responder, http::header::ContentType, HttpResponse, post};
+use chrono::{DateTime, ParseError};
+use uuid::Uuid;
+
+use gamenight_database::{gamenight::Gamenight, DbPool, GetConnection};
+
+use crate::{models::{gamenight, add_gamenight_request_body::AddGamenightRequestBody, get_gamenight_request::GetGamenightRequest}, request::authorization::AuthUser};
+use crate::request::error::ApiError;
+
+
+impl AddGamenightRequestBody {
+    pub fn into_with_user(&self, user: AuthUser) -> Result<Gamenight, ParseError> {
+        Ok(Gamenight {
+            datetime: DateTime::parse_from_rfc3339(&self.clone().datetime.unwrap())?.with_timezone(&chrono::Utc),
+            id: Uuid::new_v4(),
+            name: self.clone().name.unwrap().clone(),
+            owner_id: user.id
+        })
+    }
+}
+
+impl From<GetGamenightRequest> for Uuid {
+    fn from(value: GetGamenightRequest) -> Self {
+        Uuid::parse_str(value.id.unwrap().as_str()).unwrap()
+    }
+}
+
+#[get("/gamenights")]
+pub async fn gamenights(pool: web::Data<DbPool>, _user: AuthUser) -> Result<impl Responder, ApiError> {
+    let mut conn = pool.get_conn();
+    let gamenights: Vec<gamenight_database::gamenight::Gamenight> = gamenight_database::gamenights(&mut conn)?;
+
+    Ok(HttpResponse::Ok()
+        .content_type(ContentType::json())
+        .body(serde_json::to_string(&gamenights)?)
+    )
+}
+
+#[post("/gamenight")]
+pub async fn gamenight_post(pool: web::Data<DbPool>, user: AuthUser, gamenight_data: web::Json<AddGamenightRequestBody>) -> Result<impl Responder, ApiError> {
+    let mut conn = pool.get_conn();
+    
+    gamenight_database::gamenight::add_gamenight(&mut conn, gamenight_data.into_with_user(user)?)?;
+    
+    Ok(HttpResponse::Ok())
+}
+
+#[get("/gamenight")]
+pub async fn gamenight_get(pool: web::Data<DbPool>, _user: AuthUser, gamenight_data: web::Json<GetGamenightRequest>) -> Result<impl Responder, ApiError> {
+    let mut conn = pool.get_conn();
+
+    let gamenight = gamenight_database::gamenight::get_gamenight(&mut conn, gamenight_data.into_inner().into())?;
+    let participants = gamenight_database::gamenight_participants::get_participants(&mut conn, &gamenight.id)?;
+
+    let model = gamenight::Gamenight{
+        id: gamenight.id.to_string(),
+        datetime: gamenight.datetime.to_rfc3339(),
+        name: gamenight.name,
+        owner_id: gamenight.owner_id.to_string(),
+        participants: Some(participants.iter().map(|x| {x.to_string()}).collect())
+    };
+
+    Ok(HttpResponse::Ok()
+        .content_type(ContentType::json())
+        .body(serde_json::to_string(&model)?))
+}

backend-actix/src/request/mod.rs

@@ -0,0 +1,13 @@
+
+mod user_handlers;
+mod gamenight_handlers;
+mod error;
+mod authorization;
+
+pub use user_handlers::login;
+pub use user_handlers::register;
+pub use gamenight_handlers::gamenights;
+pub use gamenight_handlers::gamenight_post;
+pub use gamenight_handlers::gamenight_get;
+pub use user_handlers::get_user;
+pub use user_handlers::get_user_unauthenticated;

backend-actix/src/request/user_handlers.rs

@@ -0,0 +1,161 @@
+
+use actix_web::http::header::ContentType;
+use actix_web::{get, post, web, HttpResponse, Responder};
+use gamenight_database::user::{count_users_with_email, count_users_with_username};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+use validator::{Validate, ValidateArgs, ValidationError};
+use crate::models::login::Login;
+use crate::models::registration::Registration;
+use crate::models::token::Token;
+use crate::models::user::User;
+use crate::request::error::ApiError;
+use crate::request::authorization::get_token;
+use serde_json;
+use gamenight_database::{DbPool, GetConnection};
+
+use super::authorization::AuthUser;
+
+impl From<Login> for gamenight_database::user::LoginUser {
+    fn from(val: Login) -> Self {
+        gamenight_database::user::LoginUser {
+            username: val.username,
+            password: val.password
+        }
+    }
+}
+
+impl From<Registration> for gamenight_database::user::Register {
+    fn from(val: Registration) -> Self {
+        gamenight_database::user::Register {
+            email: val.email,
+            username: val.username,
+            password: val.password
+        }
+    }
+}
+
+pub struct RegisterContext<'v_a> {
+    pub pool: &'v_a DbPool
+}
+
+pub fn unique_username(username: &String, context: &RegisterContext) -> Result<(), ValidationError> {
+    let mut conn = context.pool.get_conn();
+
+    match count_users_with_username(&mut conn, username)
+    {
+        Ok(0) => Ok(()),
+        Ok(_) => Err(ValidationError::new("User already exists")),
+        Err(_) => Err(ValidationError::new("Database error while validating user")),
+    }
+}
+
+pub fn unique_email(email: &String, context: &RegisterContext) -> Result<(), ValidationError> {
+    let mut conn = context.pool.get_conn();
+
+    match count_users_with_email(&mut conn, email)
+    {
+        Ok(0) => Ok(()),
+        Ok(_) => Err(ValidationError::new("email already exists")),
+        Err(_) => Err(ValidationError::new("Database error while validating email"))
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Validate)]
+#[validate(context = RegisterContext::<'v_a>)]
+pub struct ValidatableRegistration {
+    #[validate(
+        length(min = 1),
+        custom(function = "unique_username", use_context)
+    )]
+    pub username: String,
+    #[validate(
+        email,
+        custom(function = "unique_email", use_context)
+    )]
+    pub email: String,
+    #[validate(length(min = 10), must_match(other = "password_repeat", ))]
+    pub password: String,
+    pub password_repeat: String,
+}
+
+impl From<Registration> for ValidatableRegistration {
+    fn from(value: Registration) -> Self {
+        Self {
+            username: value.username,
+            email: value.email,
+            password: value.password,
+            password_repeat: value.password_repeat
+        }
+    }
+}
+
+#[get("/token")]
+pub async fn login(pool: web::Data<DbPool>, login_data: web::Json<Login>) -> Result<impl Responder, ApiError> {
+    let data = login_data.into_inner();
+
+    if let Ok(Some(user)) = web::block(move || {
+        let mut conn = pool.get_conn();
+        gamenight_database::login(&mut conn, data.into())
+    })
+    .await?
+    {
+        let token = get_token(&user)?;
+        let response = Token{ jwt_token: Some(token) };
+        Ok(HttpResponse::Ok()
+            .content_type(ContentType::json())
+            .body(serde_json::to_string(&response)?)
+        )
+    }
+    else {
+        Err(ApiError{status: 401, message: "User doesn't exist or password doesn't match".to_string()})
+    }
+}
+
+#[post("/user")]
+pub async fn register(pool: web::Data<DbPool>, register_data: web::Json<Registration>) -> Result<impl Responder, ApiError> {
+    web::block(move || -> Result<(), ApiError> {
+        let validatable_registration: ValidatableRegistration = register_data.clone().into();
+        validatable_registration.validate_with_args(&RegisterContext{pool: &pool})?;
+        let register_request = register_data.into_inner().into();
+        let mut conn = pool.get_conn();
+        gamenight_database::register(&mut conn, register_request)?;
+        Ok(())
+    }).await??;
+
+    Ok(HttpResponse::Ok())
+}
+
+#[derive(Deserialize)]
+struct UserInfo {
+    pub uuid: String
+}
+
+impl From<gamenight_database::user::User> for User {
+    fn from(value: gamenight_database::user::User) -> Self {
+        Self {
+            id: Some(value.id.to_string()),
+            username: value.username,
+            email: None,
+
+        }
+    }
+}
+
+#[get("/user/{user_id}")]
+pub async fn get_user(pool: web::Data<DbPool>, _user: AuthUser, path: web::Path<UserInfo>) -> Result<impl Responder, ApiError> {
+    let mut conn = pool.get_conn();
+    
+    let user = gamenight_database::user::get_user(&mut conn, Uuid::parse_str(&path.uuid)?)?;
+    Ok(HttpResponse::Ok()
+            .content_type(ContentType::json())
+            .body(serde_json::to_string(&user)?))
+}
+
+#[get("/user/{user_id}")]
+pub async fn get_user_unauthenticated(_path: web::Path<UserInfo>) -> Result<impl Responder, ApiError> {
+    Ok(HttpResponse::Forbidden())
+}
+
+
+

docker-compose.yml

@@ -0,0 +1,18 @@
+services:
+  db:
+    container_name: pg_container
+    image: postgres
+    environment:
+      POSTGRES_USER: root
+      POSTGRES_PASSWORD: root
+      POSTGRES_DB: gamenight
+    ports:
+      - "5432:5432"
+  pgadmin:
+    container_name: pgadmin4_container
+    image: dpage/pgadmin4
+    environment:
+      PGADMIN_DEFAULT_EMAIL: admin@admin.com
+      PGADMIN_DEFAULT_PASSWORD: root
+    ports:
+      - "5050:80"

gamenight-api-client-rs/.gitignore

@@ -0,0 +1,9 @@
+/target/
+git_push.sh
+**/*.rs.bk
+Cargo.lock
+docs
+src
+.travis.yml
+.openapi-generator
+.openapi-generator-ignore

gamenight-api-client-rs/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "gamenight-api-client-rs"
+version = "0.1.0"
+authors = ["dennis@brentj.es"]
+description = "Api specifaction for a Gamenight server"
+license = "MIT"
+edition = "2021"
+
+[dependencies]
+serde = { version = "^1.0", features = ["derive"] }
+serde_json = "^1.0"
+serde_repr = "^0.1"
+url = "^2.5"
+reqwest = { version = "^0.12", default-features = false, features = ["json", "multipart"] }

gamenight-api-client-rs/README.md

@@ -0,0 +1,60 @@
+# Rust API client for gamenight-api-client-rs
+
+Api specifaction for a Gamenight server
+
+For more information, please visit [https://brentj.es](https://brentj.es)
+
+## Overview
+
+This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project.  By using the [openapi-spec](https://openapis.org) from a remote server, you can easily generate an API client.
+
+- API version: 1.0
+- Package version: 0.1.0
+- Generator version: 7.13.0
+- Build package: `org.openapitools.codegen.languages.RustClientCodegen`
+
+## Installation
+
+Put the package under your project folder in a directory named `gamenight-api-client-rs` and add the following to `Cargo.toml` under `[dependencies]`:
+
+```
+gamenight-api-client-rs = { path = "./gamenight-api-client-rs" }
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *http://localhost:8080*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*DefaultApi* | [**get_gamenight**](docs/DefaultApi.md#get_gamenight) | **GET** /gamenight | 
+*DefaultApi* | [**get_gamenights**](docs/DefaultApi.md#get_gamenights) | **GET** /gamenights | Your GET endpoint
+*DefaultApi* | [**get_token**](docs/DefaultApi.md#get_token) | **GET** /token | 
+*DefaultApi* | [**post_gamenight**](docs/DefaultApi.md#post_gamenight) | **POST** /gamenight | 
+*DefaultApi* | [**post_register**](docs/DefaultApi.md#post_register) | **POST** /user | 
+*DefaultApi* | [**user_get**](docs/DefaultApi.md#user_get) | **GET** /user | 
+
+
+## Documentation For Models
+
+ - [AddGamenightRequestBody](docs/AddGamenightRequestBody.md)
+ - [Failure](docs/Failure.md)
+ - [Gamenight](docs/Gamenight.md)
+ - [GetGamenightRequest](docs/GetGamenightRequest.md)
+ - [GetToken401Response](docs/GetToken401Response.md)
+ - [Login](docs/Login.md)
+ - [Registration](docs/Registration.md)
+ - [Token](docs/Token.md)
+ - [User](docs/User.md)
+
+
+To get access to the crate's generated documentation, use:
+
+```
+cargo doc --open
+```
+
+## Author
+
+dennis@brentj.es
+

gamenight-api-client-rs/build.rs

@@ -0,0 +1,9 @@
+use std::process::Command;
+
+fn main() {
+    let _ = 
+        Command::new("openapi-generator")
+            .args(["generate", "-i", "../backend-actix/gamenight-api.yaml", "-g", "rust", "--additional-properties=withSeparateModelsAndApi=true,modelPackage=gamenight_model,apiPackage=gamenight_api,packageName=gamenight-api-client-rs,packageVersion=0.1.0"])
+            .output()
+            .expect("Failed to generate models sources for the gamenight API");
+}

gamenight-api-client-rs/git_push.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-petstore-perl "minor update" "gitlab.com"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+git_host=$4
+
+if [ "$git_host" = "" ]; then
+    git_host="github.com"
+    echo "[INFO] No command line input provided. Set \$git_host to $git_host"
+fi
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="GIT_USER_ID"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="GIT_REPO_ID"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="Minor update"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=$(git remote)
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+        git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:"${GIT_TOKEN}"@${git_host}/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'

gamenight-cli/.gitignore

@@ -0,0 +1 @@
+target

gamenight-cli/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "gamenight-cli"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+gamenight-api-client-rs = { path = "../gamenight-api-client-rs" }
+tokio = { version = "1", features = ["full"] }
+inquire = { version = "0.7.5", features = ["date"] }
+async-trait = "0.1"
+dyn-clone = "1.0"
+chrono = "0.4"

gamenight-cli/src/domain/gamenight.rs

@@ -0,0 +1,27 @@
+use std::fmt::Display;
+
+use chrono::{DateTime, Local};
+use gamenight_api_client_rs::models;
+
+#[derive(Clone)]
+pub struct Gamenight {
+    pub name: String,
+    pub start_time: DateTime<Local>
+}
+
+impl From<models::Gamenight> for Gamenight {
+    fn from(value: models::Gamenight) -> Self {
+        Self {
+            name: value.name,
+            start_time: DateTime::parse_from_rfc3339(&value.datetime).unwrap().into()
+        }
+    }
+}
+impl Display for Gamenight {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, r#"
+Name: {}
+When: {}
+"#, self.name, self.start_time.format("%d-%m-%Y %H:%M"))
+    }
+}

gamenight-cli/src/domain/mod.rs

@@ -0,0 +1 @@
+pub mod gamenight;

gamenight-cli/src/flows/add_gamenight.rs

@@ -0,0 +1,49 @@
+
+use gamenight_api_client_rs::{apis::default_api::post_gamenight, models};
+use inquire::{CustomType, DateSelect, Text};
+use chrono::{self, Local, NaiveTime};
+
+use super::*;
+
+#[derive(Clone)]
+pub struct AddGamenight {
+
+}
+
+impl AddGamenight {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for AddGamenight {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        let mut add_gamenight = models::AddGamenightRequestBody::new();
+
+        add_gamenight.name = Some(Text::new("What should we call your gamenight")
+            .prompt()?);
+        let naive_date = DateSelect::new("When is your gamenight")
+            .prompt()?;
+        let naive_time = CustomType::<NaiveTime>::new("At What time")
+            .prompt()?;
+        add_gamenight.datetime = Some(naive_date
+            .and_time(naive_time)
+            .and_local_timezone(Local)
+            .earliest()
+            .unwrap()
+            .to_utc()
+            .to_rfc3339());
+
+        post_gamenight(&state.configuration, Some(add_gamenight)).await?;
+        
+        Ok((FlowOutcome::Successful, state))
+    }
+}
+
+impl Display for AddGamenight {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Add Gamenight.")
+    }
+}
+

gamenight-cli/src/flows/exit.rs

@@ -0,0 +1,25 @@
+use super::*;
+
+#[derive(Clone)]
+pub struct Exit {
+
+}
+
+impl Exit {
+    pub fn new() -> Self {
+        Self{}
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for Exit {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        Ok((FlowOutcome::Abort, state))
+    }
+}
+
+impl Display for Exit {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Exit")
+    }
+}

gamenight-cli/src/flows/list_gamenights.rs

@@ -0,0 +1,42 @@
+
+use gamenight_api_client_rs::apis::default_api::get_gamenights;
+use inquire::Select;
+
+use crate::flows::view_gamenight::ViewGamenight;
+
+use super::{exit::Exit, *};
+
+#[derive(Clone)]
+pub struct ListGamenights {
+
+}
+
+impl ListGamenights {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for ListGamenights {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        let response = get_gamenights(&state.configuration).await?;
+
+        let mut view_flows = response.into_iter().map(|gamenight| -> Box<dyn Flow<'a> + Send> { 
+            Box::new(ViewGamenight::new(gamenight.into()))
+        }).collect::<Vec<Box<dyn Flow<'a> + Send>>>();
+        view_flows.push(Box::new(Exit::new()));
+
+        let choice = Select::new("What gamenight would you like to view?", view_flows)
+            .prompt_skippable()?;
+
+        handle_choice_option(&choice, self, state).await
+    }
+}
+
+impl Display for ListGamenights {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "List all gamenights")
+    }
+}
+

gamenight-cli/src/flows/login.rs

@@ -0,0 +1,44 @@
+use async_trait::async_trait;
+use gamenight_api_client_rs::{apis::{configuration::Configuration, default_api::get_token}, models};
+use inquire::{Password, Text};
+
+use super::*;
+
+#[derive(Clone)]
+pub struct Login {
+
+}
+
+impl Login {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for Login {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        let configuration = Configuration::new();
+
+        let username = Text::new("What is your login?").prompt()?;
+        let password = Password::new("what is your password?")
+            .without_confirmation()
+            .prompt()?;
+   
+        let login = models::Login::new(username, password);
+   
+        let result = get_token(&configuration, Some(login)).await?;
+        if let Some(token) = result.jwt_token {
+            state.configuration.bearer_access_token = Some(token);
+            Ok((FlowOutcome::Successful, state))
+        } else {
+            Err(FlowError{error: "Unexpected response".to_string()})
+        }
+    }
+}
+
+impl Display for Login {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Login")
+    }
+}

gamenight-cli/src/flows/main.rs

@@ -0,0 +1,42 @@
+
+use super::{exit::Exit, add_gamenight::AddGamenight, list_gamenights::ListGamenights, login::Login, main_menu::MainMenu, *};
+
+#[derive(Clone)]
+pub struct Main {
+    login: Box<dyn for<'a> Flow<'a>>,
+    main_menu: MainMenu
+}
+
+impl Main {
+    pub fn new() -> Self {
+        let mut main_menu = MainMenu::new();
+        main_menu.menu.push(Box::new(ListGamenights::new()));
+        main_menu.menu.push(Box::new(AddGamenight::new()));
+        main_menu.menu.push(Box::new(Exit::new()));
+        Self {
+            login: Box::new(Login::new()),
+            main_menu
+        }
+    }
+}
+
+impl Default for Main {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for Main {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        let (_outcome, state) = self.login.run(state).await?;
+        let (_outcome, state) = self.main_menu.run(state).await?;
+        Ok((FlowOutcome::Successful, state))
+    }
+}
+
+impl Display for Main {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "main")
+    }
+}

gamenight-cli/src/flows/main_menu.rs

@@ -0,0 +1,42 @@
+
+use inquire::{ui::RenderConfig, Select};
+
+use super::*;
+
+#[derive(Clone)]
+pub struct MainMenu {
+    pub menu: Vec<Box<dyn for<'a> Flow<'a> + Send>>
+}
+
+impl MainMenu {
+    pub fn new() -> Self {
+        MainMenu { 
+            menu: vec![]
+        }
+    }
+}
+
+unsafe impl Send for MainMenu {
+
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for MainMenu {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        let choice = Select::new("What would you like to do?", self.menu.clone())
+            .with_help_message("Select the action you want to take or quit the program")
+            .with_render_config(RenderConfig {
+                option_index_prefix: inquire::ui::IndexPrefix::Simple,
+                ..Default::default()
+            })
+            .prompt_skippable()?;
+
+            handle_choice_option(&choice, self, state).await
+    }
+}
+
+impl Display for MainMenu {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Main menu")
+    }
+}

gamenight-cli/src/flows/mod.rs

@@ -0,0 +1,99 @@
+use std::fmt::Display;
+
+use async_trait::async_trait;
+use chrono::ParseError;
+use gamenight_api_client_rs::apis::configuration::Configuration;
+use inquire::InquireError;
+use dyn_clone::DynClone;
+
+pub mod main;
+mod login;
+mod main_menu;
+mod exit;
+mod list_gamenights;
+mod add_gamenight;
+mod view_gamenight;
+
+pub struct GamenightState {
+    configuration: Configuration,
+}
+
+impl GamenightState {
+    pub fn new() -> Self{
+        Self {
+            configuration: Configuration::new()
+        }
+    }
+}
+
+impl Default for GamenightState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug)]
+pub struct FlowError {
+    pub error: String
+}
+
+impl From<InquireError> for FlowError {
+    fn from(value: InquireError) -> Self {
+        Self {
+            error: value.to_string()
+        }
+    }
+}
+
+impl<T> From<gamenight_api_client_rs::apis::Error<T>> for FlowError {
+    fn from(value: gamenight_api_client_rs::apis::Error<T>) -> Self {
+        Self {
+            error: value.to_string()
+        }
+    }
+}
+
+impl From<ParseError> for FlowError {
+    fn from(value: ParseError) -> Self {
+        Self {
+            error: value.to_string()
+        }
+    }
+}
+
+#[derive(PartialEq)]
+pub enum FlowOutcome {
+    Successful,
+    Bool(bool),
+    String(String),
+    Abort
+}
+
+type FlowResult<'a> = Result<(FlowOutcome, &'a mut GamenightState), FlowError>;
+
+dyn_clone::clone_trait_object!(for<'a> Flow<'a>);
+
+#[async_trait]
+pub trait Flow<'a>: Sync + DynClone + Send + Display {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a>;
+}
+
+async fn handle_choice<'a>(choice: &Box<dyn Flow<'a> + Send>, flow: &dyn Flow<'a>, state: &'a mut GamenightState) -> FlowResult<'a> {
+    let (outcome, new_state) = choice.run(state).await?;
+        
+    if outcome == FlowOutcome::Abort {
+        Ok((FlowOutcome::Successful, new_state))
+    }
+    else {
+        flow.run(new_state).await
+    }       
+}
+
+async fn handle_choice_option<'a>(choice: &Option<Box<dyn Flow<'a> + Send>>, flow: &dyn Flow<'a>, state: &'a mut GamenightState) -> FlowResult<'a> {
+    if let Some(choice) = choice {
+        handle_choice(choice, flow, state).await
+    }
+    else {
+        Ok((FlowOutcome::Abort, state))
+    }
+}

gamenight-cli/src/flows/view_gamenight.rs

@@ -0,0 +1,41 @@
+
+use inquire::Select;
+
+use crate::{domain::gamenight::Gamenight, flows::exit::Exit};
+
+use super::*;
+
+#[derive(Clone)]
+pub struct ViewGamenight {
+    gamenight: Gamenight
+}
+
+impl ViewGamenight {
+    pub fn new(gamenight: Gamenight) -> Self {
+        Self {
+            gamenight
+        }
+    }
+}
+
+#[async_trait]
+impl<'a> Flow<'a> for ViewGamenight {
+    async fn run(&self, state: &'a mut GamenightState) -> FlowResult<'a> {
+        
+        print!("{}", self.gamenight);
+        let options: Vec<Box<dyn Flow<'a> + Send>> = vec![
+            Box::new(Exit::new())
+        ];
+        let choice = Select::new("What do you want to do:", options)
+            .prompt_skippable()?;
+
+        handle_choice_option(&choice, self, state).await
+    }
+}
+
+impl Display for ViewGamenight {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} {}", self.gamenight.name, self.gamenight.start_time.format("%d-%m-%Y %H:%M"))
+    }
+}
+

gamenight-cli/src/main.rs

@@ -0,0 +1,15 @@
+pub mod flows;
+pub mod domain;
+
+use flows::{main::Main, Flow, GamenightState};
+
+#[tokio::main]
+async fn main() {
+    let mut state = GamenightState::new();
+    let mainflow = Main::new();
+    if let Err(x) = mainflow.run(&mut state).await {
+        println!("{}", x.error);
+    }
+}
+    
+

gamenight-database/.gitignore

@@ -0,0 +1 @@
+target

gamenight-database/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "gamenight-database"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+diesel = { version = "2.0", features = ["postgres", "r2d2", "uuid", "chrono"] }
+diesel-derive-enum = { version = "2.0", features = ["postgres"] }
+diesel_migrations = "2.0"
+argon2 = { version = "0.5", features = ["std"] }
+uuid = { version = "1.17.0", features = ["serde", "v4"] }
+serde = { version = "1.0", features = ["derive"] }
+chrono = { version = "0.4", features = ["serde"] }
+rand_core = "0.9"
+

gamenight-database/diesel.toml

@@ -0,0 +1,2 @@
+[print_schema]
+file = "src/schema/schema.rs"

gamenight-database/migrations/2022-03-19-191822_initial/up.sql

@@ -0,0 +1,12 @@
+-- Your SQL goes here
+
+CREATE TABLE gamenight (
+    id UUID NOT NULL PRIMARY KEY,
+    name VARCHAR NOT NULL,
+    datetime VARCHAR NOT NULL
+);
+
+CREATE TABLE known_games (
+    id UUID NOT NULL PRIMARY KEY,
+    name VARCHAR UNIQUE NOT NULL
+);

gamenight-database/migrations/2022-04-17-175115_user-system/down.sql

@@ -0,0 +1,6 @@
+-- This file should undo anything in `up.sql`
+
+drop table pwd;
+drop table users;
+
+drop type Role;

gamenight-database/migrations/2022-04-17-175115_user-system/up.sql

@@ -0,0 +1,28 @@
+CREATE TYPE Role AS ENUM ('user', 'admin');
+
+CREATE TABLE users (
+    id UUID NOT NULL PRIMARY KEY,
+    username VARCHAR UNIQUE NOT NULL,
+    email VARCHAR UNIQUE NOT NULL,
+    role Role NOT NULL
+);
+
+CREATE TABLE pwd (
+    user_id UUID NOT NULL PRIMARY KEY,
+    password VARCHAR NOT NULL,
+    CONSTRAINT FK_UserId FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+--Initialize default admin user, with password "gamenight!"
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+DO $$
+DECLARE 
+    admin_uuid uuid = uuid_generate_v4();
+BEGIN
+    INSERT INTO users (id, username, email, role)
+    values(admin_uuid, 'admin', '', 'admin');
+
+    insert INTO pwd (user_id, password)
+    values(admin_uuid, '$argon2id$v=19$m=4096,t=3,p=1$zEdUjCAnZqd8DziYWzlFHw$YBLQhKvYIZBY43B8zM6hyBvLKuqTeh0EM5pKOfbWQSI');
+END $$;
+

gamenight-database/migrations/2022-05-14-104118_gamenight_owners/down.sql

@@ -0,0 +1,4 @@
+-- This file should undo anything in `up.sql`
+
+ALTER TABLE gamenight
+DROP COLUMN owner_id;

gamenight-database/migrations/2022-05-14-104118_gamenight_owners/up.sql

@@ -0,0 +1,19 @@
+ALTER TABLE gamenight RENAME TO _gamenight_old;
+
+CREATE TABLE gamenight (
+    id UUID NOT NULL PRIMARY KEY,
+    name VARCHAR NOT NULL,
+    datetime VARCHAR NOT NULL,
+    owner_id UUID NOT NULL,
+    CONSTRAINT FK_OwnerId FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+SET session_replication_role = 'replica';
+
+INSERT INTO gamenight (id, name, datetime, owner_id)
+select id, name, datetime, '00000000-0000-0000-0000-000000000000'
+FROM _gamenight_old;
+
+drop table _gamenight_old;
+
+SET session_replication_role = 'origin';

gamenight-database/migrations/2022-05-27-183310_gamenight_gamelist/down.sql

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+
+drop table gamenight_gamelist;

gamenight-database/migrations/2022-05-27-183310_gamenight_gamelist/up.sql

@@ -0,0 +1,9 @@
+-- Your SQL goes here
+
+create table gamenight_gamelist (
+    gamenight_id UUID NOT NULL,
+    game_id UUID NOT NULL,
+    CONSTRAINT FK_gamenight_id FOREIGN KEY (gamenight_id) REFERENCES gamenight(id) ON DELETE CASCADE,
+    CONSTRAINT FK_game_id FOREIGN KEY (game_id) REFERENCES known_games(id) ON DELETE CASCADE,
+    PRIMARY KEY(gamenight_id, game_id)
+);

gamenight-database/migrations/2022-05-28-142526_gamenight participant/down.sql

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+
+drop table gamenight_participant;

gamenight-database/migrations/2022-05-28-142526_gamenight participant/up.sql

@@ -0,0 +1,9 @@
+-- Your SQL goes here
+
+create table gamenight_participant (
+    gamenight_id UUID NOT NULL,
+    user_id UUID NOT NULL,
+    CONSTRAINT FK_gamenight_id FOREIGN KEY (gamenight_id) REFERENCES gamenight(id) ON DELETE CASCADE,
+    CONSTRAINT FK_user_id FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    PRIMARY KEY(gamenight_id, user_id)
+)

gamenight-database/migrations/2022-06-04-141858_registration_tokens/down.sql

@@ -0,0 +1,6 @@
+-- This file should undo anything in `up.sql`
+
+drop table registration_tokens;
+
+ALTER TABLE gamenight
+ALTER datetime TYPE VARCHAR;

gamenight-database/migrations/2022-06-04-141858_registration_tokens/up.sql

@@ -0,0 +1,11 @@
+-- Your SQL goes here
+
+create table registration_tokens (
+    id UUID PRIMARY KEY,
+    token CHARACTER(32) NOT NULL,
+    single_use BOOLEAN NOT NULL,
+    expires TIMESTAMPTZ
+);
+
+ALTER TABLE gamenight
+ALTER datetime TYPE TIMESTAMPTZ using datetime::timestamp;

gamenight-database/src/error.rs

@@ -0,0 +1,13 @@
+pub struct DatabaseError(pub String);
+
+impl From<diesel::result::Error> for DatabaseError {
+    fn from(value: diesel::result::Error) -> Self {
+        DatabaseError(value.to_string())
+    }
+}
+
+impl From<argon2::password_hash::Error> for DatabaseError {
+    fn from(value: argon2::password_hash::Error) -> Self {
+        DatabaseError(value.to_string())
+    }
+}

gamenight-database/src/gamenight.rs

@@ -0,0 +1,28 @@
+use chrono::{DateTime, Utc};
+use diesel::{Insertable, Queryable, PgConnection, RunQueryDsl, insert_into, QueryDsl};
+use serde::{Serialize, Deserialize};
+use uuid::Uuid;
+use crate::schema::gamenight;
+
+use super::error::DatabaseError;
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(table_name = gamenight)]
+pub struct Gamenight {
+    pub id: Uuid,
+    pub name: String,
+    pub datetime: DateTime<Utc>,
+    pub owner_id: Uuid,
+}
+
+pub fn gamenights(conn: &mut PgConnection) -> Result<Vec::<Gamenight>, DatabaseError> {
+    Ok(gamenight::table.load::<Gamenight>(conn)?)
+}
+
+pub fn add_gamenight(conn: &mut PgConnection, gamenight: Gamenight) -> Result<usize, DatabaseError> {
+    Ok(insert_into(gamenight::table).values(&gamenight).execute(conn)?)
+}
+
+pub fn get_gamenight(conn: &mut PgConnection, id: Uuid) -> Result<Gamenight, DatabaseError> {
+    Ok(gamenight::table.find(id).first(conn)?)
+}

gamenight-database/src/gamenight_participants.rs

@@ -0,0 +1,24 @@
+use diesel::{ExpressionMethods, Insertable, QueryDsl, Queryable, RunQueryDsl};
+use serde::{Serialize, Deserialize};
+use uuid::Uuid;
+
+use crate::schema::gamenight_participant;
+
+use super::error::DatabaseError;
+use super::DbConnection;
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(belongs_to(Gamenight))]
+#[diesel(belongs_to(User))]
+#[diesel(table_name = gamenight_participant)]
+pub struct GamenightParticipant {
+    pub gamenight_id: Uuid,
+    pub user_id: Uuid,
+}
+
+pub fn get_participants(conn: &mut DbConnection, id: &Uuid) -> Result<Vec<Uuid>, DatabaseError> {
+    Ok(gamenight_participant::table
+        .filter(gamenight_participant::gamenight_id.eq(&id))
+        .select(gamenight_participant::user_id)
+        .get_results(conn)?)
+}

gamenight-database/src/lib.rs

@@ -0,0 +1,46 @@
+pub mod user;
+pub mod error;
+pub mod schema;
+pub mod gamenight;
+pub mod gamenight_participants;
+
+use diesel::r2d2::ConnectionManager;
+use diesel::r2d2::ManageConnection;
+use diesel::r2d2::Pool;
+use diesel::r2d2::PooledConnection;
+use diesel::PgConnection;
+use diesel_migrations::embed_migrations;
+use diesel_migrations::EmbeddedMigrations;
+
+use diesel_migrations::MigrationHarness;
+pub use user::login;
+pub use user::register;
+pub use gamenight::gamenights;
+pub use gamenight_participants::get_participants;
+
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!();
+pub type DbConnection = PgConnection;
+pub type DbPool = Pool<ConnectionManager<DbConnection>>;
+
+pub fn run_migration(conn: &mut DbConnection) {
+    conn.run_pending_migrations(MIGRATIONS).unwrap();
+}
+
+pub fn get_connection_pool(url: &str) -> DbPool {
+    let manager = ConnectionManager::<PgConnection>::new(url);
+    // Refer to the `r2d2` documentation for more methods to use
+    // when building a connection pool
+    Pool::builder()
+        .test_on_check_out(true)
+        .build(manager)
+        .expect("Could not build connection pool")
+}
+pub trait GetConnection<T> where T: ManageConnection {
+    fn get_conn(&self) -> PooledConnection<T>;
+}
+
+impl<T: ManageConnection> GetConnection<T> for Pool<T> {
+    fn get_conn(&self) -> PooledConnection<T> {
+        self.get().expect("Couldn't get db connection from pool")
+    }
+}

gamenight-database/src/schema.rs

@@ -0,0 +1,83 @@
+// @generated automatically by Diesel CLI.
+
+pub mod sql_types {
+    #[derive(diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "role"))]
+    pub struct Role;
+}
+
+diesel::table! {
+    gamenight (id) {
+        id -> Uuid,
+        name -> Varchar,
+        datetime -> Timestamptz,
+        owner_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    gamenight_gamelist (gamenight_id, game_id) {
+        gamenight_id -> Uuid,
+        game_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    gamenight_participant (gamenight_id, user_id) {
+        gamenight_id -> Uuid,
+        user_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    known_games (id) {
+        id -> Uuid,
+        name -> Varchar,
+    }
+}
+
+diesel::table! {
+    pwd (user_id) {
+        user_id -> Uuid,
+        password -> Varchar,
+    }
+}
+
+diesel::table! {
+    registration_tokens (id) {
+        id -> Uuid,
+        #[max_length = 32]
+        token -> Bpchar,
+        single_use -> Bool,
+        expires -> Nullable<Timestamptz>,
+    }
+}
+
+diesel::table! {
+    use diesel::sql_types::*;
+    use super::sql_types::Role;
+
+    users (id) {
+        id -> Uuid,
+        username -> Varchar,
+        email -> Varchar,
+        role -> Role,
+    }
+}
+
+diesel::joinable!(gamenight -> users (owner_id));
+diesel::joinable!(gamenight_gamelist -> gamenight (gamenight_id));
+diesel::joinable!(gamenight_gamelist -> known_games (game_id));
+diesel::joinable!(gamenight_participant -> gamenight (gamenight_id));
+diesel::joinable!(gamenight_participant -> users (user_id));
+diesel::joinable!(pwd -> users (user_id));
+
+diesel::allow_tables_to_appear_in_same_query!(
+    gamenight,
+    gamenight_gamelist,
+    gamenight_participant,
+    known_games,
+    pwd,
+    registration_tokens,
+    users,
+);

gamenight-database/src/schema/schema.rs

@@ -0,0 +1,83 @@
+// @generated automatically by Diesel CLI.
+
+pub mod sql_types {
+    #[derive(diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "role"))]
+    pub struct Role;
+}
+
+diesel::table! {
+    gamenight (id) {
+        id -> Uuid,
+        name -> Varchar,
+        datetime -> Timestamptz,
+        owner_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    gamenight_gamelist (gamenight_id, game_id) {
+        gamenight_id -> Uuid,
+        game_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    gamenight_participant (gamenight_id, user_id) {
+        gamenight_id -> Uuid,
+        user_id -> Uuid,
+    }
+}
+
+diesel::table! {
+    known_games (id) {
+        id -> Uuid,
+        name -> Varchar,
+    }
+}
+
+diesel::table! {
+    pwd (user_id) {
+        user_id -> Uuid,
+        password -> Varchar,
+    }
+}
+
+diesel::table! {
+    registration_tokens (id) {
+        id -> Uuid,
+        #[max_length = 32]
+        token -> Bpchar,
+        single_use -> Bool,
+        expires -> Nullable<Timestamptz>,
+    }
+}
+
+diesel::table! {
+    use diesel::sql_types::*;
+    use super::sql_types::Role;
+
+    users (id) {
+        id -> Uuid,
+        username -> Varchar,
+        email -> Varchar,
+        role -> Role,
+    }
+}
+
+diesel::joinable!(gamenight -> users (owner_id));
+diesel::joinable!(gamenight_gamelist -> gamenight (gamenight_id));
+diesel::joinable!(gamenight_gamelist -> known_games (game_id));
+diesel::joinable!(gamenight_participant -> gamenight (gamenight_id));
+diesel::joinable!(gamenight_participant -> users (user_id));
+diesel::joinable!(pwd -> users (user_id));
+
+diesel::allow_tables_to_appear_in_same_query!(
+    gamenight,
+    gamenight_gamelist,
+    gamenight_participant,
+    known_games,
+    pwd,
+    registration_tokens,
+    users,
+);

gamenight-database/src/user.rs

@@ -0,0 +1,140 @@
+use argon2::password_hash::Salt;
+use diesel::Connection;
+use serde::{Serialize, Deserialize};
+use uuid::Uuid;
+use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, Insertable, Queryable};
+use diesel_derive_enum::DbEnum;
+use argon2::password_hash::SaltString;
+use argon2::PasswordHash;
+use argon2::PasswordVerifier;
+use argon2::Argon2;
+use argon2::password_hash::PasswordHasher;
+use argon2::password_hash::rand_core::OsRng;
+use argon2::password_hash::rand_core::RngCore;
+use crate::DbConnection;
+
+use super::schema::{pwd, users};
+pub use super::error::DatabaseError;
+
+
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(table_name = pwd)]
+struct Pwd {
+    user_id: Uuid,
+    password: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Insertable, Queryable)]
+#[diesel(table_name = users)]
+pub struct User {
+    pub id: Uuid,
+    pub username: String,
+    pub email: String,
+    pub role: Role,
+}
+
+#[derive(DbEnum, Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
+#[ExistingTypePath = "crate::schema::sql_types::Role"]
+pub enum Role {
+    Admin,
+    User
+}
+
+pub struct LoginUser {
+    pub username: String,
+    pub password: String
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct LoginResult {
+    pub result: bool,
+    pub user: Option<User>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct RegisterResult {
+    pub result: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Register {
+    pub username: String,
+    pub email: String,
+    pub password: String
+}
+
+pub fn login(conn: &mut DbConnection, user: LoginUser) -> Result<Option<User>, DatabaseError> {
+    let id: Uuid = users::table
+        .filter(users::username.eq(&user.username))
+        .or_filter(users::email.eq(&user.username))
+        .select(users::id)
+        .first(conn)?;
+
+    let pwd: String = pwd::table
+        .filter(pwd::user_id.eq(id))
+        .select(pwd::password)
+        .first(conn)?;
+
+    let parsed_hash = PasswordHash::new(&pwd)?;
+
+    if Argon2::default()
+        .verify_password(user.password.as_bytes(), &parsed_hash)
+        .is_ok()
+    {
+        Ok(Some(users::table.find(id).first(conn)?))
+    } else {
+        Ok(None)
+    } 
+}
+
+pub fn get_user(conn: &mut DbConnection, id: Uuid) -> Result<User, DatabaseError> {
+    Ok(users::table.find(id).first(conn)?)
+}
+
+pub fn register(conn: &mut DbConnection, register: Register) -> Result<(), DatabaseError> {
+    let mut bytes = [0u8; Salt::RECOMMENDED_LENGTH];
+    OsRng.try_fill_bytes(&mut bytes).unwrap();
+    let salt = SaltString::encode_b64(&bytes).unwrap();
+    let argon2 = Argon2::default();
+
+    let password_hash = argon2
+        .hash_password(register.password.as_bytes(), &salt)?
+        .to_string();
+
+    conn.transaction(|c| {
+        let id = Uuid::new_v4();
+
+        diesel::insert_into(users::table)
+            .values(User {
+                id,
+                username: register.username,
+                email: register.email,
+                role: Role::User,
+            })
+            .execute(c)?;
+
+        diesel::insert_into(pwd::table)
+            .values(Pwd {
+                user_id: id,
+                password: password_hash,
+            })
+            .execute(c)?;
+
+        Ok(())
+    })
+}
+
+pub fn count_users_with_username(conn: &mut DbConnection, username: &String) -> Result<i64, DatabaseError> {
+    Ok(users::table
+        .count()
+        .filter(users::username.eq(username))
+        .get_result::<i64>(conn)?)
+}
+
+pub fn count_users_with_email(conn: &mut DbConnection, email: &String) -> Result<i64, DatabaseError> {
+    Ok(users::table
+        .count()
+        .filter(users::email.eq(email))
+        .get_result::<i64>(conn)?)
+}

migrations/2022-03-19-191822_initial/up.sql

@@ -1,12 +0,0 @@
--- Your SQL goes here
-
-CREATE TABLE gamenight (
-    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    game text TEXT NOT NULL,
-    datetime TEXT NOT NULL
-);
-
-CREATE TABLE known_games (
-    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    game TEXT UNIQUE NOT NULL
-);

src/api.rs

@@ -1,58 +0,0 @@
-use crate::schema;
-use rocket::form::Form;
-use rocket::serde::json::{Json, json, Value};
-use rocket::http::Status;
-use rocket::request::{self, Request, FromRequest};
-use rocket::outcome::Outcome::{Success, Failure};
-use rocket::response::{Redirect, Flash};
-
-pub struct Referer(String);
-
-#[derive(Debug)]
-pub enum ReferrerError {
-    Missing,
-    MoreThanOne
-}
-
-#[derive(Debug, Responder)]
-pub enum ApiResponse {
-    Status(Status),
-    Redirect(Redirect),
-    Value(Value),
-    Flash(Flash<Redirect>)
-}
-
-#[rocket::async_trait]
-impl<'r> FromRequest<'r> for Referer {
-    type Error = ReferrerError;
-
-    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
-        let referers : Vec<_> = req.headers().get("Referer").collect();
-        match referers.len() {
-            0 => Failure((Status::BadRequest, ReferrerError::Missing)),
-            1 => Success(Referer(referers[0].to_string())),
-            _ => Failure((Status::BadRequest, ReferrerError::MoreThanOne)),
-        }
-    }
-}
-
-#[get("/gamenights")]
-pub async fn gamenights(conn: schema::DbConn) -> ApiResponse {
-    let gamenights = schema::get_all_gamenights(conn).await;
-    ApiResponse::Value(json!(gamenights))
-}
-
-#[post("/gamenight", format = "application/json", data = "<gamenight_json>")]
-pub async fn gamenight_post_json(conn: schema::DbConn, gamenight_json: Json<schema::GameNightNoId>) -> ApiResponse  {
-    schema::insert_gamenight(conn, gamenight_json.into_inner()).await;
-    ApiResponse::Status(Status::Accepted)
-}
-
-#[post("/gamenight", format = "application/x-www-form-urlencoded", data = "<gamenight_form>")]
-pub async fn gamenight_post_form(referer: Option<Referer>, conn: schema::DbConn, gamenight_form: Form<schema::GameNightNoId>) -> ApiResponse {
-    schema::insert_gamenight(conn, gamenight_form.into_inner()).await;
-    match referer {
-        None => ApiResponse::Status(Status::Accepted),
-        Some(referer) => ApiResponse::Flash(Flash::success(Redirect::to(referer.0), "Added Gamenight."))
-    }
-}

src/main.rs

@@ -1,20 +0,0 @@
-#[macro_use] extern crate rocket;
-#[macro_use] extern crate diesel_migrations;
-#[macro_use] extern crate diesel;
-
-use rocket::fairing::AdHoc;
-use rocket_dyn_templates::Template;
-
-mod api;
-pub mod schema;
-mod site;
-
-#[launch]
-fn rocket() -> _ {
-    rocket::build()
-        .attach(schema::DbConn::fairing())
-        .attach(Template::fairing())
-        .attach(AdHoc::on_ignite("Run Migrations", schema::run_migrations))
-        .mount("/", routes![site::index, site::gamenights, site::add_game_night])
-        .mount("/api", routes![api::gamenights, api::gamenight_post_form, api::gamenight_post_json])
-}

src/schema.rs

@@ -1,83 +0,0 @@
-use rocket_sync_db_pools::database;
-use serde::{Serialize, Deserialize};
-use rocket::{Rocket, Build};
-use diesel::RunQueryDsl;
-
-
-#[database("gamenight_database")]
-pub struct DbConn(diesel::SqliteConnection);
-
-table! {
-    gamenight (id) {
-        id -> Integer,
-        game -> Text,
-        datetime -> Text,
-    }
-}
-
-table! {
-    known_games (game) {
-        id -> Integer,
-        game -> Text,
-    }
-}
-
-allow_tables_to_appear_in_same_query!(
-    gamenight,
-    known_games,
-);
-
-pub async fn get_all_gamenights(conn: DbConn) -> Vec::<GameNight> {
-    conn.run(|c| {
-        gamenight::table.load::<GameNight>(c).unwrap()
-    }).await
-}
-
-pub async fn insert_gamenight(conn: DbConn, new_gamenight: GameNightNoId) -> () {
-    conn.run(|c| {
-        diesel::insert_into(gamenight::table)
-            .values(new_gamenight)
-            .execute(c)
-            .unwrap()
-    }).await;
-}
-
-pub async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
-    // This macro from `diesel_migrations` defines an `embedded_migrations`
-    // module containing a function named `run`. This allows the example to be
-    // run and tested without any outside setup of the database.
-    embed_migrations!();
-
-    let conn = DbConn::get_one(&rocket).await.expect("database connection");
-    conn.run(|c| embedded_migrations::run(c)).await.expect("can run migrations");
-
-    rocket
-}
-
-#[derive(Serialize, Deserialize, Debug, FromForm, Insertable)]
-#[table_name="known_games"]
-pub struct GameNoId {
-    pub game : String,
-}
-
-#[derive(Serialize, Deserialize, Debug, FromForm, Queryable)]
-pub struct Game {
-    pub id: i32,
-    pub game : String,
-}
-
-#[derive(Serialize, Deserialize, Debug, FromForm, Insertable)]
-#[table_name="gamenight"]
-pub struct GameNightNoId {
-    pub game : String,
-    pub datetime : String, 
-}
-
-#[derive(Serialize, Deserialize, Debug, FromForm, Queryable)]
-pub struct GameNight {
-    pub id: i32,
-    pub game : String,
-    pub datetime : String, 
-}
-
-

src/site.rs

@@ -1,57 +0,0 @@
-use serde::{Serialize, Deserialize};
-use rocket_dyn_templates::Template;
-use rocket::response::{Redirect};
-use rocket::request::{FlashMessage};
-use crate::schema;
-
-#[derive(Serialize, Deserialize, Debug)]
-struct FlashData {
-    has_data: bool,
-    kind: String,
-    message: String
-
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct GameNightsData {
-    gamenights: Vec::<schema::GameNight>,
-    flash: FlashData
-}
-
-#[get("/gamenights")]
-pub async fn gamenights(conn: schema::DbConn) -> Template {
-    let gamenights = schema::get_all_gamenights(conn).await;
-    
-    let data = GameNightsData {
-        gamenights: gamenights,
-        flash: FlashData { has_data: false, message: "".to_string(), kind: "".to_string() }
-    };
-
-    Template::render("gamenights", &data)
-}
-
-#[get("/")]
-pub async fn index() -> Redirect {
-    Redirect::to(uri!(gamenights))
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct GameNightAddData {
-    post_url: String,
-    flash : FlashData
-}
-
-#[get("/gamenight/add")]
-pub async fn add_game_night(flash: Option<FlashMessage<'_>>) -> Template {
-    let flash_data = match flash {
-        None => FlashData { has_data: false, message: "".to_string(), kind: "".to_string() },
-        Some(flash) => FlashData { has_data: true, message: flash.message().to_string(), kind: flash.kind().to_string() }
-    };
-    
-    let data = GameNightAddData {
-        post_url: "/api/gamenight".to_string(),
-        flash: flash_data
-    };
-
-    Template::render("gamenight_add", &data)
-}

templates/flash.html.hbs

@@ -1,5 +0,0 @@
-    {{#if has_data}}
-    <div>
-      <p>{{kind}}: {{message}}</p>
-    </div>
-    {{/if}}

templates/gamenight_add.html.hbs

@@ -1,16 +0,0 @@
-<html>
-  <head>
-  </head>
-  <body>
-
-    {{> flash flash }}
-
-    <form action="{{post_url}}" method="post">
-      <label for="game">Game:</label><br>
-      <input type="text" id="game" name="game"><br>
-      <label for="datetime">Wanneer:</label><br>
-      <input type="text" id="datetime" name="datetime">
-      <input type="submit" value="Submit">
-    </form>
-  </body>
-</html>

templates/gamenights.html.hbs

@@ -1,14 +0,0 @@
-<html>
-  <head>
-  </head>
-  <body>
-    {{> flash flash }}
-
-    {{#each gamenights}}
-      <div>
-        <span>game: {{this.game}}</span>
-        <span>when: {{this.datetime}}</span>
-      </div>
-    {{/each}}
-  </body>
-</html>