sndr 0.3.0

Easily and securely share files from the command line. A fully featured Send client (formerly ffsend, rebranded by tarnover).
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

use chrono::Duration;
use clap::{Arg, ArgMatches};
use failure::Fail;
use ffsend_api::api::Version as ApiVersion;
use ffsend_api::config::expiry_max;

use super::{CmdArg, CmdArgFlag, CmdArgOption};
use crate::cmd::matcher::MainMatcher;
use crate::util::{
    format_duration, highlight, parse_duration, prompt_yes, quit, quit_error, ErrorHints,
};

/// The download limit argument.
pub struct ArgExpiryTime {}

impl ArgExpiryTime {
    pub fn value_checked<'a>(
        matches: &ArgMatches<'a>,
        main_matcher: &MainMatcher,
        api_version: ApiVersion,
        auth: bool,
    ) -> Option<usize> {
        // Get the expiry time value
        let mut expiry = Self::value(matches)?;

        // Get expiry time, return if allowed or when forcing
        let max = *expiry_max(api_version, auth).into_iter().max().unwrap();
        if expiry <= max || main_matcher.force() {
            return Some(expiry);
        }

        // Define function to format seconds
        let format_secs = |secs: usize| format_duration(Duration::seconds(secs as i64));

        // Prompt the user the specified expiry time is invalid
        eprintln!(
            "The expiry time must equal to or less than: {}",
            format_secs(max),
        );
        if auth {
            eprintln!("Use '{}' to force", highlight("--force"));
        } else {
            eprintln!(
                "Use '{}' to force, authenticate for higher limits",
                highlight("--force")
            );
        }

        // Ask to use maximum expiry time instead, quit if user cancelled
        if !prompt_yes(
            &format!(
                "Would you like to set expiry time to {} instead?",
                format_secs(max),
            ),
            None,
            main_matcher,
        ) {
            quit();
        }
        expiry = max;

        Some(expiry)
    }
}

impl CmdArg for ArgExpiryTime {
    fn name() -> &'static str {
        "expiry-time"
    }

    fn build<'b, 'c>() -> Arg<'b, 'c> {
        Arg::with_name("expiry-time")
            .long("expiry-time")
            .short("e")
            .alias("expire")
            .alias("expiry")
            .value_name("TIME")
            .env("SNDR_EXPIRY_TIME")
            .help("The file expiry time")
    }
}

impl CmdArgFlag for ArgExpiryTime {}

impl<'a> CmdArgOption<'a> for ArgExpiryTime {
    type Value = Option<usize>;

    fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
        Self::value_raw(matches).map(|t| match parse_duration(t) {
            Ok(seconds) => seconds,
            Err(err) => quit_error(
                err.context("specified invalid file expiry time"),
                ErrorHints::default(),
            ),
        })
    }
}