mawsitsit 0.1.12 → 0.1.14

data/ext/mawsitsit/src/parser/parser.rs

@@ -1,9 +1,10 @@
-use serde_json::Value;
+use serde_json::{Map, Value};
 use async_recursion::async_recursion;
 use serde::{Serialize, Deserialize};
 use serde_magnus::serialize;
 use magnus::Value as RubyValue;
-use crate::parser::manipulators::{like_enum, like_fetch, like_lambda, like_ashby};
+use crate::parser::manipulators::{like_enum, like_fetch, like_lambda, like_ashby, like_lever, int_to_dt};
+use super::{manipulators::EnumValue, utils::helpers::{remove_nulls, remove_nulls_in_place, vec_str}};
 
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -15,6 +16,9 @@ impl JsonValue {
     pub fn new(value: serde_json::Value) -> JsonValue {
         JsonValue { value }
     }
+    pub fn null() -> JsonValue {
+        JsonValue { value: serde_json::Value::Null }
+    }
     pub fn get_by_path(&self, path: &str) -> Option<&Value> {
         let mut current = &self.value;
         for key in path.split('.') {
@@ -58,6 +62,15 @@ impl JsonValue {
         let ruby : RubyValue = serialize(&self.value).unwrap();
         return ruby;
     }
+    pub fn no_null(&self) -> JsonValue{
+        JsonValue {
+            value: remove_nulls(&self.value),
+        }
+    }
+    pub fn drop_nulls(&mut self) {
+        remove_nulls_in_place(&mut self.value);
+    }
+    
 
 }
 
@@ -117,23 +130,100 @@ impl JsonToJson {
                         let mut task_res = serde_json::Value::Null;
                         match task.get(0) {
                             Some(&"enum") => {
-                                task_res =
-                                    like_enum(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap());
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => {
+                                                match value {
+                                                    serde_json::Value::String(value_str) => like_enum(EnumValue::Str(value_str.to_string()), todo),
+                                                    serde_json::Value::Bool(value_bool) => like_enum(EnumValue::Bool(*value_bool), todo),
+                                                    _ => serde_json::Value::Null,
+                                                }
+                                            }
+
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }                
                             }
                             Some(&"fetch") => {
-                                task_res = like_fetch(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap()).await;
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => match value.as_str() {
+                                                Some(value) => like_fetch(value, todo).await,
+                                                None => serde_json::Value::Null
+                                            }
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
                             }
                             Some(&"ashby") => {
-                                task_res = like_ashby(&reference.get_by_path(bin[0]).expect("Path not found in reference"));
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => like_ashby(value),
+                                    None => serde_json::Value::Null
+                                }
+                            
+                            }
+                            Some(&"lever") => {
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => like_lever(value),
+                                    None => serde_json::Value::Null
+                                }
                             }
                             Some(&"lambda") => {
-                                task_res = like_lambda(&reference.get_by_path(bin[0]).expect("Path not found in reference").to_string(), task.get(1).unwrap());
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match task.get(1) {
+                                            Some(todo) => match value.as_str() {
+                                                Some(value) => like_lambda(value, todo),
+                                                None => serde_json::Value::Null
+                                            }
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
+                                
+                            }
+                            Some(&"int_to_datetime") => {
+                                task_res = match reference.get_by_path(bin[0]) {
+                                    Some(value) => {
+                                        match value.as_i64() {
+                                            Some(value) => int_to_dt(value),
+                                            None => serde_json::Value::Null
+                                        }
+                                    },
+                                    None => serde_json::Value::Null
+                                }
+                                
+                            }
+                            Some(&"flatten") => {
+                                task_res = reference.get_by_path(bin[0])
+                                    .and_then(|value| value.as_array())
+                                    .map_or(serde_json::Value::Null, |array| {
+                                        let strings: Vec<&str> = array.iter()
+                                            .filter_map(|v| v.as_str())
+                                            .collect();
+                                        serde_json::Value::String(vec_str(strings, ", "))
+                                    });
+                                
                             }
                             _ => (),
                         }
                         *value = task_res;
                     } else {
-                        *value = reference.get_by_path(value_str).unwrap().clone();
+                        let bin_spl:Vec<&str>= bin[0].split(".").collect(); 
+                        if bin_spl[0] == "ignore" {
+                            *value = bin[0].clone().into();
+                            return;
+                        }
+                        *value = reference
+                            .get_by_path(value_str)
+                            .map_or_else(|| serde_json::Value::Null, |v| v.clone().into());
                     }
                 }
             }

