def bulk_add(state, csv_rows): sdk = state.sdk def handle_row(matter_id, username): _add_user_to_legal_hold(sdk, matter_id, username) run_bulk_process(handle_row, csv_rows, progress_label="Adding users to legal hold:")
def bulk_remove_risk_tags(state, csv_rows): sdk = state.sdk def handle_row(username, tag): _remove_risk_tags(sdk, username, tag) run_bulk_process( handle_row, csv_rows, progress_label="Removing risk tags from users:", )
def bulk_add(state, csv_rows): sdk = state.sdk def handle_row(number, event_id): sdk.cases.file_events.add(number, event_id) run_bulk_process( handle_row, csv_rows, progress_label="Associating file events to cases:", )
def add(state, csv_rows): sdk = state.sdk def handle_row(rule_id, username): _add_user(sdk, rule_id, username) run_bulk_process(handle_row, csv_rows, progress_label="Adding users to alert-rules:")
def bulk_add_risk_tags(state, csv_rows): sdk = state.sdk def handle_row(username, tag): _add_risk_tags(sdk, username, tag) run_bulk_process( handle_row, csv_rows, progress_label="Adding risk tags to users:", )
def remove(state, csv_rows): sdk = state.sdk def handle_row(matter_id, username): _remove_user_from_legal_hold(sdk, matter_id, username) run_bulk_process( handle_row, csv_rows, progress_label="Removing users from legal hold:" )
def remove(state, csv_rows): sdk = state.sdk def handle_row(rule_id, username): _remove_user(sdk, rule_id, username) run_bulk_process(handle_row, csv_rows, progress_label="Removing users from alert-rules:")
def bulk_remove(state, file_rows): sdk = state.sdk def handle_row(username): _remove_high_risk_employee(sdk, username) run_bulk_process( handle_row, file_rows, progress_label="Removing users from high risk employee detection list:", )
def bulk_add(state, csv_rows): sdk = state.sdk def handle_row(username, cloud_alias, risk_tag, notes): _add_high_risk_employee(sdk, username, cloud_alias, risk_tag, notes) run_bulk_process( handle_row, csv_rows, progress_label="Adding users to high risk employee detection list:", )
def bulk_remove(state, csv_rows): sdk = state.sdk def handle_row(number, event_id): sdk.cases.file_events.delete(number, event_id) run_bulk_process( handle_row, csv_rows, progress_label="Removing the file event association from cases:", )
def bulk_remove(state, csv_rows): sdk = state.sdk def handle_row(username): _remove_departing_employee(sdk, username) run_bulk_process( handle_row, csv_rows, progress_label="Removing users from the Departing Employees detection list:", )
def bulk_update(cli_state, csv_rows): """Bulk update alerts.""" sdk = cli_state.sdk def handle_row(id, state, note): _update_alert(sdk, id, state, note) run_bulk_process( handle_row, csv_rows, progress_label="Updating alerts:", )
def bulk_update(state, csv_rows): """Bulk update trusted activities.""" sdk = state.sdk def handle_row(resource_id, value, description): if resource_id is None: message = "'resource_id' is a required field to update a trusted activity." raise Code42CLIError(message) _check_resource_id_type(resource_id) sdk.trustedactivities.update(resource_id, value, description) run_bulk_process(handle_row, csv_rows, progress_label="Updating trusted activities:")
def bulk_rename(state, csv_rows, format): """Rename all devices from the provided CSV containing a 'guid' and a 'name' column.""" # Initialize the SDK before starting any bulk processes # to prevent multiple instances and having to enter 2fa multiple times. sdk = state.sdk csv_rows[0]["renamed"] = "False" formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()}) stats = create_worker_stats(len(csv_rows)) def handle_row(**row): try: _change_device_name(sdk, row["guid"], row["name"]) row["renamed"] = "True" except Exception as err: row["renamed"] = f"False: {err}" stats.increment_total_errors() return row result_rows = run_bulk_process( handle_row, csv_rows, progress_label="Renaming devices:", stats=stats, raise_global_error=False, ) formatter.echo_formatted_list(result_rows)
def bulk_remove_alias(state, csv_rows, format): """Bulk remove aliases from users""" # Initialize the SDK before starting any bulk processes # to prevent multiple instances and having to enter 2fa multiple times. sdk = state.sdk success_header = "alias removed" csv_rows[0][success_header] = "False" formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()}) stats = create_worker_stats(len(csv_rows)) def handle_row(**row): try: _remove_cloud_alias( sdk, **{ key: row[key] for key in row.keys() if key != success_header }) row[success_header] = "True" except Exception as err: row[success_header] = f"False: {err}" stats.increment_total_errors() return row result_rows = run_bulk_process( handle_row, csv_rows, progress_label="Removing aliases from users:", stats=stats, raise_global_error=False, ) formatter.echo_formatted_list(result_rows)
def bulk_remove(state, csv_rows): """Bulk remove trusted activities.""" sdk = state.sdk def handle_row(resource_id): if resource_id is None: message = "'resource_id' is a required field to remove a trusted activity." raise Code42CLIError(message) _check_resource_id_type(resource_id) sdk.trustedactivities.delete(resource_id) run_bulk_process( handle_row, csv_rows, progress_label="Removing trusted activities:", )
def bulk_deactivate(state, csv_rows, format): """Deactivate a list of users.""" # Initialize the SDK before starting any bulk processes # to prevent multiple instances and having to enter 2fa multiple times. sdk = state.sdk csv_rows[0]["deactivated"] = "False" formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()}) stats = create_worker_stats(len(csv_rows)) def handle_row(**row): try: _deactivate_user( sdk, **{ key: row[key] for key in row.keys() if key != "deactivated" }) row["deactivated"] = "True" except Exception as err: row["deactivated"] = f"False: {err}" stats.increment_total_errors() return row result_rows = run_bulk_process( handle_row, csv_rows, progress_label="Deactivating users:", stats=stats, raise_global_error=False, ) formatter.echo_formatted_list(result_rows)
def _add_settings_to_dataframe(sdk, device_dataframe): macos_guids = device_dataframe.loc[ device_dataframe["osName"] == "mac", "guid" ].values def handle_row(guid): try: full_disk_access_status = sdk.devices.get_agent_full_disk_access_state( guid ).data[ "value" ] # returns 404 error if device isn't a Mac or doesn't have full disk access except Py42NotFoundError: full_disk_access_status = False return { "guid": guid, "full disk access status": full_disk_access_status, } result_list = DataFrame.from_records( run_bulk_process( handle_row, macos_guids, progress_label="Getting device settings" ) ) try: return device_dataframe.merge(result_list, how="left", on="guid") except KeyError: return device_dataframe
def bulk_add(state, csv_rows): sdk = state.sdk # Force initialization of py42 to only happen once. def handle_row(username, cloud_alias, departure_date, notes): if departure_date: try: departure_date = click.DateTime(formats=[DATE_FORMAT]).convert( departure_date, None, None ) except click.exceptions.BadParameter: message = ( f"Invalid date {departure_date}, valid date format {DATE_FORMAT}." ) raise Code42CLIError(message) _add_departing_employee(sdk, username, cloud_alias, departure_date, notes) run_bulk_process( handle_row, csv_rows, progress_label="Adding users to the Departing Employees detection list:", )
def bulk_create(state, csv_rows): """Bulk create trusted activities.""" sdk = state.sdk def handle_row(type, value, description): if type not in TrustedActivityType.choices(): message = f"Invalid type {type}, valid types include {', '.join(TrustedActivityType.choices())}." raise Code42CLIError(message) if type is None: message = "'type' is a required field to create a trusted activity." raise Code42CLIError(message) if value is None: message = "'value' is a required field to create a trusted activity." raise Code42CLIError(message) sdk.trustedactivities.create(type, value, description) run_bulk_process( handle_row, csv_rows, progress_label="Creating trusting activities:", )
def bulk_add(ctx, state, csv_rows): def handle_row(username, cloud_alias, departure_date, notes): if departure_date: try: departure_date = click.DateTime(formats=[DATE_FORMAT]).convert( departure_date, None, None) except click.exceptions.BadParameter: message = "Invalid date {}, valid date format {}".format( departure_date, DATE_FORMAT) raise Code42CLIError(message) ctx.invoke( add, username=username, cloud_alias=cloud_alias, departure_date=departure_date, notes=notes, ) run_bulk_process( handle_row, csv_rows, progress_label="Adding users to departing employee detection list:", )
def bulk_reactivate(state, csv_rows, format): """Reactivate all devices from the provided CSV containing a 'guid' column.""" sdk = state.sdk csv_rows[0]["reactivated"] = False formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()}) def handle_row(**row): try: _reactivate_device(sdk, row["guid"]) row["reactivated"] = "True" except Exception as err: row["reactivated"] = f"False: {err}" return row result_rows = run_bulk_process( handle_row, csv_rows, progress_label="Reactivating devices:" ) formatter.echo_formatted_list(result_rows)
def _add_backup_set_settings_to_dataframe(sdk, devices_dataframe): rows = [{"guid": guid} for guid in devices_dataframe["guid"].values] def handle_row(guid): try: current_device_settings = sdk.devices.get_settings(guid) except Exception as e: return DataFrame.from_records( [ { "guid": guid, "ERROR": "Unable to retrieve device settings for {}: {}".format( guid, e ), } ] ) current_result_dataframe = DataFrame.from_records( [ { "guid": current_device_settings.guid, "backup set name": backup_set["name"], "destinations": [ destination for destination in backup_set.destinations.values() ], "included files": backup_set.included_files, "excluded files": backup_set.excluded_files, "filename exclusions": backup_set.filename_exclusions, "locked": backup_set.locked, } for backup_set in current_device_settings.backup_sets ] ) return current_result_dataframe result_list = run_bulk_process( handle_row, rows, progress_label="Getting device settings" ) try: return devices_dataframe.merge(concat(result_list), how="left", on="guid") except KeyError: return devices_dataframe
def bulk_deactivate(state, csv_rows, change_device_name, purge_date, format): sdk = state.sdk csv_rows[0]["deactivated"] = False formatter = OutputFormatter(format, {key: key for key in csv_rows[0].keys()}) for row in csv_rows: row["change_device_name"] = change_device_name row["purge_date"] = purge_date def handle_row(**row): try: _deactivate_device( sdk, row["guid"], row["change_device_name"], row["purge_date"] ) row["deactivated"] = "True" except Exception as e: row["deactivated"] = "False: {}".format(e) return row result_rows = run_bulk_process( handle_row, csv_rows, progress_label="Deactivating devices:" ) formatter.echo_formatted_list(result_rows)
def test_run_bulk_process_creates_processor(bulk_processor_factory): errors.ERRORED = False rows = [1, 2] run_bulk_process(func_with_one_arg, rows) bulk_processor_factory.assert_called_once_with(func_with_one_arg, rows, None)
def test_run_bulk_process_calls_run(bulk_processor, bulk_processor_factory): errors.ERRORED = False run_bulk_process(func_with_one_arg, None) assert bulk_processor.run.call_count