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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Controllers for requests starting with `/api/v0/main-frontend/exercise-services/`.

use models::exercise_services::{ExerciseService, ExerciseServiceNewOrUpdate};

use crate::prelude::*;

/**
DELETE `/api/v0/main-frontend/exercise-services/:id`
*/
#[instrument(skip(pool))]
async fn delete_exercise_service(
    exercise_service_id: web::Path<Uuid>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ExerciseService>> {
    let mut conn = pool.acquire().await?;
    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::ExerciseService).await?;

    let deleted =
        models::exercise_services::delete_exercise_service(&mut conn, *exercise_service_id).await?;

    token.authorized_ok(web::Json(deleted))
}

/**
POST `/api/v0/main-frontend/exercise-services`
*/
#[instrument(skip(pool))]
async fn add_exercise_service(
    pool: web::Data<PgPool>,
    user: AuthUser,
    payload: web::Json<ExerciseServiceNewOrUpdate>,
) -> ControllerResult<web::Json<ExerciseService>> {
    let mut conn = pool.acquire().await?;
    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::ExerciseService).await?;

    let exercise_service = payload.0;
    let created =
        models::exercise_services::insert_exercise_service(&mut conn, &exercise_service).await?;

    token.authorized_ok(web::Json(created))
}

/**
GET `/api/v0/main-frontend/exercise-services/:id`
*/
#[instrument(skip(pool))]
async fn get_exercise_service_by_id(
    exercise_service_id: web::Path<Uuid>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ExerciseService>> {
    let mut conn = pool.acquire().await?;
    let exercise_service =
        models::exercise_services::get_exercise_service(&mut conn, *exercise_service_id).await?;

    let token = authorize(&mut conn, Act::Teach, Some(user.id), Res::ExerciseService).await?;
    token.authorized_ok(web::Json(exercise_service))
}

/**
GET `/api/v0/main-frontend/exercise-services`
*/
#[instrument(skip(pool))]
async fn get_exercise_services(
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<Vec<ExerciseService>>> {
    let mut conn = pool.acquire().await?;
    let exercise_services = models::exercise_services::get_exercise_services(&mut conn).await?;

    let token = authorize(&mut conn, Act::Teach, Some(user.id), Res::ExerciseService).await?;
    token.authorized_ok(web::Json(exercise_services))
}

/**
PUT `/api/v0/main-frontend/exercise-services/:id`
*/
#[instrument(skip(pool))]
async fn update_exercise_service(
    payload: web::Json<ExerciseServiceNewOrUpdate>,
    exercise_service_id: web::Path<Uuid>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ExerciseService>> {
    let mut conn = pool.acquire().await?;
    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::ExerciseService).await?;

    let updated_exercise_service = payload.0;
    let updated_service = models::exercise_services::update_exercise_service(
        &mut conn,
        *exercise_service_id,
        &updated_exercise_service,
    )
    .await?;

    token.authorized_ok(web::Json(updated_service))
}

/**
Add a route for each controller in this module.

The name starts with an underline in order to appear before other functions in the module documentation.

We add the routes by calling the route method instead of using the route annotations because this method preserves the function signatures for documentation.
*/
pub fn _add_routes(cfg: &mut ServiceConfig) {
    cfg.route("/", web::post().to(add_exercise_service))
        .route("/", web::get().to(get_exercise_services))
        .route(
            "/{exercise_service_id}",
            web::delete().to(delete_exercise_service),
        )
        .route(
            "/{exercise_service_id}",
            web::put().to(update_exercise_service),
        )
        .route(
            "/{exercise_service_id}",
            web::get().to(get_exercise_service_by_id),
        );
}