data/ext/mawsitsit/src/parser/utils/application_option.rs

@@ -1,5 +1,5 @@
 use std::fmt;
-use serde_json::{json, Value};
+use serde_json::Value;
 
 
 #[derive(Debug)]
@@ -9,7 +9,7 @@ pub enum ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ashby Application Option Type is not represented in QuestionType")
+        write!(f, "Application Option Type is not represented in QuestionType")
     }
 }
 impl std::error::Error for ParseError {}
@@ -86,6 +86,19 @@ pub fn parse_ashby_type(input: &str) -> Result<QuestionType, ParseError> {
     }
 }
 
+pub fn parse_lever_type(input: &str) -> Result<QuestionType, ParseError> {
+    match input {
+        "text" => Ok(QuestionType::ShortText),
+        "file-upload" => Ok(QuestionType::File),
+        "textarea" => Ok(QuestionType::LongText),
+        "dropdown" => Ok(QuestionType::SingleChoice),
+        "multiple-choice" => Ok(QuestionType::SingleChoice),
+        "university" => Ok(QuestionType::SingleChoice),
+        "multiple-select" => Ok(QuestionType::MultipleChoice),
+        _ => Err(ParseError::InvalidType),
+    }
+}
+
 #[derive(Debug)]
 pub struct ApplicationOption {
     pub question: String,

data/ext/mawsitsit/src/parser/utils/helpers.rs

@@ -1,11 +1,16 @@
 use reqwest::{Client, Method};
 use std::collections::HashMap;
-use base64::encode;
 use magnus::Value as RubyValue;
+use serde_json::{Map, Value as SerdeValue};
+
+
 
 
 pub fn str_vec<'a>(args: &'a str, param: &str) -> Vec<&'a str> {
