Adapted routes to new paths

src/dto.rs

@@ -6,15 +6,15 @@ use crate::models::*;
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TitleDto {
-    pub ids: TitleIdDto,
+pub struct ContentDto {
+    pub ids: ContentIdDto,
     pub kind: String,
     pub original_language: Option<String>,
     pub runtime: Option<i32>,
     pub year_start: Option<i32>,
     pub year_end: Option<i32>,
-    pub titles: Vec<TitleNameDto>,
-    pub descriptions: Vec<TitleDescriptionDto>,
+    pub titles: Vec<ContentNameDto>,
+    pub descriptions: Vec<ContentDescriptionDto>,
     pub cast: Vec<CastDto>,
     pub genres: Vec<GenreDto>,
     pub ratings: Vec<RatingDto>,
@@ -26,11 +26,11 @@ pub struct TitleDto {
     pub updated_at: chrono::DateTime<chrono::Utc>,
 }
 
-impl TitleDto {
+impl ContentDto {
     pub fn of(
         src: Title,
-        titles: Vec<TitleNameDto>,
-        descriptions: Vec<TitleDescriptionDto>,
+        titles: Vec<ContentNameDto>,
+        descriptions: Vec<ContentDescriptionDto>,
         cast: Vec<CastDto>,
         genres: Vec<GenreDto>,
         ratings: Vec<RatingDto>,
@@ -39,8 +39,8 @@ impl TitleDto {
         subtitles: Vec<SubtitleDto>,
         preview: Option<String>,
     ) -> Self {
-        TitleDto {
-            ids: TitleIdDto {
+        ContentDto {
+            ids: ContentIdDto {
                 uuid: src.id,
                 imdb: src.imdb_id,
                 tmdb: src.tmdb_id,
@@ -68,7 +68,7 @@ impl TitleDto {
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TitleIdDto {
+pub struct ContentIdDto {
     pub uuid: uuid::Uuid,
     pub imdb: Option<String>,
     pub tmdb: Option<i32>,
@@ -77,16 +77,16 @@ pub struct TitleIdDto {
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TitleNameDto {
+pub struct ContentNameDto {
     pub region: Option<String>,
     pub languages: Vec<String>,
     pub kind: String,
     pub name: String,
 }
 
-impl From<TitleName> for TitleNameDto {
+impl From<TitleName> for ContentNameDto {
     fn from(src: TitleName) -> Self {
-        TitleNameDto {
+        ContentNameDto {
             region: src.region,
             languages: src.languages,
             kind: src.kind,
@@ -97,7 +97,7 @@ impl From<TitleName> for TitleNameDto {
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TitleDescriptionDto {
+pub struct ContentDescriptionDto {
     pub region: Option<String>,
     pub languages: Vec<String>,
     pub kind: String,
@@ -105,9 +105,9 @@ pub struct TitleDescriptionDto {
     pub tagline: Option<String>,
 }
 
-impl From<TitleDescription> for TitleDescriptionDto {
+impl From<TitleDescription> for ContentDescriptionDto {
     fn from(src: TitleDescription) -> Self {
-        TitleDescriptionDto {
+        ContentDescriptionDto {
             region: src.region,
             languages: src.languages,
             kind: src.kind,
@@ -175,20 +175,20 @@ impl From<Person> for PersonDto {
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct EpisodeDto {
+pub struct InstalmentDto {
     pub season: Option<String>,
     pub episode: Option<String>,
     pub air_date: Option<chrono::NaiveDate>,
-    pub title: TitleDto,
+    pub content: ContentDto,
 }
 
-impl EpisodeDto {
-    pub fn of(episode: TitleEpisode, title: TitleDto) -> Self {
-        EpisodeDto {
+impl InstalmentDto {
+    pub fn of(episode: TitleEpisode, content: ContentDto) -> Self {
+        InstalmentDto {
             season: episode.season_number,
             episode: episode.episode_number,
             air_date: episode.air_date,
-            title,
+            content,
         }
     }
 }
@@ -271,14 +271,14 @@ impl SubtitleDto {
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct GenreWithTitlesDto {
+pub struct GenreWithContentDto {
     pub genre: GenreDto,
-    pub titles: Vec<TitleDto>,
+    pub content: Vec<ContentDto>,
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct TitleMetaDto {
-    pub title: TitleDto,
-    pub show: Option<EpisodeDto>,
+pub struct ContentMetaDto {
+    pub content: ContentDto,
+    pub instalment: Option<InstalmentDto>,
 }
\ No newline at end of file

src/dto_helpers.rs

@@ -7,7 +7,7 @@ use crate::dto::*;
 use crate::models::*;
 use crate::schema::*;
 
-pub fn load_episodes(db: &PgConnection, config: &Config, title_id: Uuid) -> QueryResult<Vec<EpisodeDto>> {
+pub fn load_episodes(db: &PgConnection, config: &Config, title_id: Uuid) -> QueryResult<Vec<InstalmentDto>> {
     let titles: Vec<(TitleEpisode, Title)> = title_episodes::table
         .filter(title_episodes::show_id.eq(title_id))
         .inner_join(titles::table.on(titles::id.eq(title_episodes::episode_id)))
@@ -16,19 +16,19 @@ pub fn load_episodes(db: &PgConnection, config: &Config, title_id: Uuid) -> Quer
     let (episodes, titles): (Vec<TitleEpisode>, Vec<Title>) = titles.into_iter().unzip();
     let titles = load_titles(db, config, titles)?;
     Ok(episodes.into_iter().zip(titles)
-        .map(|(episode, title)| EpisodeDto::of(episode, title))
+        .map(|(episode, title)| InstalmentDto::of(episode, title))
         .collect::<Vec<_>>())
 }
 
-pub fn load_show(db: &PgConnection, config: &Config, title_id: Uuid) -> QueryResult<EpisodeDto> {
+pub fn load_show(db: &PgConnection, config: &Config, title_id: Uuid) -> QueryResult<InstalmentDto> {
     let (episode, show) = title_episodes::table
         .filter(title_episodes::episode_id.eq(title_id))
         .inner_join(titles::table.on(titles::id.eq(title_episodes::show_id)))
         .first::<(TitleEpisode, Title)>(db)?;
-    Ok(EpisodeDto::of(episode, load_title(db, config, show)?))
+    Ok(InstalmentDto::of(episode, load_title(db, config, show)?))
 }
 
-pub fn load_title(db: &PgConnection, config: &Config, title: Title) -> QueryResult<TitleDto> {
+pub fn load_title(db: &PgConnection, config: &Config, title: Title) -> QueryResult<ContentDto> {
     let title_names: Vec<TitleName> = TitleName::belonging_to(&title)
         .load::<TitleName>(db)?;
     let title_descriptions: Vec<TitleDescription> = TitleDescription::belonging_to(&title)
@@ -59,7 +59,7 @@ pub fn load_title(db: &PgConnection, config: &Config, title: Title) -> QueryResu
     ))
 }
 
-pub fn load_titles(db: &PgConnection, config: &Config, titles: Vec<Title>) -> QueryResult<Vec<TitleDto>> {
+pub fn load_titles(db: &PgConnection, config: &Config, titles: Vec<Title>) -> QueryResult<Vec<ContentDto>> {
     let title_names: Vec<Vec<TitleName>> = TitleName::belonging_to(&titles)
         .load::<TitleName>(db)?
         .grouped_by(&titles);
@@ -113,7 +113,7 @@ pub fn load_titles(db: &PgConnection, config: &Config, titles: Vec<Title>) -> Qu
                 images, media, subtitles,
                 preview,
             )
-        }).collect::<Vec<TitleDto>>())
+        }).collect::<Vec<ContentDto>>())
 }
 
 fn process_title(
@@ -122,14 +122,14 @@ fn process_title(
     cast: Vec<(TitleCast, Person)>, genres: Vec<(TitleGenre, Genre)>, ratings: Vec<TitleRating>,
     images: Vec<TitleImage>, media: Vec<TitleMedium>, subtitles: Vec<TitleSubtitle>,
     preview: Option<TitlePreview>,
-) -> TitleDto {
-    TitleDto::of(
+) -> ContentDto {
+    ContentDto::of(
         title,
         names.into_iter().map(|src| {
-            TitleNameDto::from(src)
+            ContentNameDto::from(src)
         }).collect::<Vec<_>>(),
         descriptions.into_iter().map(|src| {
-            TitleDescriptionDto::from(src)
+            ContentDescriptionDto::from(src)
         }).collect::<Vec<_>>(),
         cast.into_iter().map(|src| {
             let (cast, person) = src;

src/main.rs

@@ -34,7 +34,7 @@ fn list_genres(db: MediaflixConnection) -> QueryResult<Json<Vec<GenreDto>>> {
 }
 
 #[get("/api/v1/genres/<genre_id>")]
-fn get_genre(db: MediaflixConnection, config: State<Config>, genre_id: ParamUuid) -> QueryResult<Json<GenreWithTitlesDto>> {
+fn get_genre(db: MediaflixConnection, config: State<Config>, genre_id: ParamUuid) -> QueryResult<Json<GenreWithContentDto>> {
     use media_backend::schema::*;
     let genre: Genre = genres::table
         .find(genre_id.uuid())
@@ -44,47 +44,47 @@ fn get_genre(db: MediaflixConnection, config: State<Config>, genre_id: ParamUuid
         .inner_join(titles::table)
         .select(titles::all_columns)
         .load::<Title>(&db.0)?;
-    Ok(Json(GenreWithTitlesDto {
+    Ok(Json(GenreWithContentDto {
         genre: GenreDto::from(genre),
-        titles: load_titles(&db.0, &config, titles)?,
+        content: load_titles(&db.0, &config, titles)?,
     }))
 }
 
-#[get("/api/v1/titles")]
-fn list_titles(db: MediaflixConnection, config: State<Config>) -> QueryResult<Json<Vec<TitleDto>>> {
+#[get("/api/v1/content")]
+fn list_content(db: MediaflixConnection, config: State<Config>) -> QueryResult<Json<Vec<ContentDto>>> {
     use media_backend::schema::*;
-    let titles = titles::table
+    let content = titles::table
         .left_outer_join(title_episodes::table.on(title_episodes::episode_id.eq(titles::id)))
         .filter(title_episodes::id.is_null())
         .select(titles::all_columns)
         .load::<Title>(&db.0)?;
-    Ok(Json(load_titles(&db.0, &config, titles)?))
+    Ok(Json(load_titles(&db.0, &config, content)?))
 }
 
-#[get("/api/v1/titles/<title_id>")]
-fn get_title(db: MediaflixConnection, config: State<Config>, title_id: ParamUuid) -> QueryResult<Json<TitleMetaDto>> {
+#[get("/api/v1/content/<content_id>")]
+fn get_content(db: MediaflixConnection, config: State<Config>, content_id: ParamUuid) -> QueryResult<Json<ContentMetaDto>> {
     use media_backend::schema::*;
-    let title = load_title(
+    let content = load_title(
         &db.0,
         &config,
         titles::table
-            .find(title_id.uuid())
+            .find(content_id.uuid())
             .first::<Title>(&db.0)?,
     )?;
-    match title.kind.as_str() {
+    match content.kind.as_str() {
         "episode" => {
-            let show = load_show(&db.0, &config, title.ids.uuid)?;
-            Ok(Json(TitleMetaDto { title, show: Some(show) }))
+            let show = load_show(&db.0, &config, content.ids.uuid)?;
+            Ok(Json(ContentMetaDto { content, instalment: Some(show) }))
         }
         _ => {
-            Ok(Json(TitleMetaDto { title, show: None }))
+            Ok(Json(ContentMetaDto { content, instalment: None }))
         }
     }
 }
 
-#[get("/api/v1/titles/<title_id>/episodes")]
-fn list_episodes(db: MediaflixConnection, config: State<Config>, title_id: ParamUuid) -> QueryResult<Json<Vec<EpisodeDto>>> {
-    Ok(Json(load_episodes(&db.0, &config, title_id.uuid())?))
+#[get("/api/v1/content/<content_id>/episodes")]
+fn list_episodes(db: MediaflixConnection, config: State<Config>, content_id: ParamUuid) -> QueryResult<Json<Vec<InstalmentDto>>> {
+    Ok(Json(load_episodes(&db.0, &config, content_id.uuid())?))
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -100,12 +100,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             rocket::routes![
                 list_genres,
                 get_genre,
-                list_titles,
-                get_title,
+                list_content,
+                get_content,
                 list_episodes
             ],
         )
-        .mount("/static", StaticFiles::from(env::var("MEDIAFLIX_PATH")?))
+        .mount("/media", StaticFiles::from(env::var("MEDIAFLIX_PATH")?))
         .attach(MediaflixConnection::fairing())
         .attach(rocket_cors::CorsOptions {
             allowed_headers: AllowedHeaders::some(&["Authorization", "Accept", "Accept-Language"]),