Feature/de

CHANGELOG.md

@@ -30,12 +30,21 @@ how a consumer would use the library (e.g. adding unit tests, updating documenta
 - `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:
+        - `generate-template`: that creates the file template. And parameters:
             - `cmd`: with options `add` and `remove`.
             - `path`
         - `remove`: that takes a list of users in a file.
     - `add` that takes parameters: `--username`, `--cloud-alias`, `--risk-factor`, and `--notes`.
     - `remove` that takes a username.
+- `code42 departing-employee` commands:
+    - `bulk` with subcommands:
+        - `add`: that takes a csv file of users.
+        - `generate-template`: that creates the file template. And parameters:
+            - `cmd`: with options `add` and `remove`.
+            - `path`
+        - `remove`: that takes a list of users in a file.
+    - `add` that takes parameters: `--username`, `--cloud-alias`, `--departure-date`, and `--notes`.
+    - `remove` that takes a username.
 
 ### Removed
 

README.md

@@ -5,7 +5,8 @@ Use the `code42` command to interact with your Code42 environment.
 * `code42 security-data` is a CLI tool for extracting AED events.
     Additionally, you can choose to only get events that Code42 previously did not observe since you last recorded a 
     checkpoint (provided you do not change your query).
-* `code42 high-risk-employee` is a collection of tools for managing the high risk employee detection list.
+* `code42 high-risk-employee` is a collection of tools for managing the high risk employee detection list. Similarly, 
+    there is `code42 departing-employee`.
 
 ## Requirements
 

src/code42cli/cmds/detectionlists/__init__.py

@@ -63,6 +63,19 @@ def create_high_risk_employee_list(cls, handlers):
         """
         return cls(DetectionLists.HIGH_RISK_EMPLOYEE, handlers)
 
+    @classmethod
+    def create_departing_employee_list(cls, handlers):
+        """Creates a departing employee detection list.
+
+        Args:
+            handlers (DetectionListHandlers): A DTO containing implementations for adding /
+                removing users from specific lists.
+
+        Returns:
+            DetectionList: A departing employee detection list.
+        """
+        return cls(DetectionLists.DEPARTING_EMPLOYEE, handlers)
+
     def load_subcommands(self):
         """Loads high risk employee related subcommands"""
         bulk = self.factory.create_bulk_command(lambda: self._load_bulk_subcommands())
@@ -151,7 +164,7 @@ def load_user_descriptions(argument_collection):
     _load_username_description(argument_collection)
     cloud_alias = argument_collection.arg_configs[DetectionListUserKeys.CLOUD_ALIAS]
     notes = argument_collection.arg_configs[DetectionListUserKeys.NOTES]
-    cloud_alias.set_help(u"Alternative emails addresses for other cloud services.")
+    cloud_alias.set_help(u"An alternative email address for another cloud service.")
     notes.set_help(u"Notes about the employee.")
 
 

src/code42cli/cmds/detectionlists/departing_employee.py

@@ -0,0 +1,48 @@
+from code42cli.cmds.detectionlists import (
+    DetectionList,
+    DetectionListHandlers,
+    load_user_descriptions,
+    get_user_id,
+    update_user,
+)
+
+
+def load_subcommands():
+    handlers = _create_handlers()
+    detection_list = DetectionList.create_departing_employee_list(handlers)
+    return detection_list.load_subcommands()
+
+
+def _create_handlers():
+    return DetectionListHandlers(
+        add=add_departing_employee, remove=remove_departing_employee, load_add=_load_add_description
+    )
+
+
+def add_departing_employee(
+    sdk, profile, username, cloud_alias=None, departure_date=None, notes=None
+):
+    """Adds an employee to the departing employee detection list.
+
+    Args:
+        sdk (py42.sdk.SDKClient): py42.
+        profile (C42Profile): Your code42 profile.
+        username (str): The username of the employee to add.
+        cloud_alias (str): An alternative email address for another cloud service.
+        departure_date (str): The date the employee is departing in format `YYYY-MM-DD`.
+        notes: (str): Notes about the employee.
+    """
+    user_id = get_user_id(sdk, username)
+    update_user(sdk, user_id, cloud_alias, notes=notes)
+    sdk.detectionlists.departing_employee.add(user_id, departure_date)
+
+
+def remove_departing_employee(sdk, profile, username):
+    user_id = get_user_id(sdk, username)
+    sdk.detectionlists.departing_employee.remove(user_id)
+
+
+def _load_add_description(argument_collection):
+    load_user_descriptions(argument_collection)
+    departure_date = argument_collection.arg_configs[u"departure_date"]
+    departure_date.set_help(u"The date the employee is departing in format YYYY-MM-DD.")

src/code42cli/cmds/securitydata/date_helper.py

@@ -1,20 +1,6 @@
-import re
-from datetime import datetime, timedelta
-
-from c42eventextractor.common import convert_datetime_to_timestamp
 from py42.sdk.queries.fileevents.filters.event_filter import EventTimestamp
 
-_MAX_LOOK_BACK_DAYS = 90
-_FORMAT_VALUE_ERROR_MESSAGE = u"input must be a date/time string (e.g. 'YYYY-MM-DD', 'YY-MM-DD HH:MM', 'YY-MM-DD HH:MM:SS'), or a short value in days, hours, or minutes (e.g. 30d, 24h, 15m)"
-
-
-class DateArgumentException(Exception):
-    def __init__(self, message=_FORMAT_VALUE_ERROR_MESSAGE):
-        super(DateArgumentException, self).__init__(message)
-
-
-TIMESTAMP_REGEX = re.compile(u"(\d{4}-\d{2}-\d{2})\s*(.*)?")
-MAGIC_TIME_REGEX = re.compile(u"(\d+)([dhm])$")
+from code42cli.date_helper import DateArgumentException, parse_min_timestamp, parse_max_timestamp
 
 
 def create_event_timestamp_filter(begin_date=None, end_date=None):
@@ -25,16 +11,16 @@ def create_event_timestamp_filter(begin_date=None, end_date=None):
             end_date: The end date for the range.
     """
     if begin_date and end_date:
-        min_timestamp = _parse_min_timestamp(begin_date)
-        max_timestamp = _parse_max_timestamp(end_date)
+        min_timestamp = parse_min_timestamp(begin_date)
+        max_timestamp = parse_max_timestamp(end_date)
         return _create_in_range_filter(min_timestamp, max_timestamp)
 
     elif begin_date and not end_date:
-        min_timestamp = _parse_min_timestamp(begin_date)
+        min_timestamp = parse_min_timestamp(begin_date)
         return _create_on_or_after_filter(min_timestamp)
 
     elif end_date and not begin_date:
-        max_timestamp = _parse_max_timestamp(end_date)
+        max_timestamp = parse_max_timestamp(end_date)
         return _create_on_or_before_filter(max_timestamp)
 
 
@@ -43,90 +29,16 @@ def _create_in_range_filter(min_timestamp, max_timestamp):
     return EventTimestamp.in_range(min_timestamp, max_timestamp)
 
 
-def _create_on_or_after_filter(min_timestamp):
-    return EventTimestamp.on_or_after(min_timestamp)
-
-
-def _create_on_or_before_filter(max_timestamp):
-    return EventTimestamp.on_or_before(max_timestamp)
-
-
-def _parse_timestamp(date_str, rounding_func):
-    timestamp_match = TIMESTAMP_REGEX.match(date_str)
-    magic_match = MAGIC_TIME_REGEX.match(date_str)
-
-    if timestamp_match:
-        date, time = timestamp_match.groups()
-        dt = _get_dt_from_date_time_pair(date, time)
-        if not time:
-            dt = rounding_func(dt)
-
-    elif magic_match:
-        num, period = magic_match.groups()
-        dt = _get_dt_from_magic_time_pair(num, period)
-        if period == u"d":
-            dt = rounding_func(dt)
-
-    else:
-        raise DateArgumentException()
-    return dt
-
-
-def _parse_min_timestamp(begin_date_str):
-    dt = _parse_timestamp(begin_date_str, _round_datetime_to_day_start)
-
-    boundary_date = _round_datetime_to_day_start(
-        datetime.utcnow() - timedelta(days=_MAX_LOOK_BACK_DAYS)
-    )
-    if dt < boundary_date:
-        raise DateArgumentException(u"'Begin date' must be within 90 days.")
-
-    return convert_datetime_to_timestamp(dt)
-
-
-def _parse_max_timestamp(end_date_str):
-    dt = _parse_timestamp(end_date_str, _round_datetime_to_day_end)
-    return convert_datetime_to_timestamp(dt)
-
-
-def _get_dt_from_date_time_pair(date, time):
-    date_format = u"%Y-%m-%d %H:%M:%S"
-    if time:
-        time = u"{}:{}:{}".format(*time.split(":") + [u"00", u"00"])
-    else:
-        time = u"00:00:00"
-    date_string = u"{} {}".format(date, time)
-    try:
-        dt = datetime.strptime(date_string, date_format)
-    except ValueError:
-        raise DateArgumentException()
-    else:
-        return dt
-
-
-def _get_dt_from_magic_time_pair(num, period):
-    num = int(num)
-    if period == u"d":
-        dt = datetime.utcnow() - timedelta(days=num)
-    elif period == u"h":
-        dt = datetime.utcnow() - timedelta(hours=num)
-    elif period == u"m":
-        dt = datetime.utcnow() - timedelta(minutes=num)
-    else:
-        raise DateArgumentException(u"Couldn't parse magic time string: {}{}".format(num, period))
-    return dt
-
-
 def _verify_timestamp_order(min_timestamp, max_timestamp):
     if min_timestamp is None or max_timestamp is None:
         return
     if min_timestamp >= max_timestamp:
         raise DateArgumentException(u"Begin date cannot be after end date")
 
 
-def _round_datetime_to_day_start(dt):
-    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+def _create_on_or_after_filter(min_timestamp):
+    return EventTimestamp.on_or_after(min_timestamp)
 
 
-def _round_datetime_to_day_end(dt):
-    return dt.replace(hour=23, minute=59, second=59, microsecond=999000)
+def _create_on_or_before_filter(max_timestamp):
+    return EventTimestamp.on_or_before(max_timestamp)

src/code42cli/date_helper.py

@@ -0,0 +1,91 @@
+from datetime import datetime, timedelta
+import re
+
+from c42eventextractor.common import convert_datetime_to_timestamp
+
+
+_FORMAT_VALUE_ERROR_MESSAGE = (
+    u"input must be a date/time string (e.g. 'YYYY-MM-DD', "
+    u"'YY-MM-DD HH:MM', 'YY-MM-DD HH:MM:SS'), or a short value in days, "
+    u"hours, or minutes (e.g. 30d, 24h, 15m)"
+)
+
+TIMESTAMP_REGEX = re.compile(u"(\d{4}-\d{2}-\d{2})\s*(.*)?")
+MAGIC_TIME_REGEX = re.compile(u"(\d+)([dhm])$")
+
+
+class DateArgumentException(Exception):
+    def __init__(self, message=_FORMAT_VALUE_ERROR_MESSAGE):
+        super(DateArgumentException, self).__init__(message)
+
+
+def parse_min_timestamp(begin_date_str, max_days_back=90):
+    dt = _parse_timestamp(begin_date_str, _round_datetime_to_day_start)
+
+    boundary_date = _round_datetime_to_day_start(datetime.utcnow() - timedelta(days=max_days_back))
+    if dt < boundary_date:
+        raise DateArgumentException(u"'Begin date' must be within 90 days.")
+
+    return convert_datetime_to_timestamp(dt)
+
+
+def parse_max_timestamp(end_date_str):
+    dt = _parse_timestamp(end_date_str, _round_datetime_to_day_end)
+    return convert_datetime_to_timestamp(dt)
+
+
+def _parse_timestamp(date_str, rounding_func):
+    timestamp_match = TIMESTAMP_REGEX.match(date_str)
+    magic_match = MAGIC_TIME_REGEX.match(date_str)
+
+    if timestamp_match:
+        date, time = timestamp_match.groups()
+        dt = _get_dt_from_date_time_pair(date, time)
+        if not time:
+            dt = rounding_func(dt)
+
+    elif magic_match:
+        num, period = magic_match.groups()
+        dt = _get_dt_from_magic_time_pair(num, period)
+        if period == u"d":
+            dt = rounding_func(dt)
+
+    else:
+        raise DateArgumentException()
+    return dt
+
+
+def _get_dt_from_date_time_pair(date, time):
+    date_format = u"%Y-%m-%d %H:%M:%S"
+    if time:
+        time = u"{}:{}:{}".format(*time.split(":") + [u"00", u"00"])
+    else:
+        time = u"00:00:00"
+    date_string = u"{} {}".format(date, time)
+    try:
+        dt = datetime.strptime(date_string, date_format)
+    except ValueError:
+        raise DateArgumentException()
+    else:
+        return dt
+
+
+def _get_dt_from_magic_time_pair(num, period):
+    num = int(num)
+    if period == u"d":
+        dt = datetime.utcnow() - timedelta(days=num)
+    elif period == u"h":
+        dt = datetime.utcnow() - timedelta(hours=num)
+    elif period == u"m":
+        dt = datetime.utcnow() - timedelta(minutes=num)
+    else:
+        raise DateArgumentException(u"Couldn't parse magic time string: {}{}".format(num, period))
+    return dt
+
+
+def _round_datetime_to_day_start(dt):
+    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+
+
+def _round_datetime_to_day_end(dt):
+    return dt.replace(hour=23, minute=59, second=59, microsecond=999000)

src/code42cli/main.py

@@ -5,7 +5,9 @@
 
 from code42cli import PRODUCT_NAME
 from code42cli.cmds import profile
+from code42cli.cmds.detectionlists import departing_employee as de
 from code42cli.cmds.detectionlists import high_risk_employee as hre
+from code42cli.cmds.detectionlists.enums import DetectionLists
 from code42cli.cmds.securitydata import main as secmain
 from code42cli.commands import Command
 from code42cli.invoker import CommandInvoker
@@ -46,7 +48,12 @@ def _load_top_commands():
             subcommand_loader=secmain.load_subcommands,
         ),
         Command(
-            u"high-risk-employee",
+            DetectionLists.DEPARTING_EMPLOYEE,
+            detection_lists_description.format(u"departing employee"),
+            subcommand_loader=de.load_subcommands,
+        ),
+        Command(
+            DetectionLists.HIGH_RISK_EMPLOYEE,
             detection_lists_description.format(u"high risk employee"),
             subcommand_loader=hre.load_subcommands,
         ),