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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::app::settings::get_db_connection;
use crate::entity::{
    media::Entity as MediaEntity,
    music::Entity as MusicEntity,
    report::{self, ActiveModel as ReportAModel, Column as ReportColumn, Entity as ReportEntity},
};
use crate::error::error::CustomError;
use log::info;
use sea_orm::{
    ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, Iterable, QueryFilter,
};
use serde::Serialize;
use std::sync::mpsc::Sender;
use std::time::Instant;

#[derive(Serialize, Debug)]
pub struct ReportList {
    pub report_type: String,
    pub path: String,
}

pub struct MusicValidator {
    pub sender: Option<Sender<String>>,
}

impl MusicValidator {
    pub fn new(tx: Option<Sender<String>>) -> Self {
        Self { sender: tx }
    }

    pub async fn insert_report(
        reports: Vec<ReportAModel>,
        db: &DatabaseConnection,
    ) -> Result<String, CustomError> {
        for chunk in reports.chunks(
            (u16::MAX / (<report::Entity as EntityTrait>::Column::iter().count() as u16 * 5))
                as usize,
        ) {
            for individual_report in chunk.iter() {
                individual_report.clone().insert(db).await?;
            }
        }

        Ok("Ok".to_string())
    }

    pub async fn get_reports() -> Result<Vec<ReportList>, CustomError> {
        let _before = Instant::now();
        let mut mapped_media_reports: Vec<_> = get_media_reports().await?;
        let mut mapped_music_reports: Vec<ReportList> = get_music_reports().await?;
        mapped_media_reports.append(&mut mapped_music_reports);
        println!("Timing Complete get_reports in {:.2?}", _before.elapsed());
        Ok(mapped_media_reports)
    }
}

#[deprecated]
#[allow(dead_code)]
pub async fn get_reports() -> Result<Vec<ReportList>, CustomError> {
    //info!("Running get_reports");
    let _before = Instant::now();
    let mut mapped_media_reports: Vec<_> = get_media_reports().await?;
    let mut mapped_music_reports: Vec<ReportList> = get_music_reports().await?;
    mapped_media_reports.append(&mut mapped_music_reports);
    println!("Timing Complete get_reports in {:.2?}", _before.elapsed());
    Ok(mapped_media_reports)
}

async fn get_media_reports() -> Result<Vec<ReportList>, CustomError> {
    let before = Instant::now();
    let db = get_db_connection().await?;

    let reports = report::Entity::find()
        .find_also_related(MediaEntity)
        .all(&db)
        .await?;
    let filtered_reports: Vec<_> = reports.into_iter().filter(|x| x.1.is_some()).collect();
    let mapped_media_reports: Vec<_> = filtered_reports
        .iter()
        .map(|x| ReportList {
            report_type: x.0.report_type.to_owned(),
            path: x.1.clone().unwrap().path,
        })
        .collect();
    info!(
        "Timing Complete get_media_reports in {:.2?}",
        before.elapsed()
    );
    Ok(mapped_media_reports)
}

async fn get_music_reports() -> Result<Vec<ReportList>, CustomError> {
    let before = Instant::now();
    let db = get_db_connection().await?;

    let reports = report::Entity::find()
        .find_also_related(MusicEntity)
        .all(&db)
        .await?;

    let filtered_reports: Vec<_> = reports.into_iter().filter(|x| x.1.is_some()).collect();
    ////info!("{:?}", filtered_reports);
    let mut mapped_music_reports: Vec<ReportList> = Vec::new();
    for f in filtered_reports.iter() {
        //let media_path = f.0.clone().media_id.unwrap_or_else(continue);
        let media_path = get_media_path(&db, f.clone().1.unwrap().clone().media_id).await?;
        mapped_music_reports.push(ReportList {
            report_type: f.0.clone().report_type,
            path: media_path,
        });
    }
    info!(
        "Timing Complete get_music_reports in {:.2?}",
        before.elapsed()
    );
    Ok(mapped_music_reports)
}

async fn get_media_path(db: &DatabaseConnection, media_id: i32) -> Result<String, CustomError> {
    //info!("{}",media_id);
    let one = MediaEntity::find_by_id(media_id).one(db).await?;
    Ok(one.unwrap().path.to_string())
}

#[allow(dead_code)]
pub async fn delete_reports() -> Result<String, CustomError> {
    let db = get_db_connection().await?;
    ReportEntity::delete_many()
        .filter(ReportColumn::Id.is_not_null())
        .exec(&db)
        .await?;
    Ok("Ok".to_string())
}
#[allow(dead_code)]
pub async fn run_reports() -> Result<String, CustomError> {
    todo!()
}