librmo 0.4.4

A library to manage media files and play them
Documentation 
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

use std::time::Instant;

use crate::entity::album_group::{
    self, ActiveModel as AlbumGroupAModel, Entity as AlbumGroup, Model as AlbumGroupModel,
};
use crate::error::error::QueryError;
use crate::{app::settings::get_db_connection, error::CustomError};
use log::info;
use sea_orm::{ActiveModelTrait, ActiveValue, EntityTrait, ModelTrait, Set};
use sea_query;

use super::albums::{get_albums_by_release_group, get_earliest_album_by_release_group};
use super::get_albums;

pub async fn album_groups_rebuild() -> Result<(), CustomError> {
    let before = Instant::now();
    generate_album_groups().await?;
    validate_album_groups().await?;
    update_album_groups().await?;
    info!(
        "Timing Complete album_groups_rebuild in {:.2?}",
        before.elapsed()
    );
    Ok(())
}

pub async fn generate_album_groups() -> Result<String, CustomError> {
    info!("generate_album_groups");
    let db = get_db_connection().await?;
    let album_group: Vec<AlbumGroupAModel> = match get_albums().await {
        Ok(x) => x
            .into_iter()
            .map(|a| AlbumGroupAModel {
                id: ActiveValue::not_set(),
                mb_release_group_id: ActiveValue::Set(a.mb_release_group_id),
                title: ActiveValue::Set(a.title),
                release_year: ActiveValue::Set(a.original_year),
            })
            .collect(),
        Err(x) => return Err(x),
    };

    for a in album_group.iter() {
        let _x = AlbumGroup::insert(a.clone())
            .on_conflict(
                sea_query::OnConflict::column(album_group::Column::MbReleaseGroupId)
                    .update_column(album_group::Column::ReleaseYear)
                    .to_owned(),
            )
            .exec(&db)
            .await;
    }

    Ok("Ok".to_string())
}

pub async fn validate_album_groups() -> Result<(), CustomError> {
    let db = get_db_connection().await?;
    let album_groups = match get_all_album_group().await {
        Ok(x) => x,
        Err(x) => return Err(x),
    };

    for a in album_groups.iter() {
        let albums = match get_albums_by_release_group(a.mb_release_group_id.clone()).await {
            Ok(x) => x,
            Err(x) => return Err(x),
        };
        if albums.len() < 1 {
            a.clone().delete(&db).await?;
        }
    }
    Ok(())
}

pub async fn update_album_groups() -> Result<(), CustomError> {
    let db = get_db_connection().await?;
    let album_groups = match get_all_album_group().await {
        Ok(x) => x,
        Err(x) => return Err(x),
    };

    for a in album_groups.iter() {
        let albums = match get_earliest_album_by_release_group(a.mb_release_group_id.clone()).await
        {
            Ok(x) => x,
            Err(x) => return Err(x),
        };
        let mut album_group: AlbumGroupAModel = a.clone().into();
        album_group.release_year = Set(albums.original_year.to_owned());
        let _album_group: AlbumGroupModel = album_group.update(&db).await?;
    }

    Ok(())
}

pub async fn get_all_album_group() -> Result<Vec<AlbumGroupModel>, CustomError> {
    let db = get_db_connection().await?;
    let album_groups = match AlbumGroup::find().all(&db).await {
        Ok(x) => x,
        Err(_) => {
            return Err(CustomError::QueryErr(QueryError {
                query: format!("Failed to find get_all_album_group"),
            }))
        }
    };

    Ok(album_groups)
}