CreateHash, DeduplicateValuesbyKey, JsonUnescape [Common Scripts Utility Consolidations]

Packs/CommonScripts/ReleaseNotes/1_10_49.md

@@ -0,0 +1,9 @@
+
+#### Scripts
+##### New: JsonUnescape
+- Recursively un-escapes JSON data if escaped JSON is found (Available from Cortex XSOAR 6.0.0).
+##### New: DeduplicateValuesbyKey
+- Given a list of objects and a key found in each of those objects, return a unique list of values associated with that key. Returns error if the objects provided do not contain the key of interest.  (Available from Cortex XSOAR 6.0.0).
+##### New: CreateHash
+- Creating a hash of a given input, support sha1, sha256, sha512, md5 and blake. Wrapper for https://docs.python.org/3/library/hashlib.html.
+ (Available from Cortex XSOAR 6.0.0).

Packs/CommonScripts/Scripts/CreateHash/CreateHash.py

@@ -0,0 +1,52 @@
+
+import hashlib
+from hashlib import blake2b
+
+import demistomock as demisto  # noqa: F401
+from CommonServerPython import *  # noqa: F401
+
+
+def create_hash(text, hashtype):
+    """Create a hash from a given input and return it as a context outputs
+
+    Args:
+        text (str): input to hash
+        hashtype (str): hash type
+
+    Returns:
+        Dict[str,str]: Dictionary representing the command results context
+    """
+    if hashtype == "sha512":
+        h = hashlib.sha512()
+        h.update(text.encode('utf-8'))
+    elif hashtype == "sha256":
+        h = hashlib.sha256()
+        h.update(text.encode('utf-8'))
+    elif hashtype == 'sha1':
+        h = hashlib.sha1()  # nosec
+        h.update(text.encode('utf-8'))
+    elif hashtype == 'md5':
+        h = hashlib.md5()  # nosec
+        h.update(text.encode('utf-8'))
+    else:
+        h = blake2b()
+        h.update(text.encode('utf-8'))
+
+    context = {
+        "CreateHash": str(h.hexdigest())
+    }
+
+    return context
+
+
+def main():  # pragma: no cover
+    args = demisto.args()
+    text = args.get('text')
+    hashtype = args.get('type')
+
+    context = create_hash(text, hashtype)
+    return_results(CommandResults(outputs=context))
+
+
+if __name__ in ('__builtin__', 'builtins', '__main__'):
+    main()

Packs/CommonScripts/Scripts/CreateHash/CreateHash_test.py

@@ -0,0 +1,18 @@
+import pytest
+
+
+@pytest.mark.parametrize("hash_method", ['sha512', 'sha256', 'sha1', 'md5', ''])
+def test_create_hash(hash_method):
+    """
+    Given:
+        - A string
+    When:
+        - Running the script
+    Then:
+        - Ensure the expected hash is returned
+    """
+    from CreateHash import create_hash
+    context = create_hash('test', hash_method)
+
+    assert isinstance(context, dict)
+    assert isinstance(context.get('CreateHash'), str)

Packs/DeduplicateValuesbyKey/Scripts/DeduplicateValuesbyKey/DeduplicateValuesbyKey.py → Packs/CommonScripts/Scripts/DeduplicateValuesbyKey/DeduplicateValuesbyKey.py

@@ -1,23 +1,24 @@
 import demistomock as demisto  # noqa: F401
 from CommonServerPython import *  # noqa: F401
 
-"""Given a list of objects (dictionaries) and a key, generate a list
-of unique values of that key in the list of objects."""
 
+def generate_unique_values_from_objects(object_list, key, keep_none):
+    """Given a list of objects (dictionaries) and a key,
+    generate a list of unique values of that key in the list of objects
+    and return the unique values list.
 
-def main():
-
-    object_list = demisto.args().get("object_list")
-    key = demisto.args().get("key_of_interest")
-    keep_none = argToBoolean(demisto.args().get("keep_none"))
 
+    Args:
+        object_list (List[Dict]): list of objects (dictionaries)
+        key (Object): key of interest
+        keep_none (bool): whether to keep None values
+    """
     values = set()
 
     for obj in object_list:
         # Initially attempt to retrieve value using built-in object get method.
