Skip to main content

quokka_admin/entity/
group.rs

1use quokka::{
2    helper::database::{
3        execute, query_all, query_one, query_optional, BaseRepository, PaginationOrder,
4    },
5    state::{Database, FromState},
6};
7
8#[derive(Clone, sqlx::FromRow, serde::Deserialize, serde::Serialize)]
9pub struct Group {
10    pub id: i32,
11    pub name: String,
12    pub created_at: time::OffsetDateTime,
13    pub updated_at: time::OffsetDateTime,
14}
15
16#[derive(Clone, sqlx::FromRow, serde::Deserialize, serde::Serialize)]
17pub struct UserGroup {
18    pub user_id: i32,
19    pub group_id: i32,
20    pub created_at: time::OffsetDateTime,
21    pub updated_at: time::OffsetDateTime,
22}
23
24#[derive(Clone, FromState)]
25pub struct GroupRepository {
26    database: Database,
27}
28
29#[derive(Clone, FromState)]
30pub struct UserGroupRepository {
31    database: Database,
32}
33
34impl GroupRepository {
35    #[query_optional(query = "SELECT * FROM \"group\" WHERE name = {name}")]
36    pub async fn get_group_by_name(&self, name: &str) -> quokka::Result<Option<Group>>;
37}
38
39impl BaseRepository for GroupRepository {
40    type Entity = Group;
41
42    type PkType = i32;
43
44    #[query_all(
45        query = "SELECT * FROM \"group\" ORDER BY {#order_by} {#direction.to_string()} LIMIT {#page_size} OFFSET {#page_size * page}"
46    )]
47    async fn get_entities(
48        &self,
49        page: i32,
50        page_size: i32,
51        order_by: &'static str,
52        direction: PaginationOrder,
53    ) -> quokka::Result<Vec<Self::Entity>>;
54
55    #[query_one(query = "SELECT * FROM \"group\" WHERE id = {pk}")]
56    fn get_entity(&self, pk: Self::PkType) -> quokka::Result<Self::Entity>;
57
58    #[execute(
59        query = "UPDATE \"group\" SET name = {entity.name}, updated_at = NOW() WHERE id = {entity.id}",
60        write
61    )]
62    fn update_entity(&self, entity: Self::Entity) -> quokka::Result<u64>;
63
64    #[query_one(
65        query = "INSERT INTO \"group\" (id, name) VALUES ({entity.id}, {entity.name}) RETURNING *",
66        write
67    )]
68    fn create_entity(&self, entity: Self::Entity) -> quokka::Result<Self::Entity>;
69
70    #[execute(query = "DELETE FROM \"group\" WHERE id = {pk}", write)]
71    fn delete_entity(&self, pk: Self::PkType) -> quokka::Result<u64>;
72}
73
74impl GroupRepository {
75    #[query_all(query = r#"SELECT "group".*
76        FROM "group"
77        INNER JOIN "user_group" gu
78            ON "group".id = gu.group_id
79        INNER JOIN "user"
80            ON "user".id = gu.user_id
81        WHERE
82            "user".username = {username}"#)]
83    pub async fn get_group_of_user(&self, username: &str) -> quokka::Result<Vec<Group>>;
84}
85
86impl BaseRepository for UserGroupRepository {
87    type Entity = UserGroup;
88
89    type PkType = (i32, i32);
90
91    #[query_all(
92        query = "SELECT * FROM \"user_group\" ORDER BY {#order_by} {#direction.to_string()} LIMIT {#page_size} OFFSET {#page_size * page}"
93    )]
94    async fn get_entities(
95        &self,
96        page: i32,
97        page_size: i32,
98        order_by: &'static str,
99        direction: PaginationOrder,
100    ) -> quokka::Result<Vec<Self::Entity>>;
101
102    #[query_one(
103        query = "SELECT * FROM \"user_group\" WHERE user_id = {pk.0} AND group_id = {pk.1}"
104    )]
105    fn get_entity(&self, pk: Self::PkType) -> quokka::Result<Self::Entity>;
106
107    /// There is nothing to be updated here
108    #[execute(
109        query = "UPDATE \"user_group\" SET updated_at = NOW() WHERE user_id = {entity.user_id} AND group_id = {entity.group_id}",
110        write
111    )]
112    fn update_entity(&self, entity: Self::Entity) -> quokka::Result<u64>;
113
114    #[query_one(
115        query = "INSERT INTO \"user_group\" (user_id, group_id) VALUES ({entity.user_id}, {entity.group_id}) RETURNING *",
116        write
117    )]
118    fn create_entity(&self, entity: Self::Entity) -> quokka::Result<Self::Entity>;
119
120    #[execute(
121        query = "DELETE FROM \"user_group\" WHERE user_id = {pk.0} AND group_id = {pk.1}",
122        write
123    )]
124    fn delete_entity(&self, pk: Self::PkType) -> quokka::Result<u64>;
125}