n4n5 1.6.4

n4n5's utility crate
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
138
139
140
141
142
143
144
145
146

//! To see all subcommands, run:
//!
//! ```shell
//! n4n5 music
//! ```
//!

use std::{path::PathBuf, process::Command};

use clap::{ArgAction, Subcommand};
use music_exporter::{MusicExporter, PlatformType};
use serde::{Deserialize, Serialize};
use tokio::runtime::Runtime;

use crate::{
    config::Config,
    config_path,
    errors::GeneralError,
    utils::{input_no, input_path},
};

/// Movies configuration
#[derive(Deserialize, Serialize, Default)]
pub struct MusicCliCommand {
    /// Path to the movies file
    pub music_file: Option<String>,

    /// env path
    pub env_path: Option<String>,
}

/// Music subcommands
#[derive(Subcommand, Debug, Clone)]
pub enum MusicSubcommand {
    /// Save music
    Sync,

    /// Open music file
    Open {
        /// Print the path only
        #[arg(short = 'p', long = "path", action = ArgAction::SetTrue)]
        show_path_only: bool,
    },
}

impl MusicSubcommand {
    /// invoke the subcommand
    /// # Errors
    /// Error if error in subcommand
    pub fn invoke(self, config: &mut Config) -> Result<(), GeneralError> {
        match self {
            MusicSubcommand::Sync => MusicCliCommand::sync_music(config, None),
            MusicSubcommand::Open { show_path_only } => {
                MusicCliCommand::open_music_file(config, show_path_only)
            }
        }
    }
}

impl MusicCliCommand {
    /// Get the music file path
    /// # Errors
    /// Fails if the file cannot be found
    pub fn get_music_file_path(config: &mut Config) -> Result<PathBuf, GeneralError> {
        let path = config_path!(
            config,
            music,
            MusicCliCommand,
            music_file,
            "the file for music"
        );
        Ok(path)
    }

    /// open music file
    /// # Errors
    /// Fails if the file cannot be opened
    pub fn open_music_file(config: &mut Config, print_path: bool) -> Result<(), GeneralError> {
        let music_file = MusicCliCommand::get_music_file_path(config)?;
        if print_path {
            println!("{}", music_file.display());
            return Ok(());
        }
        println!("Opening music file at {}", music_file.display());
        Command::new("vi").arg(&music_file).spawn()?.wait()?;
        Ok(())
    }

    /// Sync music
    /// # Errors
    /// Fails if the music file cannot be found
    pub fn sync_music(config: &mut Config, sync_all: Option<bool>) -> Result<(), GeneralError> {
        let rt = Runtime::new()?;

        let music_file = MusicCliCommand::get_music_file_path(config)?;
        let env_path = config_path!(config, music, MusicCliCommand, env_path, "the env path");

        println!("music file: '{}'", music_file.display());
        if let Some(true) = sync_all {
            let platforms = vec![
                PlatformType::Deezer,
                PlatformType::Spotify,
                PlatformType::Youtube,
            ];
            rt.block_on(async {
                env_logger::builder()
                    .filter_level(log::LevelFilter::Info)
                    .format_target(false)
                    .format_timestamp(None)
                    .init();
                MusicExporter::new_from_vars(music_file, Some(env_path), &platforms)
                    .run_main()
                    .await
                    .map_err(|e| ("Error with music-exporter", e))
            })?;
        } else {
            for platform in [
                PlatformType::Deezer,
                PlatformType::Spotify,
                PlatformType::Youtube,
            ] {
                if input_no(format!("Should we sync platform: {platform}?"))? {
                    println!("Skipping platform: {platform}");
                    continue;
                }
                rt.block_on(async {
                    env_logger::builder()
                        .filter_level(log::LevelFilter::Info)
                        .format_target(false)
                        .format_timestamp(None)
                        .init();
                    MusicExporter::new_from_vars(
                        music_file.clone(),
                        Some(env_path.clone()),
                        &[platform],
                    )
                    .run_main()
                    .await
                    .map_err(|e| ("Error with music-exporter", e))
                })?;
            }
        }

        Ok(())
    }
}