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
123
124
|
use crate::database::DatabaseWrapper;
use serde::{Deserialize, Serialize};
use sqlx::mysql::MySqlQueryResult;
use utoipa::ToSchema;
#[derive(Serialize, ToSchema)]
pub struct Artist {
#[schema(example = "artist name")]
name: Option<String>,
#[schema(example = "1")]
id: Option<i32>,
}
#[derive(Serialize, Deserialize, ToSchema)]
pub struct ArtistPost {
#[schema(example = "artist name", required = true)]
name: Option<String>,
}
#[derive(Serialize, Deserialize, ToSchema)]
pub struct ArtistPut {
#[schema(example = "1", required = true)]
id: Option<String>,
#[schema(example = "new name", required = true)]
name: Option<String>,
}
impl DatabaseWrapper {
pub async fn select_artists(&self) -> Result<Vec<Artist>, sqlx::Error> {
sqlx::query_as!(
Artist,
"SELECT name, id
FROM artist",
)
.fetch_all(&self.db_pool)
.await
}
pub async fn select_artist_by_id(&self, id: &str) -> Result<Option<Artist>, sqlx::Error> {
sqlx::query_as!(
Artist,
"SELECT name, id
FROM artist
WHERE id = ?",
id,
)
.fetch_optional(&self.db_pool)
.await
}
pub async fn select_artists_by_name(&self, name_raw: &str) -> Result<Vec<Artist>, sqlx::Error> {
let name: String = format!("{}{}{}", "%", name_raw, "%");
sqlx::query_as!(
Artist,
"SELECT name, id
FROM artist
WHERE name LIKE ?",
name,
)
.fetch_all(&self.db_pool)
.await
}
pub async fn create_artist(&self, data: ArtistPost) -> Result<MySqlQueryResult, sqlx::Error> {
if data.name.is_none() {
return Err(sqlx::Error::RowNotFound);
}
sqlx::query!(
"INSERT INTO artist (name)
VALUE (?)",
data.name
)
.execute(&self.db_pool)
.await
}
pub async fn edit_artist(&self, data: ArtistPut) -> Result<MySqlQueryResult, sqlx::Error> {
if data.id.is_none() {
return Err(sqlx::Error::RowNotFound);
}
let og_artist: Artist = match self.select_artist_by_id(data.id.as_ref().unwrap()).await {
Ok(res) => match res.is_some() {
true => res.unwrap(),
false => return Err(sqlx::Error::RowNotFound),
},
Err(_) => return Err(sqlx::Error::RowNotFound),
};
sqlx::query!(
"UPDATE artist SET name=? WHERE id=?",
data.name
.unwrap_or(og_artist.name.unwrap_or(String::default())),
data.id,
)
.execute(&self.db_pool)
.await
}
pub async fn delete_artist(&self, id: i32) -> Result<MySqlQueryResult, sqlx::Error> {
let _ = sqlx::query!(
"DELETE song FROM song
INNER JOIN album ON song.album_id = album.id
WHERE album.artist_id = ?",
id
)
.execute(&self.db_pool)
.await;
let _ = sqlx::query!(
"DELETE FROM album
WHERE artist_id = ?",
id
)
.execute(&self.db_pool)
.await;
sqlx::query!(
"DELETE FROM artist
WHERE id = ?",
id
)
.execute(&self.db_pool)
.await
}
}
|
