Release Tagging / release (push) Successful in 16s
soaricarus_auth Build / build (push) Successful in 1m5s
soaricarus_auth Build / Rustfmt (push) Successful in 1m10s
soaricarus_auth Build / Check (push) Successful in 1m16s
soaricarus_auth Build / Clippy (push) Successful in 1m19s
soaricarus_auth Build / Test Suite (push) Successful in 1m19s
Closes #14 Reviewed-on: http://git.kundeng.us/phoenix/soaricarus_auth/pulls/15
342 lines
9.2 KiB
Rust
342 lines
9.2 KiB
Rust
pub mod service;
|
|
|
|
pub mod user {
|
|
use sqlx::Row;
|
|
|
|
#[derive(Debug, serde::Serialize, sqlx::FromRow)]
|
|
pub struct InsertedData {
|
|
pub id: uuid::Uuid,
|
|
pub date_created: Option<time::OffsetDateTime>,
|
|
}
|
|
|
|
pub async fn get(
|
|
pool: &sqlx::PgPool,
|
|
username: &String,
|
|
) -> Result<simodels::user::User, sqlx::Error> {
|
|
let result = sqlx::query(
|
|
r#"
|
|
SELECT * FROM "user" WHERE username = $1
|
|
"#,
|
|
)
|
|
.bind(username)
|
|
.fetch_optional(pool)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(r) => match r {
|
|
Some(r) => parse_row(&r).await,
|
|
None => Err(sqlx::Error::RowNotFound),
|
|
},
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
pub async fn get_with_id(
|
|
pool: &sqlx::PgPool,
|
|
id: &uuid::Uuid,
|
|
) -> Result<simodels::user::User, sqlx::Error> {
|
|
let result = sqlx::query(
|
|
r#"
|
|
SELECT * FROM "user" WHERE id = $1
|
|
"#,
|
|
)
|
|
.bind(id)
|
|
.fetch_optional(pool)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(r) => match r {
|
|
Some(roww) => parse_row(&roww).await,
|
|
None => Err(sqlx::Error::RowNotFound),
|
|
},
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
async fn parse_row(row: &sqlx::postgres::PgRow) -> Result<simodels::user::User, sqlx::Error> {
|
|
Ok(simodels::user::User {
|
|
id: row
|
|
.try_get("id")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
username: row
|
|
.try_get("username")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
password: row
|
|
.try_get("password")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
email: row
|
|
.try_get("email")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
phone: row
|
|
.try_get("phone")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
firstname: row
|
|
.try_get("firstname")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
lastname: row
|
|
.try_get("lastname")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
email_verified: row
|
|
.try_get("email_verified")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
date_created: row
|
|
.try_get("date_created")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
status: row
|
|
.try_get("status")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
last_login: row
|
|
.try_get("last_login")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
salt_id: row
|
|
.try_get("salt_id")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)
|
|
.unwrap(),
|
|
})
|
|
}
|
|
|
|
pub async fn update_password(
|
|
pool: &sqlx::PgPool,
|
|
user: &simodels::user::User,
|
|
password: &str,
|
|
) -> Result<bool, sqlx::Error> {
|
|
match sqlx::query(
|
|
r#"
|
|
UPDATE "user" SET password = $1 WHERE id = $2
|
|
"#,
|
|
)
|
|
.bind(password)
|
|
.bind(user.id)
|
|
.execute(pool)
|
|
.await
|
|
{
|
|
Ok(r) => {
|
|
if r.rows_affected() > 0 {
|
|
Ok(true)
|
|
} else {
|
|
Ok(false)
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub async fn update_user_profile(
|
|
pool: &sqlx::PgPool,
|
|
id: &uuid::Uuid,
|
|
firstname: &str,
|
|
lastname: &str,
|
|
) -> Result<bool, sqlx::Error> {
|
|
match sqlx::query(
|
|
r#"
|
|
UPDATE "user" SET firstname = $1, lastname = $2 WHERE id = $3
|
|
"#,
|
|
)
|
|
.bind(firstname)
|
|
.bind(lastname)
|
|
.bind(id)
|
|
.execute(pool)
|
|
.await
|
|
{
|
|
Ok(r) => {
|
|
if r.rows_affected() > 0 {
|
|
Ok(true)
|
|
} else {
|
|
Ok(false)
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub async fn update_last_login(
|
|
pool: &sqlx::PgPool,
|
|
user: &simodels::user::User,
|
|
time: &time::OffsetDateTime,
|
|
) -> Result<time::OffsetDateTime, sqlx::Error> {
|
|
let result = sqlx::query(
|
|
r#"
|
|
UPDATE "user" SET last_login = $1 WHERE id = $2 RETURNING last_login
|
|
"#,
|
|
)
|
|
.bind(time)
|
|
.bind(user.id)
|
|
.fetch_optional(pool)
|
|
.await
|
|
.map_err(|e| {
|
|
eprintln!("Error updating time: {e}");
|
|
e
|
|
});
|
|
|
|
match result {
|
|
Ok(row) => match row {
|
|
Some(r) => {
|
|
let last_login: time::OffsetDateTime = r
|
|
.try_get("last_login")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)?;
|
|
Ok(last_login)
|
|
}
|
|
None => Err(sqlx::Error::RowNotFound),
|
|
},
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub async fn exists(pool: &sqlx::PgPool, username: &String) -> Result<bool, sqlx::Error> {
|
|
let result = sqlx::query(
|
|
r#"
|
|
SELECT 1 FROM "user" WHERE username = $1
|
|
"#,
|
|
)
|
|
.bind(username)
|
|
.fetch_optional(pool)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(r) => Ok(r.is_some()),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
pub async fn insert(
|
|
pool: &sqlx::PgPool,
|
|
user: &simodels::user::User,
|
|
) -> Result<(uuid::Uuid, std::option::Option<time::OffsetDateTime>), sqlx::Error> {
|
|
let row = sqlx::query(
|
|
r#"
|
|
INSERT INTO "user" (username, password, email, phone, firstname, lastname, email_verified, status, salt_id)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
|
|
RETURNING id, date_created;
|
|
"#)
|
|
.bind(&user.username)
|
|
.bind(&user.password)
|
|
.bind(&user.email)
|
|
.bind(&user.phone)
|
|
.bind(&user.firstname)
|
|
.bind(&user.lastname)
|
|
.bind(user.email_verified)
|
|
.bind(&user.status)
|
|
.bind(user.salt_id)
|
|
.fetch_one(pool)
|
|
.await
|
|
.map_err(|e| {
|
|
eprintln!("Error inserting item: {e}");
|
|
e
|
|
})?;
|
|
|
|
let result = InsertedData {
|
|
id: row.try_get("id").map_err(|_e| sqlx::Error::RowNotFound)?,
|
|
date_created: row
|
|
.try_get("date_created")
|
|
.map_err(|_e| sqlx::Error::RowNotFound)?,
|
|
};
|
|
|
|
if result.id.is_nil() && result.date_created.is_none() {
|
|
Err(sqlx::Error::RowNotFound)
|
|
} else {
|
|
Ok((result.id, result.date_created))
|
|
}
|
|
}
|
|
}
|
|
|
|
pub mod salt {
|
|
use sqlx::Row;
|
|
|
|
#[derive(Debug, serde::Serialize, sqlx::FromRow)]
|
|
pub struct InsertedData {
|
|
pub id: uuid::Uuid,
|
|
}
|
|
|
|
pub async fn get(
|
|
pool: &sqlx::PgPool,
|
|
id: &uuid::Uuid,
|
|
) -> Result<simodels::user::salt::Salt, sqlx::Error> {
|
|
let result = sqlx::query(
|
|
r#"
|
|
SELECT * FROM "salt" WHERE id = $1
|
|
"#,
|
|
)
|
|
.bind(id)
|
|
.fetch_optional(pool)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(r) => match r {
|
|
Some(r) => Ok(simodels::user::salt::Salt {
|
|
id: r.try_get("id")?,
|
|
salt: r.try_get("salt")?,
|
|
}),
|
|
None => Err(sqlx::Error::RowNotFound),
|
|
},
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
pub async fn insert(
|
|
pool: &sqlx::PgPool,
|
|
salt: &simodels::user::salt::Salt,
|
|
) -> Result<uuid::Uuid, sqlx::Error> {
|
|
let row = sqlx::query(
|
|
r#"
|
|
INSERT INTO "salt" (salt)
|
|
VALUES ($1)
|
|
RETURNING id;
|
|
"#,
|
|
)
|
|
.bind(&salt.salt)
|
|
.fetch_one(pool)
|
|
.await
|
|
.map_err(|e| {
|
|
eprintln!("Error inserting item: {e}");
|
|
e
|
|
})?;
|
|
|
|
let result = InsertedData {
|
|
id: row.try_get("id").map_err(|_e| sqlx::Error::RowNotFound)?,
|
|
};
|
|
|
|
if !result.id.is_nil() {
|
|
Ok(result.id)
|
|
} else {
|
|
Err(sqlx::Error::RowNotFound)
|
|
}
|
|
}
|
|
|
|
pub async fn update_salt(
|
|
pool: &sqlx::PgPool,
|
|
salt: &simodels::user::salt::Salt,
|
|
updated_salt: &str,
|
|
) -> Result<bool, sqlx::Error> {
|
|
match sqlx::query(
|
|
r#"
|
|
UPDATE "salt" SET salt = $1 WHERE id = $2
|
|
"#,
|
|
)
|
|
.bind(updated_salt)
|
|
.bind(salt.id)
|
|
.execute(pool)
|
|
.await
|
|
{
|
|
Ok(row) => {
|
|
if row.rows_affected() > 0 {
|
|
Ok(true)
|
|
} else {
|
|
Ok(false)
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
}
|