lcode 0.10.0

An application of terminal write leetcode.一个终端刷力扣的应用
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

use leetcode_api::{
    glob_leetcode,
    leetcode::{IdSlug, question::qs_detail::Question, resps::run_res::*},
};
use tracing::error;

use crate::{app::inner::App, mytui::myevent::UserEvent};

impl App<'_> {
    pub fn get_qs_detail(&self, idslug: IdSlug, force: bool) {
        let eve_tx = self.events.tx.clone();
        tokio::spawn(async move {
            let qs = glob_leetcode()
                .await
                .get_qs_detail(idslug, force, true)
                .await
                .unwrap_or_else(Question::new_with_info);
            eve_tx
                .send(UserEvent::GetQsDone(Box::new(qs)))
                .expect("get_qs_detail send failed");
        });
    }
    pub async fn get_qs_done(&mut self, qs: Question) {
        match self.get_code(&qs).await {
            // if error, don't update question info
            Ok(()) => self.cur_qs = qs,
            Err(err) => error!("{}", err),
        };
        self.render();
    }
    pub fn menu_button_trig(&mut self) -> bool {
        self.edit.button.active_cur_but();
        match self.edit.button.selected {
            0 => self.test_code(),
            1 => self.submit_code(),
            _ => false,
        }
    }
    pub fn submit_code(&mut self) -> bool {
        let id: u32 = self
            .cur_qs
            .question_id
            .parse()
            .unwrap_or_default();

        // avoid repeated requests
        if self.edit.button.submitting {
            return false;
        }

        self.edit.button.done();
        let eve_tx = self.events.tx.clone();
        tokio::spawn(async move {
            // min id is 1
            let runres = if id > 0 {
                match glob_leetcode()
                    .await
                    .submit_code(IdSlug::Id(id))
                    .await
                {
                    Ok((_, it)) => it,
                    Err(err) => RunResultBuild::default()
                        .set_status_msg(err.to_string())
                        .build(),
                }
            }
            else {
                RunResultBuild::default()
                    .set_status_msg("id lower 1".to_owned())
                    .build()
            };

            eve_tx
                .send(UserEvent::SubmitDone(Box::new(runres)))
                .expect("submit_code send failed");
        });
        false
    }

    pub fn test_code(&mut self) -> bool {
        let id = self
            .cur_qs
            .question_id
            .parse()
            .unwrap_or_default();

        // avoid repeated requests
        if self.edit.button.submitting {
            return false;
        }
        self.edit.button.start();

        let eve_tx = self.events.tx.clone();
        tokio::spawn(async move {
            // min id is 1
            let runres = if id > 0 {
                match glob_leetcode()
                    .await
                    .test_code(IdSlug::Id(id))
                    .await
                {
                    Ok((_, it)) => it,
                    Err(err) => RunResultBuild::default()
                        .set_status_msg(err.to_string())
                        .build(),
                }
            }
            else {
                RunResult::default()
            };
            eve_tx
                .send(UserEvent::TestDone(Box::new(runres)))
                .expect("test_code send failed");
        });
        false
    }
    pub fn test_done(&mut self, res: RunResult) {
        self.edit.test.content = res;

        self.edit.test.open();
        self.edit.submit.close();
        self.edit.button.close();

        self.edit.button.test_done();
        self.render();
    }
    pub fn submit_done(&mut self, res: RunResult) {
        self.edit.submit.need_add_test_case = !res.last_testcase.is_empty();
        self.edit.submit.content = res;

        self.edit.submit.open();
        self.edit.test.close();
        self.edit.button.close();

        self.edit.button.submit_done();
        self.render();
    }
}