1#[macro_use]
2extern crate log;
3
4#[cfg(test)]
5mod tests;
6
7pub mod addons;
8pub mod core;
9pub mod event;
10pub mod history;
11pub mod library;
12pub mod mixer;
13pub mod playback;
14pub mod playlist;
15pub mod server;
16pub mod tracklist;
17pub mod api {
18 #[path = ""]
19 pub mod music {
20 use music_player_entity::folder;
21 use music_player_types::types::Playlist;
22
23 use self::v1alpha1::{GetFolderDetailsResponse, GetPlaylistDetailsResponse};
24
25 #[path = "music.v1alpha1.rs"]
26 pub mod v1alpha1;
27
28 impl From<folder::Model> for GetFolderDetailsResponse {
29 fn from(model: folder::Model) -> Self {
30 Self {
31 id: model.id,
32 name: model.name,
33 playlists: model.playlists.into_iter().map(Into::into).collect(),
34 ..Default::default()
35 }
36 }
37 }
38
39 impl Into<Playlist> for GetPlaylistDetailsResponse {
40 fn into(self) -> Playlist {
41 Playlist {
42 id: self.id,
43 name: self.name,
44 description: Some(self.description),
45 tracks: self.tracks.into_iter().map(Into::into).collect(),
46 }
47 }
48 }
49
50 impl From<Playlist> for GetPlaylistDetailsResponse {
51 fn from(playlist: Playlist) -> Self {
52 Self {
53 id: playlist.id,
54 name: playlist.name,
55 description: playlist.description.unwrap_or_default(),
56 tracks: playlist.tracks.into_iter().map(Into::into).collect(),
57 }
58 }
59 }
60 }
61
62 #[path = ""]
63 pub mod objects {
64 use self::v1alpha1::Playlist;
65 use music_player_entity::playlist;
66 use music_player_types::types;
67
68 #[path = "objects.v1alpha1.rs"]
69 pub mod v1alpha1;
70
71 impl From<playlist::Model> for Playlist {
72 fn from(model: playlist::Model) -> Self {
73 Self {
74 id: model.id,
75 name: model.name,
76 description: model.description.unwrap_or_default(),
77 tracks: model.tracks.into_iter().map(Into::into).collect(),
78 ..Default::default()
79 }
80 }
81 }
82
83 impl Into<types::Playlist> for Playlist {
84 fn into(self) -> types::Playlist {
85 types::Playlist {
86 id: self.id,
87 name: self.name,
88 description: Some(self.description),
89 tracks: self.tracks.into_iter().map(Into::into).collect(),
90 }
91 }
92 }
93 }
94
95 #[path = ""]
96 pub mod metadata {
97 use music_player_entity::{album, artist, track};
98 use music_player_types::types;
99
100 use self::v1alpha1::{Album, Artist, ArtistSong, Song, SongArtist, Track};
101
102 #[path = "metadata.v1alpha1.rs"]
103 pub mod v1alpha1;
104
105 impl From<artist::Model> for Artist {
106 fn from(model: artist::Model) -> Self {
107 Self {
108 id: model.id,
109 name: model.name,
110 songs: model.tracks.into_iter().map(Into::into).collect(),
111 albums: model.albums.into_iter().map(Into::into).collect(),
112 ..Default::default()
113 }
114 }
115 }
116
117 impl From<album::Model> for Album {
118 fn from(model: album::Model) -> Self {
119 Self {
120 id: model.id,
121 title: model.title,
122 cover: model.cover.unwrap_or_default(),
123 artist: model.artist,
124 year: i32::try_from(model.year.unwrap_or_default()).unwrap_or_default(),
125 tracks: model.tracks.into_iter().map(Into::into).collect(),
126 ..Default::default()
127 }
128 }
129 }
130
131 impl From<track::Model> for Track {
132 fn from(model: track::Model) -> Self {
133 Self {
134 id: model.id,
135 title: model.title,
136 uri: model.uri,
137 duration: model.duration.unwrap_or(0.0),
138 track_number: i32::try_from(model.track.unwrap_or_default()).unwrap(),
139 artists: model.artists.into_iter().map(Into::into).collect(),
140 album: Some(model.album.into()),
141 artist: model.artist,
142 ..Default::default()
143 }
144 }
145 }
146
147 impl From<track::Model> for Song {
148 fn from(model: track::Model) -> Self {
149 Self {
150 id: model.id,
151 title: model.title,
152 duration: model.duration.unwrap_or_default(),
153 track_number: i32::try_from(model.track.unwrap_or_default()).unwrap(),
154 artists: model.artists.into_iter().map(Into::into).collect(),
155 ..Default::default()
156 }
157 }
158 }
159
160 impl From<types::Track> for Song {
161 fn from(track: types::Track) -> Self {
162 Self {
163 id: track.id,
164 title: track.title,
165 duration: track.duration.unwrap_or_default(),
166 track_number: track.track_number.unwrap_or_default() as i32,
167 artists: track.artists.into_iter().map(Into::into).collect(),
168 ..Default::default()
169 }
170 }
171 }
172
173 impl From<artist::Model> for SongArtist {
174 fn from(model: artist::Model) -> Self {
175 Self {
176 id: model.id,
177 name: model.name,
178 ..Default::default()
179 }
180 }
181 }
182
183 impl From<types::Artist> for SongArtist {
184 fn from(artist: types::Artist) -> Self {
185 Self {
186 id: artist.id,
187 name: artist.name,
188 ..Default::default()
189 }
190 }
191 }
192
193 impl From<track::Model> for ArtistSong {
194 fn from(model: track::Model) -> Self {
195 Self {
196 id: model.id,
197 title: model.title,
198 duration: model.duration.unwrap_or_default(),
199 track_number: i32::try_from(model.track.unwrap_or_default()).unwrap(),
200 artists: model.artists.into_iter().map(Into::into).collect(),
201 album: Some(model.album.into()),
202 artist: model.artist,
203 ..Default::default()
204 }
205 }
206 }
207
208 impl Into<types::Track> for ArtistSong {
209 fn into(self) -> types::Track {
210 types::Track {
211 id: self.id,
212 title: self.title,
213 duration: Some(self.duration),
214 track_number: Some(u32::try_from(self.track_number).unwrap_or_default()),
215 disc_number: u32::try_from(self.disc_number).unwrap_or_default(),
216 artists: self.artists.into_iter().map(Into::into).collect(),
217 album: match self.album {
218 Some(album) => Some(album.into()),
219 None => None,
220 },
221 artist: self.artist,
222 ..Default::default()
223 }
224 }
225 }
226
227 impl Into<types::Track> for Track {
228 fn into(self) -> types::Track {
229 types::Track {
230 id: self.id,
231 title: self.title,
232 uri: self.uri,
233 duration: Some(self.duration),
234 track_number: Some(u32::try_from(self.track_number).unwrap_or_default()),
235 disc_number: u32::try_from(self.disc_number).unwrap_or_default(),
236 artists: self.artists.into_iter().map(Into::into).collect(),
237 artist: self.artist,
238 album: match self.album {
239 Some(album) => Some(album.into()),
240 None => None,
241 },
242 }
243 }
244 }
245
246 impl Into<track::Model> for Track {
247 fn into(self) -> track::Model {
248 track::Model {
249 id: self.id,
250 title: self.title,
251 uri: self.uri,
252 duration: Some(self.duration),
253 track: Some(u32::try_from(self.track_number).unwrap_or_default()),
254 artists: self.artists.into_iter().map(Into::into).collect(),
255 artist: self.artist,
256 album: self.album.unwrap().into(),
257 ..Default::default()
258 }
259 }
260 }
261
262 impl From<types::Track> for Track {
263 fn from(track: types::Track) -> Self {
264 Self {
265 id: track.id,
266 title: track.title,
267 uri: track.uri,
268 duration: track.duration.unwrap_or_default(),
269 track_number: i32::try_from(track.track_number.unwrap_or_default()).unwrap(),
270 disc_number: i32::try_from(track.disc_number).unwrap(),
271 artists: track.artists.into_iter().map(Into::into).collect(),
272 artist: track.artist,
273 album: match track.album {
274 Some(album) => Some(album.into()),
275 None => None,
276 },
277 ..Default::default()
278 }
279 }
280 }
281
282 impl Into<types::Artist> for Artist {
283 fn into(self) -> types::Artist {
284 types::Artist {
285 id: self.id,
286 name: self.name,
287 picture: Some(self.picture),
288 albums: self.albums.into_iter().map(Into::into).collect(),
289 songs: self.songs.into_iter().map(Into::into).collect(),
290 }
291 }
292 }
293
294 impl Into<artist::Model> for Artist {
295 fn into(self) -> artist::Model {
296 artist::Model {
297 id: self.id,
298 name: self.name,
299 albums: self.albums.into_iter().map(Into::into).collect(),
300 ..Default::default()
301 }
302 }
303 }
304
305 impl From<types::Artist> for Artist {
306 fn from(artist: types::Artist) -> Self {
307 Self {
308 id: artist.id,
309 name: artist.name,
310 picture: artist.picture.unwrap_or_default(),
311 ..Default::default()
312 }
313 }
314 }
315
316 impl Into<types::Artist> for SongArtist {
317 fn into(self) -> types::Artist {
318 types::Artist {
319 id: self.id,
320 name: self.name,
321 ..Default::default()
322 }
323 }
324 }
325
326 impl Into<types::Track> for Song {
327 fn into(self) -> types::Track {
328 types::Track {
329 id: self.id,
330 title: self.title,
331 duration: Some(self.duration),
332 track_number: Some(u32::try_from(self.track_number).unwrap_or_default()),
333 disc_number: u32::try_from(self.disc_number).unwrap_or_default(),
334 artists: self.artists.into_iter().map(Into::into).collect(),
335 ..Default::default()
336 }
337 }
338 }
339
340 impl Into<types::Album> for Album {
341 fn into(self) -> types::Album {
342 types::Album {
343 id: self.id,
344 title: self.title,
345 cover: Some(self.cover),
346 artist: self.artist.clone(),
347 year: Some(u32::try_from(self.year).unwrap_or_default()),
348 artist_id: Some(format!("{:x}", md5::compute(self.artist.as_str()))),
349 tracks: self.tracks.into_iter().map(Into::into).collect(),
350 }
351 }
352 }
353
354 impl Into<album::Model> for Album {
355 fn into(self) -> album::Model {
356 album::Model {
357 id: self.id,
358 title: self.title,
359 cover: Some(self.cover),
360 artist: self.artist.clone(),
361 year: Some(u32::try_from(self.year).unwrap_or_default()),
362 artist_id: Some(format!("{:x}", md5::compute(self.artist.as_str()))),
363 ..Default::default()
364 }
365 }
366 }
367
368 impl From<types::Album> for Album {
369 fn from(album: types::Album) -> Self {
370 Self {
371 id: album.id,
372 title: album.title,
373 cover: album.cover.unwrap_or_default(),
374 artist: album.artist,
375 year: i32::try_from(album.year.unwrap_or_default()).unwrap_or_default(),
376 tracks: album.tracks.into_iter().map(Into::into).collect(),
377 ..Default::default()
378 }
379 }
380 }
381 }
382}