rlru 0.1.9

Rocket League replay uploader
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
147
148
149
150
151
152
153
154
155
156
157
158

#[derive(Clone, Debug, PartialEq)]
pub struct AppSummary {
    pub config_path: String,
    pub accounts: Vec<AccountSummary>,
    pub upload_destinations: Vec<UploadDestinationSummary>,
    pub auto_upload: bool,
    pub upload_on_launch: bool,
    pub no_upload_while_connected: bool,
    pub selected_account: Option<String>,
    pub selected_upload_destination: Option<String>,
    pub auto_upload_interval_minutes: u64,
    pub auto_upload_jitter_minutes: u64,
    pub interval: String,
    pub jitter: String,
    pub status: String,
}

impl AppSummary {
    pub fn account_count(&self) -> usize {
        self.accounts.len()
    }

    pub fn upload_destination_count(&self) -> usize {
        self.upload_destinations.len()
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct AccountSummary {
    pub id: u32,
    pub name: String,
    pub platform: String,
    pub sync_enabled: bool,
    pub selected: bool,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AccountFormData {
    pub name: String,
    pub platform: String,
    pub sync_enabled: bool,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct OverviewConfigFormData {
    pub auto_upload_interval_minutes: String,
    pub auto_upload_jitter_minutes: String,
    pub upload_on_launch: bool,
    pub no_upload_while_connected: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub struct UploadDestinationSummary {
    pub name: String,
    pub url: String,
    pub upload_enabled: bool,
    pub automatic: bool,
    pub auth: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HistoryRow {
    pub account: String,
    pub match_id: String,
    pub timestamp: String,
    pub map_name: String,
    pub playlist: String,
    pub score: String,
    pub upload_destinations: Vec<HistoryUploadDestination>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HistoryUploadDestination {
    pub target_name: String,
    pub state: String,
    pub uploaded: bool,
    pub upload_enabled: bool,
    pub location: Option<String>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ReplayUploadRequest {
    pub target_name: String,
    pub match_id: String,
    pub reason: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct SyncRunState {
    pub running: bool,
    pub last_started_at: Option<String>,
    pub last_completed_at: Option<String>,
    pub last_summary: Option<BackfillSummary>,
    pub last_error: Option<String>,
}

impl SyncRunState {
    pub fn started(&self, started_at: String) -> Self {
        Self {
            running: true,
            last_started_at: Some(started_at),
            last_completed_at: self.last_completed_at.clone(),
            last_summary: self.last_summary.clone(),
            last_error: None,
        }
    }

    pub fn completed(&self, completed_at: String, summary: BackfillSummary) -> Self {
        Self {
            running: false,
            last_started_at: self.last_started_at.clone(),
            last_completed_at: Some(completed_at),
            last_summary: Some(summary),
            last_error: None,
        }
    }

    pub fn failed(&self, completed_at: String, error: String) -> Self {
        Self {
            running: false,
            last_started_at: self.last_started_at.clone(),
            last_completed_at: Some(completed_at),
            last_summary: self.last_summary.clone(),
            last_error: Some(error),
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BackfillSummary {
    pub uploaded: usize,
    pub duplicates: usize,
    pub cached: usize,
    pub failed: usize,
    pub failed_match_ids: Vec<String>,
    pub failed_uploads: Vec<ReplayUploadRequest>,
}

impl From<crate::sync::SyncSummary> for BackfillSummary {
    fn from(summary: crate::sync::SyncSummary) -> Self {
        Self {
            uploaded: summary.uploaded,
            duplicates: summary.duplicates,
            cached: summary.cached,
            failed: summary.failed,
            failed_match_ids: summary.failed_match_ids,
            failed_uploads: summary
                .failed_uploads
                .into_iter()
                .map(|failed| ReplayUploadRequest {
                    target_name: failed.target_name,
                    match_id: failed.match_id,
                    reason: Some(failed.reason),
                })
                .collect(),
        }
    }
}