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
