pants-store 0.1.0

A password manager
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

use std::error::Error;

use crate::{
    cli::{CLICommands, EntryStyle},
    errors::ConversionError,
    schema::Schema,
    store::Store,
};

#[derive(Debug, Clone)]
pub enum Instructions {
    Interaction(Interaction),
    Commands(Commands),
}

#[derive(Debug, Clone)]
pub enum Command {
    Read { key: String },
    Update { key: String, value: Store },
    Delete { key: String },
}

#[derive(Debug, Clone)]
pub enum Interaction {
    List,
    Backup,
    Rotate,
}

#[derive(Debug, Clone)]
pub struct Commands {
    pub commands: Vec<Command>,
}

impl IntoIterator for Commands {
    type Item = Command;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.commands.into_iter()
    }
}

impl Default for Commands {
    fn default() -> Self {
        Self::new()
    }
}

impl Commands {
    pub fn new() -> Self {
        Self { commands: vec![] }
    }

    pub fn push(&mut self, command: Command) {
        self.commands.push(command);
    }

    // pub fn add(mut self, command: Command) -> Self {
    //     self.commands.push(command);
    //     self
    // }
}

impl Instructions {
    fn handle_new(name: String, schema: Schema, style: &str) -> Result<Self, Box<dyn Error>> {
        match schema.get(&name) {
            Some(_) => Err(Box::new(ConversionError::Exists)),
            None => {
                let value = Store::prompt(style)?;
                let commands: Commands = vec![Command::Update { key: name, value }].into();
                Ok(commands.into())
            }
        }
    }
    pub fn from_commands(commands: CLICommands, schema: Schema) -> Result<Self, Box<dyn Error>> {
        match commands {
            CLICommands::New { style } => match style {
                EntryStyle::Password { name } => Self::handle_new(name, schema, "password"),
                EntryStyle::UsernamePassword { name } => {
                    Self::handle_new(name, schema, "username-password")
                }
            },
            CLICommands::Get { key } => {
                let commands: Commands = vec![Command::Read { key }].into();
                Ok(commands.into())
            }
            CLICommands::Update { key } => match schema.get(&key) {
                None => Err(Box::new(ConversionError::NoEntry)),
                Some(value) => {
                    let value = Store::prompt(value)?;
                    let commands: Commands = vec![Command::Update { key, value }].into();
                    Ok(commands.into())
                }
            },
            CLICommands::Delete { key } => {
                let commands: Commands = vec![Command::Delete { key }].into();
                Ok(commands.into())
            }
            CLICommands::List => Ok(Interaction::List.into()),
            CLICommands::Backup => Ok(Interaction::Backup.into()),
            CLICommands::Rotate => Ok(Interaction::Rotate.into()),
            _ => todo!(),
        }
    }
}

impl From<Vec<Command>> for Commands {
    fn from(value: Vec<Command>) -> Self {
        Self { commands: value }
    }
}

impl From<Commands> for Instructions {
    fn from(value: Commands) -> Self {
        Instructions::Commands(value)
    }
}

impl From<Interaction> for Instructions {
    fn from(value: Interaction) -> Self {
        Instructions::Interaction(value)
    }
}