Remove detection lists root command + additional shared code (#35)

Author: Juliya Smith

CHANGELOG.md

@@ -26,7 +26,7 @@ how a consumer would use the library (e.g. adding unit tests, updating documenta
 - `code42 profile create` command.
 - `code42 profile delete` command.
 - `code42 profile delete-all` command.
-- `code42 detection-lists high-risk` commands:
+- `code42 high-risk-employee` commands:
     - `bulk` with subcommands:
         - `add`: that takes a csv file of users.
         - `generate-template`: that creates the csv file template. And parameters:

setup.py

@@ -21,10 +21,10 @@
     package_dir={"": "src"},
     python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4",
     install_requires=[
-        "c42eventextractor==0.2.2",
+        "c42eventextractor==0.2.5",
         "keyring==18.0.1",
         "keyrings.alt==3.2.0",
-        "py42==0.6.0",
+        "py42==0.9.0",
     ],
     license="MIT",
     include_package_data=True,

src/code42cli/args.py

@@ -8,13 +8,14 @@ class ArgConfig(object):
     """Stores a set of argparse commands for later use by a command."""
 
     def __init__(self, *args, **kwargs):
-        self._settings = {}
-        self._settings[u"action"] = kwargs.get(u"action")
-        self._settings[u"choices"] = kwargs.get(u"choices")
-        self._settings[u"default"] = kwargs.get(u"default")
-        self._settings[u"help"] = kwargs.get(u"help")
-        self._settings[u"options_list"] = list(args)
-        self._settings[u"nargs"] = kwargs.get(u"nargs")
+        self._settings = {
+            u"action": kwargs.get(u"action"),
+            u"choices": kwargs.get(u"choices"),
+            u"default": kwargs.get(u"default"),
+            u"help": kwargs.get(u"help"),
+            u"options_list": list(args),
+            u"nargs": kwargs.get(u"nargs"),
+        }
 
     @property
     def settings(self):
@@ -29,6 +30,9 @@ def set_help(self, help):
     def add_short_option_name(self, short_name):
         self._settings[u"options_list"].append(short_name)
 
+    def as_multi_val_param(self, nargs=u"+"):
+        self._settings[u"nargs"] = nargs
+
 
 class ArgConfigCollection(object):
     def __init__(self):
@@ -57,7 +61,7 @@ def get_auto_arg_configs(handler):
 
         for arg_position, key in enumerate(argspec.args):
             # do not create cli parameters for arguments named "sdk", "args", or "kwargs"
-            if not key in [u"sdk", u"args", u"kwargs"]:
+            if not key in [u"sdk", u"args", u"kwargs", u"self"]:
                 arg_config = _create_auto_args_config(
                     arg_position, key, argspec, num_args, num_kw_args
                 )

src/code42cli/bulk.py

@@ -21,7 +21,12 @@ def _write_template_file(path, columns):
         new_csv.write(u",".join(columns))
 
 
-def create_bulk_processor(csv_file_path, row_handler):
+def run_bulk_process(csv_file_path, row_handler):
+    processor = _create_bulk_processor(csv_file_path, row_handler)
+    processor.run()
+
+
+def _create_bulk_processor(csv_file_path, row_handler):
     """A factory method to create the bulk processor, useful for testing purposes."""
     return BulkProcessor(csv_file_path, row_handler)
 
@@ -44,13 +49,10 @@ def __init__(self, csv_file_path, row_handler):
 
     def run(self):
         """Processes the csv file specified in the ctor, calling `self.row_handler` on each row."""
-        rows = self._get_rows()
-        self._process_rows(rows)
-        self.__worker.wait()
-
-    def _get_rows(self):
         with open(self.csv_file_path, newline=u"", encoding=u"utf8") as csv_file:
-            return _create_dict_reader(csv_file)
+            rows = _create_dict_reader(csv_file)
+            self._process_rows(rows)
+            self.__worker.wait()
 
     def _process_rows(self, rows):
         for row in rows:

src/code42cli/cmds/detectionlists/__init__.py

@@ -0,0 +1,168 @@
+from code42cli.cmds.detectionlists.commands import DetectionListCommandFactory
+from code42cli.bulk import generate_template, run_bulk_process
+from code42cli.cmds.detectionlists.enums import (
+    BulkCommandType,
+    DetectionLists,
+    DetectionListUserKeys,
+)
+from code42cli.util import print_error
+
+
+class DetectionListHandlers(object):
+    """Handlers DTO for passing in specific detection list functions.
+    
+    Args:
+        add (callable): A function that adds an employee to the list.
+        remove (callable): A function that removes an employee from the list.
+        load_add (callable): A function that loads the add-related `ArgConfig`s.
+    """
+
+    def __init__(self, add=None, remove=None, load_add=None):
+        self.add_employee = add
+        self.remove_employee = remove
+        self.load_add_description = load_add
+
+
+class UserDoesNotExistError(Exception):
+    """An error to represent a username that is not in our system."""
+
+    def __init__(self, username):
+        super(UserDoesNotExistError, self).__init__(u"User '{}' does not exist.".format(username))
+
+
+class DetectionList(object):
+    """An object representing a Code42 detection list. Use this class by passing in handlers for 
+    adding and removing employees. This class will handle the bulk-related commands and some 
+    shared help texts.
+    
+    Args:
+        list_name (str): An option from the DetectionLists enum. For convenience, use one of the 
+            given `classmethods`.
+        handlers (DetectionListHandlers): A DTO containing implementations for adding / removing 
+            users from specific lists.
+        cmd_factory (DetectionListCommandFactory): A factory that creates detection list commands.
+    """
+
+    def __init__(self, list_name, handlers, cmd_factory=None):
+        self.name = list_name
+        self.handlers = handlers
+        self.factory = cmd_factory or DetectionListCommandFactory(list_name)
+
+    @classmethod
+    def create_high_risk_list(cls, handlers):
+        """Creates a high risk detection list.
+        
+        Args:
+            handlers (DetectionListHandlers): A DTO containing implementations for adding / 
+                removing users from specific lists.
+        
+        Returns:
+            DetectionList: A high-risk employee detection list.
+        """
+        return cls(DetectionLists.HIGH_RISK_EMPLOYEE, handlers)
+
+    def load_subcommands(self):
+        """Loads high risk employee related subcommands"""
+        bulk = self.factory.create_bulk_command(lambda: self._load_bulk_subcommands())
+        add = self.factory.create_add_command(
+            self.handlers.add_employee, self.handlers.load_add_description
+        )
+        return [bulk, add]
+
+    def _load_bulk_subcommands(self):
+        generate_template_cmd = self.factory.create_bulk_generate_template_command(
+            self.generate_csv_file
+        )
+        add = self.factory.create_bulk_add_command(self.bulk_add_employees)
+        return [generate_template_cmd, add]
+
+    def generate_csv_file(self, cmd, path=None):
+        """Generates a csv template a user would need to fill-in for bulk adding users to the 
+        detection list.
+        
+        Args:
+            cmd (str): An option from the `BulkCommandType` enum specifying which type of csv to 
+                generate.
+            path (str, optional): A path to put the file after it's generated. If None, will use 
+                the current working directory. Defaults to None.
+        """
+        handler = None
+        if cmd == BulkCommandType.ADD:
+            handler = self.handlers.add_employee
+        generate_template(handler, path)
+
+    def bulk_add_employees(self, sdk, profile, csv_file):
+        """Takes a csv file with each row representing an employee and adds them all to a 
+        detection list in a bulk fashion.
+
+        Args:
+            sdk (py42.sdk.SDKClient): The py42 sdk.
+            profile (Code42Profile): The profile under which to execute this command.
+            csv_file (str): The path to the csv file containing rows of users.
+        """
+        run_bulk_process(csv_file, lambda **kwargs: self._add_employee(sdk, profile, **kwargs))
+
+    def _add_employee(self, sdk, profile, **kwargs):
+        if (
+            kwargs.has_key(DetectionListUserKeys.CLOUD_ALIAS)
+            and type(kwargs[DetectionListUserKeys.CLOUD_ALIAS]) != list
+        ):
+            kwargs[DetectionListUserKeys.CLOUD_ALIAS] = kwargs[
+                DetectionListUserKeys.CLOUD_ALIAS
+            ].split()
+
+        self.handlers.add_employee(sdk, profile, **kwargs)
+
+
+def load_user_descriptions(argument_collection):
+    """Loads the arg descriptions related to updating fields about a detection list user, such as 
+    notes or cloud aliases.
+    
+    Args:
+        argument_collection (ArgConfigCollection): The arg configs off the command that needs its 
+            user descriptions loaded.
+    """
+    username = argument_collection.arg_configs[DetectionListUserKeys.USERNAME]
+    cloud_alias = argument_collection.arg_configs[DetectionListUserKeys.CLOUD_ALIAS]
+    notes = argument_collection.arg_configs[DetectionListUserKeys.NOTES]
+
+    username.set_help(u"The code42 username of the user you want to add.")
+    cloud_alias.set_help(u"Alternative emails addresses for other cloud services.")
+    cloud_alias.as_multi_val_param()
+    notes.set_help(u"Notes about the employee.")
+
+
+def get_user_id(sdk, username):
+    """Returns the user's UID (referred to by `user_id` in detection lists). If the user does not 
+    exist, it prints an error and exits.
+    
+    Args:
+        sdk (py42.sdk.SDKClient): The py42 sdk.
+        username (str or unicode): The username of the user to get an ID for.
+    
+    Returns:
+         str: The user ID for the user with the given username.
+    """
+    users = sdk.users.get_by_username(username)[u"users"]
+    if not users:
+        print_error(str(UserDoesNotExistError(username)))
+        exit(1)
+    return users[0][u"userUid"]
+
+
+def update_user(sdk, user_id, cloud_alias=None, risk_tag=None, notes=None):
+    """Updates a detection list user.
+    
+    Args:
+        user_id (str): The ID of the user to update. This is their `userUid` found from 
+            `sdk.users.get_by_username()`.
+        cloud_alias (iter[str]): A list of cloud aliases to add to the user.
+        risk_tag (iter[str]): A list of risk tags associated with user.
+        notes (str): Notes about the user.
+    """
+    if cloud_alias:
+        sdk.detectionlists.add_user_cloud_aliases(user_id, cloud_alias)
+    if risk_tag:
+        sdk.detectionlists.add_user_risk_tags(user_id, risk_tag)
+    if notes:
+        sdk.detectionlists.update_user_notes(user_id, notes)

src/code42cli/cmds/detectionlists/commands.py

@@ -3,7 +3,7 @@
 
 
 def create_usage_prefix(detection_list_name):
-    return u"code42 detection-list {}".format(detection_list_name)
+    return u"code42 {}".format(detection_list_name)
 
 
 def create_bulk_usage_prefix(detection_list_name):
@@ -36,7 +36,7 @@ def create_bulk_generate_template_command(self, handler):
         return Command(
             u"generate-template",
             u"Generate the necessary csv template needed for bulk adding users.",
-            u"{} gen-template <cmd> <optional args>".format(self._bulk_usage_prefix),
+            u"{} generate-template <cmd> <optional args>".format(self._bulk_usage_prefix),
             handler=handler,
             arg_customizer=DetectionListCommandFactory._load_bulk_generate_template_description,
         )

src/code42cli/cmds/detectionlists/enums.py

@@ -1,10 +1,17 @@
 class DetectionLists(object):
     DEPARTING_EMPLOYEE = u"departing-employee"
-    HIGH_RISK = u"high-risk"
+    HIGH_RISK_EMPLOYEE = u"high-risk-employee"
 
 
 class BulkCommandType(object):
     ADD = u"add"
 
     def __iter__(self):
         return iter([self.ADD])
+
+
+class DetectionListUserKeys(object):
+    CLOUD_ALIAS = u"cloud_alias"
+    USERNAME = u"username"
+    NOTES = u"notes"
+    RISK_TAG = u"risk_tag"