-    return args.split(param).collect();
+    args.split(param).collect()
+}
+pub fn vec_str(args: Vec<&str>, separator: &str) -> String {
+    args.join(separator)
 }
 
 pub async fn fetch(
@@ -19,11 +24,8 @@ pub async fn fetch(
     let mut request = client.request(method, url);
     request = request.header("accept", "application/json")
         .header("content-type", "application/json");
-
     request = request.body(serde_json::to_string(&input)?);
-
-
-    let auth_header = format!("Basic {}", encode(api_key));
+    let auth_header = format!("Basic {}", api_key);
     request = request.header("authorization", auth_header);
     let response = request.send().await?;
     let json = response.json().await?;
@@ -34,8 +36,57 @@ pub trait IO {
     fn to_ruby(&self) -> RubyValue;
 }
 
+pub fn remove_nulls(value: &SerdeValue) -> SerdeValue {
+    match value {
+        SerdeValue::Object(map) => {
+            let filtered_map: Map<_, _> = map.iter()
+                .filter_map(|(k, v)| {
+                    let cleaned_value = remove_nulls(v);
+                    if !cleaned_value.is_null() {
+                        Some((k.clone(), cleaned_value))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            SerdeValue::Object(filtered_map)
+        }
+        SerdeValue::Array(arr) => {
+            let filtered_array: Vec<_> = arr.iter()
+                .map(|v| remove_nulls(v))
+                .filter(|v| !v.is_null())
+                .collect();
+            SerdeValue::Array(filtered_array)
+        }
+        _ => value.clone(),
+    }
+}
 
-
-
-
-
+pub fn remove_nulls_in_place(value: &mut serde_json::Value) {
+    match value {
+        serde_json::Value::Array(arr) => {
+            let mut i = 0;
+            while i < arr.len() {
+                if arr[i].is_null() {
+                    arr.remove(i);
+                } else {
+                    remove_nulls_in_place(&mut arr[i]);
+                    i += 1;
+                }
+            }
+        }
+        serde_json::Value::Object(obj) => {
+            let keys: Vec<_> = obj.keys().cloned().collect();
+            for key in keys {
+                if let Some(v) = obj.get_mut(&key) {
+                    if v.is_null() {
+                        obj.remove(&key);
+                    } else {
+                        remove_nulls_in_place(v);
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}

data/lib/mawsitsit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mawsitsit
-  VERSION = "0.1.12"
+  VERSION = "0.1.14"
 end

data/var/data_lever_test_1.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/data_lever_test_1.json

@@ -0,0 +1,333 @@
+
+{
+    "data": {
+        "id": "54d15a33-c024-4ba4-bc62-6f9588978758",
+        "text": "test",
+        "customQuestions": [
+            {
+                "id": "911f7ca4-e7a2-4081-9472-0c1f94d9df25",
+                "text": "Custom Questions",
+                "fields": [
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Short text",
+                        "type": "text",
+                        "id": "e7ac71d9-78e2-403a-a541-6c1802ee21e6",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Long text",
+                        "type": "textarea",
+                        "id": "5844afad-6f34-47a1-bf69-b099e48db9c7",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Dropdown",
+                        "type": "dropdown",
+                        "id": "5c89bddd-7aa7-430f-9db7-98ba78a524a9",
+                        "prompt": "Choose one",
+                        "options": [
+                            {
+                                "text": "Choice 1",
+                                "optionId": "b0e17be1-c39f-4899-8fc5-a0b74b230371"
+                            },
+                            {
+                                "text": "Choice 2",
+                                "optionId": "d36aec06-c439-4832-8982-11e9c29bcb54"
+                            },
+                            {
+                                "text": "Choice 3",
+                                "optionId": "c1a6f7e3-bfeb-436d-8c78-08f08d7353f1"
+                            },
+                            {
+                                "text": "Choice 4",
+                                "optionId": "0a5fc73b-d775-4d31-8b7f-fb19a852c59d"
+                            }
+                        ],
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "File upload",
+                        "type": "file-upload",
+                        "id": "4d1e49c2-1619-4216-9245-7f69c63b400d",
+                        "value": null
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Single Choice",
+                        "type": "multiple-select",
+                        "id": "4b3898d9-6dfa-4602-874a-dbe31fc8945c",
+                        "options": [
+                            {
+                                "text": "Option1",
+                                "optionId": "ff2e4a8a-0736-444f-b950-c4ab2c749973"
+                            },
+                            {
+                                "text": "Option2",
+                                "optionId": "f6f58997-2fa2-485f-85fd-fdb840913120"
+                            }
+                        ],
+                        "value": []
+                    },
+                    {
+                        "description": "",
+                        "required": true,
+                        "text": "Multiple Choice",
+                        "type": "multiple-choice",
+                        "id": "d9cf6785-2452-44bf-9eba-6854b68863c2",
+                        "options": [
+                            {
+                                "text": "MC1",
+                                "optionId": "0dab75d4-b915-4838-b764-c546a30f50e8"
+                            },
+                            {
+                                "text": "MC2",
+                                "optionId": "b4d057f0-5b4f-4182-b060-8147e670b4f9"
+                            },
+                            {
+                                "text": "MC3",
+                                "optionId": "7be4a1c6-ea29-41c6-b5c7-57b687341885"
+                            }
+                        ],
+                        "value": null
+                    }
+                ],
+                "distribution": [
+                    "external"
+                ]
+            }
+        ],
+        "personalInformation": [
+            {
+                "text": "Full name",
+                "name": "fullName",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Email",
+                "name": "email",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Current company",
+                "name": "currentCompany",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Current location",
+                "name": "currentLocation",
+                "type": "text",
+                "required": true,
+                "value": null
+            },
+            {
+                "text": "Phone",
+                "name": "phone",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Resume",
+                "name": "resume",
+                "type": "file-upload",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Additional information",
+                "name": "additionalInformation",
+                "type": "textarea",
+                "required": false,
+                "value": null
+            }
+        ],
+        "urls": [
+            {
+                "text": "LinkedIn",
+                "name": "LinkedIn",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Twitter",
+                "name": "Twitter",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "GitHub",
+                "name": "GitHub",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Portfolio",
+                "name": "Portfolio",
+                "type": "text",
+                "required": false,
+                "value": null
+            },
+            {
+                "text": "Other",
+                "name": "Other",
+                "type": "text",
+                "required": false,
+                "value": null
+            }
+        ],
+        "consentDisclosures": null,
+        "eeoQuestions": {
+            "gender": {
+                "description": null,
+                "required": false,
+                "text": "Gender",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Female",
+                    "optionId": "Female"
+                },
+                {
+                    "text": "Male",
+                    "optionId": "Male"
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify"
+                }
+                ],
+                "prompt": "Gender",
+                "value": null
+            },
+            "race": {
+                "description": null,
+                "required": false,
+                "text": "Race",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Hispanic or Latino",
+                    "optionId": "Hispanic or Latino",
+                    "description": "A person of Cuban, Mexican, Puerto Rican, South or Central American, or other Spanish culture or origin regardless of race."
+                },
+                {
+                    "text": "White (Not Hispanic or Latino)",
+                    "optionId": "White (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of Europe, the Middle East, or North Africa."
+                },
+                {
+                    "text": "Black or African American (Not Hispanic or Latino)",
+                    "optionId": "Black or African American (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the black racial groups of Africa."
+                },
+                {
+                    "text": "Native Hawaiian or Other Pacific Islander (Not Hispanic or Latino)",
+                    "optionId": "Native Hawaiian or Other Pacific Islander (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the peoples of Hawaii, Guam, Samoa, or other Pacific Islands."
+                },
+                {
+                    "text": "Asian (Not Hispanic or Latino)",
+                    "optionId": "Asian (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of the Far East, Southeast Asia, or the Indian Subcontinent, including, for example, Cambodia, China, India, Japan, Korea, Malaysia, Pakistan, the Philippine Islands, Thailand, and Vietnam."
+                },
+                {
+                    "text": "American Indian or Alaska Native (Not Hispanic or Latino)",
+                    "optionId": "American Indian or Alaska Native (Not Hispanic or Latino)",
+                    "description": "A person having origins in any of the original peoples of North and South America (including Central America), and who maintain tribal affiliation or community attachment."
+                },
+                {
+                    "text": "Two or More Races (Not Hispanic or Latino)",
+                    "optionId": "Two or More Races (Not Hispanic or Latino)",
+                    "description": "All persons who identify with more than one of the above five races."
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify"
+                }
+                ],
+                "prompt": "Race",
+                "value": null
+            },
+            "veteran": {
+                "description": "We are a Government contractor subject to the Section 4212 of the Vietnam Era Veterans’ Readjustment Assistance Act of 1974, as amended by the Jobs for Veterans Act of 2002, which requires Government contractors to take affirmative action to employ and advance in employment: (1) Disabled veterans – A veteran who served on active duty in the U.S. military and is entitled to disability compensation (or who but for the receipt of military retired pay would be entitled to disability compensation) under laws administered by the Secretary of Veterans Affairs, or was discharged or released from active duty because of a service-connected disability; (2) Recently separated veteran – A veteran separated during the three-year period beginning on the date of the veteran's discharge or release from active duty in the U.S military, ground, naval, or air service; (3) Active duty wartime or campaign badge veteran – A veteran who served on active duty in the U.S. military during a war, or in a campaign or expedition for which a campaign badge was authorized under the laws administered by the Department of Defense; (4) Armed forces service medal veteran – A veteran who, while serving on active duty in the U.S. military ground, naval, or air service, participated in a United States military operation for which an Armed Forces service medal was awarded pursuant to Executive Order 12985 (61 Fed. Reg. 1209).  If you believe that you belong to any of the categories of protected veterans, please indicate by making the appropriate selection.",
+                "required": false,
+                "text": "Veteran status",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "I am a Protected Veteran",
+                    "optionId": "I am a Protected Veteran",
+                    "description": "I identify as one or more of the classifications of protected veteran"
+                },
+                {
+                    "text": "I am not a Protected Veteran",
+                    "optionId": "I am not a Protected Veteran",
+                    "description": "I do not identify as one or more of the classifications of protected veteran"
+                },
+                {
+                    "text": "Decline to self-identify",
+                    "optionId": "Decline to self-identify",
+                    "description": "I decline to self-identify for protected veteran status"
+                }
+                ],
+                "prompt": "Veteran status",
+                "value": null
+            },
+            "disability": {
+                "description": null,
+                "required": false,
+                "text": "Voluntary self-identification of disability",
+                "type": "dropdown",
+                "options": [
+                {
+                    "text": "Yes, I have a disability, or have a history/record of having a disability",
+                    "optionId": "Yes, I have a disability, or have a history/record of having a disability"
+                },
+                {
+                    "text": "No, I don't have a disability, or a history/record of having a disability",
+                    "optionId": "No, I don't have a disability, or a history/record of having a disability"
+                },
+                {
+                    "text": "I don't wish to answer",
+                    "optionId": "I don't wish to answer"
+                }
+                ],
+                "prompt": "Voluntary self-identification of disability",
+                "value": null
+            },
+            "disabilitySignature": {
+                "type": "text",
+                "text": "Disability signature",
+                "description": "Captured user signature string. eg. \"First Last\"",
+                "required": false,
+                "value": null
+            },
+            "disabilitySignatureDate": {
+                "type": "text",
+                "text": "Disability signature date",
+                "description": "Please enter the date when the disabilitySignature was filled out eg. \"11/21/2022\"",
+                "required": false,
+                "value": null
+            }
+        }
+    }
+    
+}

data/var/data_lever_test_2.identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

data/var/data_lever_test_2.json

@@ -0,0 +1,52 @@
+{
+    "data": {
+        "id": "54d15a33-c024-4ba4-bc62-6f9588978758",
+        "text": "test",
+        "state": "published",
+        "distributionChannels": [
+            "public"
+        ],
+        "user": "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5",
+        "owner": "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5",
+        "hiringManager": null,
+        "categories": {
+            "commitment": "worktype1",
+            "department": null,
+            "level": null,
+            "location": "STUTTGART",
+            "team": "team1",
+            "allLocations": [
+                "STUTTGART"
+            ]
+        },
+        "tags": [],
+        "content": {
+            "description": "Hello World\n",
+            "descriptionHtml": "<div>Hello World</div>",
+            "lists": [],
+            "closing": "",
+            "closingHtml": ""
+        },
+        "country": "AS",
+        "followers": [
+            "715f7dbc-7e66-4bf6-949e-2d8bf368f9f5"
+        ],
+        "reqCode": "",
+        "requisitionCodes": [],
+        "urls": {
+            "list": "https://jobs.sandbox.lever.co/de",
+            "show": "https://jobs.sandbox.lever.co/de/54d15a33-c024-4ba4-bc62-6f9588978758",
+            "apply": "https://jobs.sandbox.lever.co/de/54d15a33-c024-4ba4-bc62-6f9588978758/apply"
+        },
+        "confidentiality": "non-confidential",
+        "createdAt": 1716466155252,
+        "updatedAt": 1719617791866,
+        "workplaceType": "onsite",
+        "salaryRange": {
+            "min": 1,
+            "max": 123,
+            "currency": "EUR",
+            "interval": "per-year-salary"
+        }
+    }
+}