songrec 0.6.7

An open-source Shazam client for Linux, written in Rust.
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

mod imp;

use crate::utils::csv_song_history::{Song, SongHistoryRecord};

glib::wrapper! {
    pub struct HistoryEntry(ObjectSubclass<imp::HistoryEntry>);
}

impl HistoryEntry {
    pub fn new(song: &SongHistoryRecord) -> Self {
        glib::Object::builder()
            .property("song_name", song.song_name.clone())
            .property("album", song.album.clone())
            .property("track_key", song.track_key.clone())
            .property("release_year", song.release_year.clone())
            .property("genre", song.genre.clone())
            .property("recognition_date", song.recognition_date.clone())
            .build()

        /*
            let mut builder = builder.property("song_name", song.song_name);
            if let Some(album) = song.album {
                builder = builder.property("album", album);
            }
            if let Some(track_key) = song.track_key {
                builder = builder.property("track_key", track_key);
            }
            if let Some(release_year) = song.release_year {
                builder = builder.property("release_year", release_year);
            }
            if let Some(genre) = song.genre {
                builder = builder.property("genre", genre);
            }
            builder = builder.property("recognition_date", song.recognition_date);
        */
    }

    pub fn get_song_history_record(&self) -> SongHistoryRecord {
        SongHistoryRecord {
            song_name: self.song_name(),
            album: self.album(),
            track_key: self.track_key(),
            release_year: self.release_year(),
            genre: self.genre(),
            recognition_date: self.recognition_date(),
        }
    }

    pub fn get_song(&self) -> Song {
        Song {
            song_name: self.song_name(),
            album: match self.album() {
                Some(val) => {
                    if &val == "" {
                        None
                    } else {
                        Some(val)
                    }
                }
                None => None,
            },
            track_key: match self.track_key() {
                Some(val) => {
                    if &val == "" {
                        None
                    } else {
                        Some(val)
                    }
                }
                None => None,
            },
            release_year: match self.release_year() {
                Some(val) => {
                    if &val == "" {
                        None
                    } else {
                        Some(val)
                    }
                }
                None => None,
            },
            genre: match self.genre() {
                Some(val) => {
                    if &val == "" {
                        None
                    } else {
                        Some(val)
                    }
                }
                None => None,
            },
        }
    }
}