dialtone_axum 0.1.0

Dialtone Axum Back-end
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use axum::extract::{Extension, Query};
use axum::response::IntoResponse;
use axum::Json;

use dialtone_common::rest::simple_exchanges::SimpleResponse;
use dialtone_common::utils::parse_acct::parse_user_acct;
use dialtone_sqlx::db::actor::update_ap::update_actor_ap;
use sqlx::{Pool, Postgres};

use dialtone_common::ap::pun::is_valid_pun;
use dialtone_common::rest::actors::actor_exchanges::{
    GetActorRequest, NewActorRequest, PutUpdateActorRequest,
};

use dialtone_sqlx::control::actor::create_owned::create_credentialed_actor;
use dialtone_sqlx::db::actor::fetch_owned::fetch_owned_actor_by_id;
use dialtone_sqlx::logic::actor::new_actor::NewActor;

use crate::authz::authz_actor::authz_owner_or_actoradmin_for_actor;

use crate::response::response_error::ResponseError;
use crate::start_server::{Claims, SharedState};
use crate::{err_bad_request, err_not_found};

/// Creates an actors.
pub async fn post_owned_actor_handler(
    Json(new_actor_request): Json<NewActorRequest>,
    claims: Claims,
    Extension(pool): Extension<Pool<Postgres>>,
) -> Result<impl IntoResponse, ResponseError> {
    let user_host = parse_user_acct(&claims.sub)?;
    if !is_valid_pun(&new_actor_request.preferred_user_name, false) {
        return err_bad_request!();
    }

    let create_new_actor = NewActor {
        preferred_user_name: &new_actor_request.preferred_user_name,
        actor_type: new_actor_request.actor_type,
        owner: &claims.sub,
        name: None,
        summary: None,
        icon: None,
        image: None,
    };
    let actor =
        create_credentialed_actor(&pool, create_new_actor, false, &user_host.host_name).await?;
    Ok(Json(actor.owned_actor))
}

/// Update an actor.
pub async fn put_owned_actor_handler(
    Json(request): Json<PutUpdateActorRequest>,
    _: Claims,
    Extension(state): Extension<SharedState>,
    Extension(pool): Extension<Pool<Postgres>>,
) -> Result<impl IntoResponse, ResponseError> {
    authz_owner_or_actoradmin_for_actor(&pool, &state, &request.actor_id).await?;
    update_actor_ap(&pool, request.update, &request.actor_id)
        .await?
        .map(|_| Json(SimpleResponse::success()))
        .ok_or(ResponseError::not_found())
}

pub async fn get_owned_actor_handler(
    Query(params): Query<GetActorRequest>,
    _: Claims, //forces an authz lookup
    Extension(pool): Extension<Pool<Postgres>>,
    Extension(state): Extension<SharedState>,
) -> Result<impl IntoResponse, ResponseError> {
    authz_owner_or_actoradmin_for_actor(&pool, &state, &params.actor_id).await?;
    let actor = fetch_owned_actor_by_id(&pool, &params.actor_id).await?;
    match actor {
        None => err_not_found!(),
        Some(_) => Ok(Json(actor)),
    }
}