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
|
use colored::Colorize;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum DownloadError {
#[error("Network request failed: {0}")]
NetworkError(#[from] reqwest::Error),
#[error("Failed to parse JSON response: {0}")]
JsonParseError(#[from] serde_json::Error),
#[error("Failed to decode base64 manifest: {0}")]
Base64DecodeError(#[from] base64::DecodeError),
#[error("Failed to parse XML manifest: {0}")]
XmlParseError(String),
#[error("Track not found: {0}")]
TrackNotFound(String),
#[error("Album not found: {0}")]
AlbumNotFound(String),
#[error("Artist not found: {0}")]
ArtistNotFound(String),
#[error("Playlist not found: {0}")]
PlaylistNotFound(String),
#[error("No download URL available for the requested quality")]
NoDownloadUrl,
#[error("Rate limited. Please wait before making more requests")]
RateLimited,
#[error("IO error: {0}")]
IoError(#[from] std::io::Error),
#[error("Download failed: {0}")]
DownloadFailed(String),
#[error("Segment download failed: {0}")]
SegmentDownloadFailed(String),
#[error("CSV parsing error: {0}")]
CsvError(String),
#[error("Service unavailable: {0}")]
ServiceUnavailable(String),
}
impl From<csv::Error> for DownloadError {
fn from(err: csv::Error) -> Self {
DownloadError::CsvError(err.to_string())
}
}
impl DownloadError {
pub fn pretty_print(&self) {
let error_type = match self {
DownloadError::NetworkError(_) => "Network Error",
DownloadError::JsonParseError(_) => "Parse Error",
DownloadError::Base64DecodeError(_) => "Decode Error",
DownloadError::XmlParseError(_) => "XML Error",
DownloadError::TrackNotFound(_) => "Not Found",
DownloadError::AlbumNotFound(_) => "Not Found",
DownloadError::ArtistNotFound(_) => "Not Found",
DownloadError::PlaylistNotFound(_) => "Not Found",
DownloadError::NoDownloadUrl => "Download Error",
DownloadError::RateLimited => "Rate Limit",
DownloadError::IoError(_) => "IO Error",
DownloadError::DownloadFailed(_) => "Download Error",
DownloadError::SegmentDownloadFailed(_) => "Download Error",
DownloadError::CsvError(_) => "CSV Error",
DownloadError::ServiceUnavailable(_) => "Service Error",
};
eprintln!();
eprintln!(
"{}",
"╭─────────────────────────────────────╮".bright_red()
);
eprintln!(
"{} {} {:>24} {}",
"│".bright_red(),
error_type
.red()
.bold(),
"",
"│".bright_red()
);
eprintln!(
"{}",
"├─────────────────────────────────────┤".bright_red()
);
eprintln!(
"{} {} {}",
"│".bright_red(),
self.to_string()
.white(),
"│".bright_red()
);
eprintln!(
"{}",
"╰─────────────────────────────────────╯".bright_red()
);
eprintln!();
}
}
pub type Result<T> = std::result::Result<T, DownloadError>;
|