-        #
         # This accounts for keys that may contain dots that are NOT intended
-        # to be retrieved from subkeys.
+        # to be retrieved from sub-keys.
         if key in obj:
             values.add(obj[key])
         # Otherwise, use demisto.get to access values.
@@ -31,10 +32,21 @@ def main():
     if not values:
         return_error("The objects provided did not contain the key of interest.")
 
+    return list(values)
+
+
+def main():  # pragma: no cover
+    args = demisto.args()
+    object_list = args.get("object_list")
+    key = args.get("key_of_interest")
+    keep_none = argToBoolean(args.get("keep_none"))
+
+    values = generate_unique_values_from_objects(object_list, key, keep_none)
+
     return_results(CommandResults(
         outputs_prefix="unique_values",
         outputs_key_field="unique_values",
-        outputs={"unique_values": list(values)}))
+        outputs={"unique_values": values}))
 
 
 if __name__ in ("__main__", "__builtin__", "builtins"):

Packs/CommonScripts/Scripts/DeduplicateValuesbyKey/DeduplicateValuesbyKey_test.py

@@ -0,0 +1,71 @@
+
+import pytest
+
+
+def test_generate_unique_values_from_objects():
+    from DeduplicateValuesbyKey import generate_unique_values_from_objects
+    objects = [
+        {
+            "key": "value1",
+            "value": "value1"
+        },
+        {
+            "key": "value1",
+            "value": "value2"
+        },
+        {
+            "key": "value2",
+            "value": "value3"
+        },
+        {
+            "key": "value2",
+            "value": "value4"
+        },
+        {
+            "key": "value3",
+            "value": "value5"
+        },
+        {
+            "key": "value3",
+            "value": "value6"
+        }]
+    values = generate_unique_values_from_objects(objects, "key", False)
+    assert set(values) == set(["value1", "value2", "value3"])
+
+
+def test_generate_unique_values_from_objects_with_none():
+    from DeduplicateValuesbyKey import generate_unique_values_from_objects
+    objects = [
+        {
+            "key": "value1",
+            "value": "value1"
+        },
+        {
+            "key": "value1",
+            "value": "value2"
+        },
+        {
+            "key": "value2",
+            "value": "value3"
+        },
+        {
+            "key": "value2",
+            "value": "value4"
+        },
+        {
+            "key": "value3",
+            "value": "value5"
+        },
+        {
+            "key": "None_value",
+            "value": None
+        }]
+    values = generate_unique_values_from_objects(objects, "key", True)
+    assert set(values) == set(["None_value", "value1", "value2", "value3"])
+
+
+def test_generate_unique_values_from_objects_fail():
+    from DeduplicateValuesbyKey import generate_unique_values_from_objects
+
+    with pytest.raises(SystemExit):
+        generate_unique_values_from_objects([], "key", True)

Packs/JsonUnescape/Scripts/JsonUnescape/JsonUnescape.py → Packs/CommonScripts/Scripts/JsonUnescape/JsonUnescape.py

@@ -7,6 +7,7 @@
 
 
 def hook(obj: Dict) -> Dict:
+    """ Hook to convert string to json if possible """
     new_obj = {}
     for k, v in obj.items():
         try:
@@ -17,13 +18,15 @@ def hook(obj: Dict) -> Dict:
 
 
 def unescape(args: Dict) -> Union[Dict, List]:
+    """ Unescape json string """
     json_str = json.dumps(args.get("value"))
     return json.loads(json_str, object_hook=hook)
 
 
-def main():
+def main():  # noqa: F841
+    args = demisto.args()
     try:
-        return_results(unescape(demisto.args()))
+        return_results(unescape(args))
     except Exception as ex:
         demisto.error(traceback.format_exc())
         return_error(f"Error: {str(ex)}")

Packs/CommonScripts/Scripts/JsonUnescape/JsonUnescape_test.py

