dto_helpers.rs

use diesel::*;

use crate::dto::*;
use crate::models::*;
use crate::schema::*;

pub fn load_title(db: &PgConnection, title: Title) -> QueryResult<TitleDto> {
    let title_names: Vec<TitleName> = TitleName::belonging_to(&title)
        .load::<TitleName>(db)?;
    let title_descriptions: Vec<TitleDescription> = TitleDescription::belonging_to(&title)
        .load::<TitleDescription>(db)?;
    let title_cast: Vec<(TitleCast, Person)> = TitleCast::belonging_to(&title)
        .inner_join(people::table)
        .load::<(TitleCast, Person)>(db)?;
    let title_genres: Vec<(TitleGenre, Genre)> = TitleGenre::belonging_to(&title)
        .inner_join(genres::table)
        .load::<(TitleGenre, Genre)>(db)?;
    let title_ratings: Vec<TitleRating> = TitleRating::belonging_to(&title)
        .load::<TitleRating>(db)?;
    let title_images: Vec<TitleImage> = TitleImage::belonging_to(&title)
        .load::<TitleImage>(db)?;
    let title_media: Vec<TitleMedium> = TitleMedium::belonging_to(&title)
        .load::<TitleMedium>(db)?;
    let title_subtitles: Vec<TitleSubtitle> = TitleSubtitle::belonging_to(&title)
        .load::<TitleSubtitle>(db)?;
    Ok(process_title(
        title, title_names, title_descriptions,
        title_cast, title_genres, title_ratings,
        title_images, title_media, title_subtitles,
    ))
}

pub fn load_titles(db: &PgConnection, titles: Vec<Title>) -> QueryResult<Vec<TitleDto>> {
    let title_names: Vec<Vec<TitleName>> = TitleName::belonging_to(&titles)
        .load::<TitleName>(db)?
        .grouped_by(&titles);
    let title_descriptions: Vec<Vec<TitleDescription>> = TitleDescription::belonging_to(&titles)
        .load::<TitleDescription>(db)?
        .grouped_by(&titles);
    let title_cast: Vec<Vec<(TitleCast, Person)>> = TitleCast::belonging_to(&titles)
        .inner_join(people::table)
        .load::<(TitleCast, Person)>(db)?
        .grouped_by(&titles);
    let title_genres: Vec<Vec<(TitleGenre, Genre)>> = TitleGenre::belonging_to(&titles)
        .inner_join(genres::table)
        .load::<(TitleGenre, Genre)>(db)?
        .grouped_by(&titles);
    let title_ratings: Vec<Vec<TitleRating>> = TitleRating::belonging_to(&titles)
        .load::<TitleRating>(db)?
        .grouped_by(&titles);
    let title_images: Vec<Vec<TitleImage>> = TitleImage::belonging_to(&titles)
        .load::<TitleImage>(db)?
        .grouped_by(&titles);
    let title_media: Vec<Vec<TitleMedium>> = TitleMedium::belonging_to(&titles)
        .load::<TitleMedium>(db)?
        .grouped_by(&titles);
    let title_subtitles: Vec<Vec<TitleSubtitle>> = TitleSubtitle::belonging_to(&titles)
        .load::<TitleSubtitle>(db)?
        .grouped_by(&titles);
    Ok(titles.into_iter()
        .zip(title_names)
        .zip(title_descriptions)
        .zip(title_cast)
        .zip(title_genres)
        .zip(title_ratings)
        .zip(title_images)
        .zip(title_media)
        .zip(title_subtitles)
        .map(|tuple| {
            let ((((((((title, akas), descriptions),
                cast), genres), ratings),
                images), media), subtitles) = tuple;
            process_title(title, akas, descriptions, cast, genres, ratings, images, media, subtitles)
        }).collect::<Vec<TitleDto>>())
}

fn process_title(
    title: Title, names: Vec<TitleName>, descriptions: Vec<TitleDescription>,
    cast: Vec<(TitleCast, Person)>, genres: Vec<(TitleGenre, Genre)>, ratings: Vec<TitleRating>,
    images: Vec<TitleImage>, media: Vec<TitleMedium>, subtitles: Vec<TitleSubtitle>
) -> TitleDto {
    TitleDto::of(
        title,
        names.into_iter().map(|src| {
            TitleNameDto::from(src)
        }).collect::<Vec<_>>(),
        descriptions.into_iter().map(|src| {
            TitleDescriptionDto::from(src)
        }).collect::<Vec<_>>(),
        cast.into_iter().map(|src| {
            let (cast, person) = src;
            CastDto::of(cast, person)
        }).collect::<Vec<_>>(),
        genres.into_iter().map(|(_, src)| {
            GenreDto::from(src)
        }).collect::<Vec<_>>(),
        ratings.into_iter().map(|src| {
            RatingDto::from(src)
        }).collect::<Vec<_>>(),
        images.into_iter().map(|src| {
            ImageDto::from(src)
        }).collect::<Vec<_>>(),
        media.into_iter().map(|src| {
            MediaDto::from(src)
        }).collect::<Vec<_>>(),
        subtitles.into_iter().map(|src| {
            SubtitleDto::from(src)
        }).collect::<Vec<_>>(),
    )
}