snowchains 0.7.0

Tools for online programming contests
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

use serde::Serialize;
use snowchains_core::web::{
    Atcoder, AtcoderParticipateCredentials, AtcoderParticipateTarget, CookieStorage, Participate,
    PlatformKind,
};
use std::{
    cell::RefCell,
    io::{BufRead, Write},
};
use structopt::StructOpt;
use strum::VariantNames as _;
use termcolor::WriteColor;

#[derive(StructOpt, Debug)]
pub struct OptParticipate {
    /// Prints the result as JSON
    #[structopt(long)]
    pub json: bool,

    /// Coloring
    #[structopt(
        long,
        possible_values(crate::ColorChoice::VARIANTS),
        default_value("auto")
    )]
    pub color: crate::ColorChoice,

    /// Target platform
    #[structopt(possible_value("atcoder"))]
    pub service: PlatformKind,

    /// Contest ID
    pub contest: String,
}

#[derive(Clone, Copy, Debug, Serialize)]
struct Outcome {
    kind: snowchains_core::web::ParticipateOutcome,
}

impl Outcome {
    fn to_json(self) -> String {
        serde_json::to_string(&self).expect("should not fail")
    }

    fn message(self) -> &'static str {
        self.kind.message()
    }
}

pub(crate) fn run(
    opt: OptParticipate,
    ctx: crate::Context<impl BufRead, impl Write, impl WriteColor>,
) -> anyhow::Result<()> {
    let OptParticipate {
        json,
        color: _,
        service: _,
        contest,
    } = opt;

    let crate::Context { cwd: _, mut shell } = ctx;

    let cookie_storage = CookieStorage::with_jsonl(crate::web::credentials::cookie_store_path()?)?;
    let timeout = Some(crate::web::SESSION_TIMEOUT);

    let kind = {
        let shell = RefCell::new(&mut shell);

        let target = AtcoderParticipateTarget { contest };

        let credentials = AtcoderParticipateCredentials {
            username_and_password: &mut crate::web::credentials::atcoder_username_and_password(
                &shell,
            ),
        };

        Atcoder::exec(Participate {
            target,
            credentials,
            cookie_storage,
            timeout,
            shell: &shell,
        })?
    };

    let outcome = Outcome { kind };

    if json {
        writeln!(shell.stdout, "{}", outcome.to_json())
    } else {
        writeln!(shell.stdout, "{}", outcome.message())
    }?;
    shell.stdout.flush()?;
    Ok(())
}