atac 0.22.1

Arguably a Terminal API Client. Feature-full, free, open-source, offline and account-less.
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

use std::fs;
use std::sync::Arc;
use anyhow::anyhow;
use indexmap::IndexMap;
use parking_lot::RwLock;
use serde::Deserialize;
use thiserror::Error;
use uuid::Uuid;
use crate::app::app::App;
use crate::cli::args::ARGS;
use crate::cli::commands::import::PostmanEnvImport;
use crate::models::environment::Environment;

#[derive(Error, Debug)]
enum ImportPostmanEnvironmentError {
    #[error("Could not read Postman environment file\n\t{0}")]
    CouldNotReadFile(String),
    #[error("Could not parse Postman environment\n\t{0}")]
    CouldNotParsePostmanEnvironment(String),
}

#[derive(Deserialize)]
struct PostmanEnv {
    #[serde(rename = "id")]
    pub _id: Uuid,
    pub name: String,
    pub values: Vec<PostmanEnvVariable>,
    pub _postman_variable_scope: String,
    pub _postman_exported_at: String,
    pub _postman_exported_using: String,
}

#[derive(Deserialize)]
struct PostmanEnvVariable {
    pub key: String,
    pub value: String,
    #[serde(rename = "type")]
    pub _type: String,
    pub enabled: bool
}


impl App<'_> {
    pub fn import_postman_environment(&mut self, postman_env_import: &PostmanEnvImport) -> anyhow::Result<()> {
        let path_buf = &postman_env_import.import_path;

        println!("Parsing Postman environment");

        // Read the file content
        let file_content = match fs::read_to_string(path_buf) {
            Ok(content) => content,
            Err(e) => {
                return Err(anyhow!(ImportPostmanEnvironmentError::CouldNotReadFile(e.to_string())));
            }
        };

        let postman_environment = match serde_yaml::from_str::<PostmanEnv>(&file_content) {
            Ok(postman_environment) => postman_environment,
            Err(e) => return Err(anyhow!(ImportPostmanEnvironmentError::CouldNotParsePostmanEnvironment(e.to_string()))),
        };

        println!("Postman environment name: {}", postman_environment.name);

        let filename = format!(".env.{}", postman_environment.name.to_lowercase().replace(" ", "_"));
        let path = ARGS.directory
            .as_ref()
            .unwrap()
            .join(filename);

        let mut env = Environment {
            name: postman_environment.name,
            values: IndexMap::new(),
            path
        };

        for env_variable in postman_environment.values {
            if !postman_env_import.use_disabled && !env_variable.enabled {
                continue;
            }

            let key = match postman_env_import.force_uppercase_keys {
                true => env_variable.key.to_uppercase(),
                false => env_variable.key.clone()
            };

            env.values.insert(
                key,
                env_variable.value.clone(),
            );
        }

        let env_count = self.environments.len();
        self.environments.push(Arc::new(RwLock::new(env)));

        self.save_environment_to_file(env_count);

        Ok(())
    }
}