@@ -0,0 +1,26 @@
+def test_hook():
+    """
+    Given
+    - A string value representing a json
+    When
+    - Running the hook function
+    Then
+    - Ensure the string value is converted to json
+    """
+    from JsonUnescape import hook
+    assert hook({"key": "value"}) == {"key": "value"}
+    assert hook({"key": "{'key': 'value'}"}) == {'key': "{'key': 'value'}"}
+
+
+def test_unescape():
+    """
+    Given
+    - A dictionary with a string value
+    When
+    - Running the unescape function
+    Then
+    - Ensure the string value is converted to json
+    """
+    from JsonUnescape import unescape
+    assert unescape({"value": "value"}) == 'value'
+    assert unescape({"value": "{'key': 'value'}"}) == "{'key': 'value'}"

Packs/CreateHash/ReleaseNotes/1_0_3.json

@@ -0,0 +1 @@
+{"breakingChanges":true,"breakingChangesNotes":"The script: CreateHash moved to *CommonScripts* pack. Make sure to update the *CommonScripts* pack to the latest version in order to use this script."}

Packs/CreateHash/ReleaseNotes/1_0_3.md

@@ -0,0 +1,2 @@
+##### CreateHash
+- Deprecated. **CreateHash** script moved to *Common Scripts* pack.

Packs/CreateHash/pack_metadata.json

@@ -2,10 +2,11 @@
     "name": "CreateHash",
     "description": "Simple wrapper of the https://docs.python.org/3/library/hashlib.html to produce sha512, sha256, sha1, md5 and Blake (simple hash) of a given text input",
     "support": "community",
-    "currentVersion": "1.0.2",
+    "currentVersion": "1.0.3",
     "author": "Joerg Stephan",
     "url": "",
     "email": "",
+    "hidden": true,
     "created": "2021-12-06T11:19:01Z",
     "categories": [
         "Utilities"
@@ -20,4 +21,4 @@
         "xsoar",
         "marketplacev2"
     ]
-}
+}

Packs/DeduplicateValuesbyKey/ReleaseNotes/1_0_1.json

@@ -0,0 +1 @@
+{"breakingChanges":true,"breakingChangesNotes":"The script: DeduplicateValuesbyKey moved to *CommonScripts* pack. Make sure to update the *CommonScripts* pack to the latest version in order to use this script."}

Packs/DeduplicateValuesbyKey/ReleaseNotes/1_0_1.md

@@ -0,0 +1,2 @@
+##### DeduplicateValuesbyKey
+- Deprecated. **DeduplicateValuesbyKey** script moved to *Common Scripts* pack.

Packs/DeduplicateValuesbyKey/pack_metadata.json

@@ -1,11 +1,12 @@
 {
-    "name": "DeduplicateValuesbyKey",
-    "description": "Given a list of objects (dictionaries) and a key (string), return a list of unique values that appear for that key in the list of objects. \n\nThe current implementation only works on the first-level of keys. That is, given a dictionary like {key1: {key2: value}}, you can return a list of unique values for key1, but not key2. ",
+    "name": "DeduplicateValuesbyKey (Deprecated)",
+    "description": "Deprecated. DeduplicateValuesbyKey script moved to CommonScripts pack.",
     "support": "community",
-    "currentVersion": "1.0.0",
+    "currentVersion": "1.0.1",
     "author": "Laura Farvour",
     "url": "",
     "email": "",
+    "hidden": true,
     "created": "2021-12-07T17:00:09Z",
     "categories": [
         "Utilities"

Packs/JsonUnescape/ReleaseNotes/1_0_1.json

@@ -0,0 +1 @@
+{"breakingChanges":true,"breakingChangesNotes":"The script: JsonUnescape moved to *CommonScripts* pack. Make sure to update the *CommonScripts* pack to the latest version in order to use this script."}

Packs/JsonUnescape/ReleaseNotes/1_0_1.md

@@ -0,0 +1,2 @@
+##### JsonUnescape
+- Deprecated. **JsonUnescape** script moved to *Common Scripts* pack.