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

use config::ConfigError;
use lofty::error::LoftyError;
use thiserror::Error;
use sea_orm::DbErr;
use sea_orm::RuntimeErr;
use std::{error::Error, fmt};
use image::ImageError;
use serde;


// A custom error type that represents all possible in our command
#[derive(Debug, Error)]
pub enum CustomError {
    #[error("Failed to read file: {0}")]
    Io(#[from] std::io::Error),
    #[error("File is not valid utf8: {0}")]
    Utf8(#[from] std::string::FromUtf8Error),
    #[error("DB Error: {0}")]
    DBErr(#[from] DbErr),
    #[error("Tag not found: {0}")]
    TagErr(#[from] TagError),
    #[error("SQL Error: {0}")]
    SQLErr(#[from] RuntimeErr),
    #[error("Image Error: {0}")]
    ImgErr(#[from] ImageError),
    #[error("Config Error: {0}")]
    ConfigErr(#[from] ConfigError),
    #[error("Tag error: {0}")]
    TagError(#[from] LoftyError),
    #[error("Query error: {0}")]
    QueryErr(#[from] QueryError),


}

#[derive(Debug, Clone)]
pub struct QueryError{
  pub query: String,
}

impl Error for QueryError {}

impl fmt::Display for QueryError {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
      write!(f, "Query failed: {}", self.query)
  }
}

#[derive(Debug, Clone)]
pub struct TagError{
  pub tag_name: String,
}

impl Error for TagError {}

impl fmt::Display for TagError {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
      write!(f, "Tag not found")
  }
}


// we must also implement serde::Serialize
impl serde::Serialize for CustomError {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::ser::Serializer,
  {
    serializer.serialize_str(self.to_string().as_ref())
  }
}
#[derive(Clone, serde::Serialize)]
pub struct Payload {
  pub message: String,
}