11293816145

Committed 11 Oct 2024 02:05PM UTC coverage: 55.96% (+0.04%) from 55.917%

Build # 11293816145

Build Type

Pull #1335

github

Committed by

web-flow

Commit Message

Merge b0326eba2 into 7cf458010

Pull Request Pull Request #1335: Bump @types/node from 22.7.4 to 22.7.5 in /app

Run Details

3934 of 7030 relevant lines covered (55.96%)

103.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.22

/src/routes/admin.rs

use crate::{
    entity::queue::{self, Column, Entity, JobStatus, Model},
    handler::{admin_required, Error},
    Db,
};
use querystrong::QueryStrong;
use sea_orm::{ColumnTrait, EntityTrait, ModelTrait, QueryOrder, QuerySelect};
use trillium::{async_trait, Conn, Handler, Status};
use trillium_api::{api, FromConn, Json};
use trillium_caching_headers::CachingHeadersExt;
use trillium_router::{router, RouterConnExt};
use uuid::Uuid;

pub fn routes() -> impl Handler {
    (
        api(admin_required),
        router()
            .get("/queue", api(index))
            .get("/queue/:job_id", api(show))
            .delete("/queue/:job_id", api(delete)),
    )
}

#[async_trait]
impl FromConn for queue::Model {
    async fn from_conn(conn: &mut Conn) -> Option<Self> {
        let db = Db::from_conn(conn).await?;
        let id: Uuid = conn.param("job_id")?.parse().ok()?;

        match Entity::find_by_id(id).one(&db).await {
            Ok(job) => job,
            Err(error) => {
                conn.insert_state(Error::from(error));
                None
            }
        }
    }
}

async fn index(conn: &mut Conn, db: Db) -> Result<Json<Vec<Model>>, Error> {
    let params = QueryStrong::parse(conn.querystring()).unwrap_or_default();
    let mut find = Entity::find();
    let query = QuerySelect::query(&mut find);
    match params.get_str("status") {
        Some("pending") => {
            query.cond_where(Column::Status.eq(JobStatus::Pending));
        }

        Some("success") => {
            query.cond_where(Column::Status.eq(JobStatus::Success));
        }

        Some("failed") => {
            query.cond_where(Column::Status.eq(JobStatus::Failed));
        }

        _ => {}
    }

    find.order_by_desc(Column::UpdatedAt)
        .limit(100)
        .all(&db)
        .await
        .map(Json)
        .map_err(Error::from)
}

async fn show(conn: &mut Conn, queue_job: Model) -> Json<Model> {
    conn.set_last_modified(queue_job.updated_at.into());

    Json(queue_job)
}

async fn delete(_: &mut Conn, (queue_job, db): (Model, Db)) -> Result<Status, Error> {
    queue_job.delete(&db).await?;
    Ok(Status::NoContent)
}

1	use crate::{
2	entity::queue::{self, Column, Entity, JobStatus, Model},
3	handler::{admin_required, Error},
4	Db,
5	};
6	use querystrong::QueryStrong;
7	use sea_orm::{ColumnTrait, EntityTrait, ModelTrait, QueryOrder, QuerySelect};
8	use trillium::{async_trait, Conn, Handler, Status};
9	use trillium_api::{api, FromConn, Json};
10	use trillium_caching_headers::CachingHeadersExt;
11	use trillium_router::{router, RouterConnExt};
12	use uuid::Uuid;
13
14	pub fn routes() -> impl Handler {	283✔
15	(	283✔
16	api(admin_required),	283✔
17	router()	283✔
18	.get("/queue", api(index))	283✔
19	.get("/queue/:job_id", api(show))	283✔
20	.delete("/queue/:job_id", api(delete)),	283✔
21	)	283✔
22	}	283✔
23
24	#[async_trait]
25	impl FromConn for queue::Model {
26	async fn from_conn(conn: &mut Conn) -> Option<Self> {	×
27	let db = Db::from_conn(conn).await?;	×
28	let id: Uuid = conn.param("job_id")?.parse().ok()?;	×
29
30	match Entity::find_by_id(id).one(&db).await {	×
31	Ok(job) => job,	×
32	Err(error) => {	×
33	conn.insert_state(Error::from(error));	×
34	None	×
35	}
36	}
37	}	×
38	}
39
40	async fn index(conn: &mut Conn, db: Db) -> Result<Json<Vec<Model>>, Error> {	4✔
41	let params = QueryStrong::parse(conn.querystring()).unwrap_or_default();	4✔
42	let mut find = Entity::find();	4✔
43	let query = QuerySelect::query(&mut find);	4✔
44	match params.get_str("status") {	4✔
45	Some("pending") => {	3✔
46	query.cond_where(Column::Status.eq(JobStatus::Pending));	1✔
47	}	1✔
48
49	Some("success") => {	2✔
50	query.cond_where(Column::Status.eq(JobStatus::Success));	1✔
51	}	1✔
52
53	Some("failed") => {	1✔
54	query.cond_where(Column::Status.eq(JobStatus::Failed));	1✔
55	}	1✔
56
57	_ => {}	1✔
58	}
59
60	find.order_by_desc(Column::UpdatedAt)	4✔
61	.limit(100)	4✔
62	.all(&db)	4✔
63	.await	×
64	.map(Json)	4✔
65	.map_err(Error::from)	4✔
66	}	4✔
67
68	async fn show(conn: &mut Conn, queue_job: Model) -> Json<Model> {	×
69	conn.set_last_modified(queue_job.updated_at.into());	×
70		×
71	Json(queue_job)	×
72	}	×
73
74	async fn delete(_: &mut Conn, (queue_job, db): (Model, Db)) -> Result<Status, Error> {	×
75	queue_job.delete(&db).await?;	×
76	Ok(Status::NoContent)	×
77	}	×

divviup / divviup-api / 11293816145

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous