Tahinli/rust_forum
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: ♻️ new permission strategy part 1

Browse source
This commit is contained in:
Ahmet Kaan GÜMÜŞ 2025-01-17 22:59:35 +03:00
parent cf1107d09c
commit 56aa04e32a
24 changed files with 3 additions and 1063 deletions
Download patch file Download diff file Expand all files Collapse all files

93
src/routing/permission.rs
View file

@ -1,93 +0,0 @@
use axum::{
extract::{Path, State},
http::StatusCode,
response::IntoResponse,
routing::{delete, get, patch, post},
Json, Router,
};
use serde::{Deserialize, Serialize};
use crate::{feature::permission::Permission, AppState};
#[derive(Debug, Serialize, Deserialize)]
struct CreatePermission {
name: String,
}
#[derive(Debug, Serialize, Deserialize)]
struct UpdatePermission {
id: i64,
name: String,
}
pub fn route(State(app_state): State<AppState>) -> Router<AppState> {
Router::new()
.route("/", post(create))
.route("/:id", get(read))
.route("/", patch(update))
.route("/:id", delete(delete_))
.route("/", get(read_all))
.with_state(app_state)
}
async fn create(
State(app_state): State<AppState>,
Json(create_permission): Json<CreatePermission>,
) -> impl IntoResponse {
match Permission::create(&create_permission.name, &app_state.database_connection).await {
Ok(permission) => (StatusCode::CREATED, Json(serde_json::json!(permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read(State(app_state): State<AppState>, Path(id): Path<i64>) -> impl IntoResponse {
match Permission::read(&id, &app_state.database_connection).await {
Ok(permission) => (StatusCode::OK, Json(serde_json::json!(permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn update(
State(app_state): State<AppState>,
Json(update_permission): Json<UpdatePermission>,
) -> impl IntoResponse {
match Permission::update(
&update_permission.id,
&update_permission.name,
&app_state.database_connection,
)
.await
{
Ok(permission) => (StatusCode::ACCEPTED, Json(serde_json::json!(permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn delete_(State(app_state): State<AppState>, Path(id): Path<i64>) -> impl IntoResponse {
match Permission::delete(&id, &app_state.database_connection).await {
Ok(permission) => (StatusCode::NO_CONTENT, Json(serde_json::json!(permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read_all(State(app_state): State<AppState>) -> impl IntoResponse {
match Permission::read_all(&app_state.database_connection).await {
Ok(permissions) => (StatusCode::OK, Json(serde_json::json!(permissions))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}

135
src/routing/role_permission.rs
View file

@ -1,135 +0,0 @@
use axum::{
extract::{Path, State},
http::StatusCode,
response::IntoResponse,
routing::{delete, get, patch, post},
Json, Router,
};
use serde::{Deserialize, Serialize};
use crate::{feature::role_permission::RolePermission, AppState};
#[derive(Debug, Serialize, Deserialize)]
struct CreateRolePermission {
pub role_id: i64,
pub permission_id: i64,
}
#[derive(Debug, Serialize, Deserialize)]
struct UpdateRolePermission {
pub role_id: i64,
pub permission_id: i64,
}
pub fn route(State(app_state): State<AppState>) -> Router<AppState> {
Router::new()
.route("/", post(create))
.route("/roles/:role_id/permissions/:permission_id", get(read))
.route("/", patch(update))
.route(
"/roles/:role_id/permissions/:permission_id",
delete(delete_),
)
.route("/roles/:role_id", get(read_all_for_role))
.route("/roles/:role_id", delete(delete_all_for_role))
.with_state(app_state)
}
async fn create(
State(app_state): State<AppState>,
Json(create_role_permission): Json<CreateRolePermission>,
) -> impl IntoResponse {
match RolePermission::create(
&create_role_permission.role_id,
&create_role_permission.permission_id,
&app_state.database_connection,
)
.await
{
Ok(role_permission) => (
StatusCode::CREATED,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read(
State(app_state): State<AppState>,
Path((role_id, permission_id)): Path<(i64, i64)>,
) -> impl IntoResponse {
match RolePermission::read(&role_id, &permission_id, &app_state.database_connection).await {
Ok(role_permission) => (StatusCode::OK, Json(serde_json::json!(role_permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn update(
State(app_state): State<AppState>,
Json(update_role): Json<UpdateRolePermission>,
) -> impl IntoResponse {
match RolePermission::update(
&update_role.role_id,
&update_role.permission_id,
&app_state.database_connection,
)
.await
{
Ok(role_permission) => (
StatusCode::ACCEPTED,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn delete_(
State(app_state): State<AppState>,
Path((role_id, permission_id)): Path<(i64, i64)>,
) -> impl IntoResponse {
match RolePermission::delete(&role_id, &permission_id, &app_state.database_connection).await {
Ok(role_permission) => (
StatusCode::NO_CONTENT,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read_all_for_role(
State(app_state): State<AppState>,
Path(role_id): Path<i64>,
) -> impl IntoResponse {
match RolePermission::read_all_for_role(&role_id, &app_state.database_connection).await {
Ok(role_permissions) => (StatusCode::OK, Json(serde_json::json!(role_permissions))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn delete_all_for_role(
State(app_state): State<AppState>,
Path(role_id): Path<i64>,
) -> impl IntoResponse {
match RolePermission::delete_all_for_role(&role_id, &app_state.database_connection).await {
Ok(role_permissions) => (StatusCode::OK, Json(serde_json::json!(role_permissions))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}

36
src/routing/routing.rs
View file

@ -1,36 +0,0 @@
use axum::{
extract::{Path, State},
http::StatusCode,
response::IntoResponse,
routing::get,
Json, Router,
};
use crate::{feature::routing::Routing, AppState};
pub fn route(State(app_state): State<AppState>) -> Router<AppState> {
Router::new()
.route("/:id", get(read))
.route("/", get(read_all))
.with_state(app_state)
}
async fn read(State(app_state): State<AppState>, Path(id): Path<i64>) -> impl IntoResponse {
match Routing::read(&id, &app_state.database_connection).await {
Ok(routing) => (StatusCode::OK, Json(serde_json::json!(routing))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read_all(State(app_state): State<AppState>) -> impl IntoResponse {
match Routing::read_all(&app_state.database_connection).await {
Ok(routings) => (StatusCode::OK, Json(serde_json::json!(routings))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}

144
src/routing/routing_permission.rs
View file

@ -1,144 +0,0 @@
use axum::{
extract::{Path, State},
http::StatusCode,
response::IntoResponse,
routing::{delete, get, patch, post},
Json, Router,
};
use serde::{Deserialize, Serialize};
use crate::{feature::routing_permission::RoutingPermission, AppState};
#[derive(Debug, Serialize, Deserialize)]
struct CreateRoutingPermission {
pub routing_id: i64,
pub permission_id: i64,
}
#[derive(Debug, Serialize, Deserialize)]
struct UpdateRoutingPermission {
pub routing_id: i64,
pub permission_id: i64,
}
pub fn route(State(app_state): State<AppState>) -> Router<AppState> {
Router::new()
.route("/", post(create))
.route(
"/routings/:routing_id/permissions/:permission_id",
get(read),
)
.route("/", patch(update))
.route(
"/routings/:routing_id/permissions/:permission_id",
delete(delete_),
)
.route("/routings/:routing_id", get(read_all_for_routing))
.route("/routings/:routing_id", delete(delete_all_for_routing))
.with_state(app_state)
}
async fn create(
State(app_state): State<AppState>,
Json(create_role_permission): Json<CreateRoutingPermission>,
) -> impl IntoResponse {
match RoutingPermission::create(
&create_role_permission.routing_id,
&create_role_permission.permission_id,
&app_state.database_connection,
)
.await
{
Ok(role_permission) => (
StatusCode::CREATED,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read(
State(app_state): State<AppState>,
Path((routing_id, permission_id)): Path<(i64, i64)>,
) -> impl IntoResponse {
match RoutingPermission::read(&routing_id, &permission_id, &app_state.database_connection).await
{
Ok(role_permission) => (StatusCode::OK, Json(serde_json::json!(role_permission))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn update(
State(app_state): State<AppState>,
Json(update_role): Json<UpdateRoutingPermission>,
) -> impl IntoResponse {
match RoutingPermission::update(
&update_role.routing_id,
&update_role.permission_id,
&app_state.database_connection,
)
.await
{
Ok(role_permission) => (
StatusCode::ACCEPTED,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn delete_(
State(app_state): State<AppState>,
Path((routing_id, permission_id)): Path<(i64, i64)>,
) -> impl IntoResponse {
match RoutingPermission::delete(&routing_id, &permission_id, &app_state.database_connection)
.await
{
Ok(role_permission) => (
StatusCode::NO_CONTENT,
Json(serde_json::json!(role_permission)),
),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn read_all_for_routing(
State(app_state): State<AppState>,
Path(routing_id): Path<i64>,
) -> impl IntoResponse {
match RoutingPermission::read_all_for_routing(&routing_id, &app_state.database_connection).await
{
Ok(role_permissions) => (StatusCode::OK, Json(serde_json::json!(role_permissions))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}
async fn delete_all_for_routing(
State(app_state): State<AppState>,
Path(routing_id): Path<i64>,
) -> impl IntoResponse {
match RoutingPermission::delete_all_for_routing(&routing_id, &app_state.database_connection)
.await
{
Ok(role_permissions) => (StatusCode::OK, Json(serde_json::json!(role_permissions))),
Err(err_val) => (
StatusCode::BAD_REQUEST,
Json(serde_json::json!(err_val.to_string())),
),
}
}