import json import urllib3 from CommonServerPython import * urllib3.disable_warnings() class Client(BaseClient): def get_transactionlog(self, page, search, locked) -> Dict[str, Any]: if page is None: page = 1 p_search = "" if search is not None and search != "": p_search = f"&search={search}" p_locked = "" if locked is not None and locked: p_locked = "&locked={}".format("true") return self._http_request(method="GET", url_suffix=f"/transactionlog/?page={page}{p_search}{p_locked}", resp_type="text") def get_users(self, page, search, locked) -> Dict[str, Any]: if page is None: page = 1 p_search = "" if search is not None and search != "": p_search = f"&search={search}" p_locked = "" if locked is not None and locked: p_locked = "&locked={}".format("true") return self._http_request(method="GET", url_suffix=f"/userlist/?page={page}{p_search}{p_locked}", resp_type="text") def get_ldap_users(self, page, search, locked, ldap) -> Dict[str, Any]: if page is None: page = 1 p_search = "" if search is not None and search != "": p_search = f"&search={search}" p_locked = "" if locked is not None and locked: p_locked = "&locked={}".format("true") return self._http_request(method="GET", url_suffix=f"/userlist/{ldap}/?page={page}{p_search}{p_locked}", resp_type="text") def get_ldaps(self) -> Dict[str, Any]: return json.loads(self._http_request(method="GET", url_suffix="/ldapconfiguration/", resp_type="text")) def get_user_personalinformation(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/", resp_type="text") def set_user_personalinformation(self, username, email, mobile_phone) -> Dict[str, Any]: post_params = {} if email: post_params["email"] = email if mobile_phone: post_params["mobile_phone"] = mobile_phone return self._http_request(method="PUT", url_suffix="/user/{username}/", json_data=post_params, resp_type="text") def get_user_accessattempts(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/access_attempt/", resp_type="text") def delete_user_accessattempts(self, username) -> Dict[str, Any]: return self._http_request(method="DELETE", url_suffix=f"/user/{username}/access_attempt/", resp_type="text") # Get "params" to generalize all token types. # Said argument must be a dictionary or json with the data corresponding to the token to be registered def create_user_token(self, username, post_params) -> Dict[str, Any]: return self._http_request(method="POST", url_suffix=f"/user/{username}/devices/", json_data=post_params, resp_type="text") def update_user_token(self, username, token_devicetype, token_serialnumber, post_params) -> Dict[str, Any]: return self._http_request( method="PUT", url_suffix=f"/user/{username}/devices/{token_devicetype}/{token_serialnumber}/", json_data=post_params, resp_type="text", ) def get_user_tokens(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/devices/", resp_type="text") def delete_user_token(self, username, token_devicetype, token_serialnumber) -> Dict[str, Any]: return self._http_request( method="DELETE", url_suffix=f"/user/{username}/devices/{token_devicetype}/{token_serialnumber}/", resp_type="text" ) def send_user_token(self, username, token_devicetype, token_serialnumber) -> Dict[str, Any]: return self._http_request( method="POST", url_suffix=f"/user/{username}/devices/{token_devicetype}/{token_serialnumber}/send/", resp_type="text" ) def send_user_virtualtoken(self, username, token_devicetype, token_serialnumber) -> Dict[str, Any]: return self._http_request( method="POST", url_suffix=f"/devices/{token_devicetype}/{token_serialnumber}/code/", resp_type="text" ) def get_user_settings(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/settings/", resp_type="text") # Get "params" to generalize all configuration items. # This argument must be a dictionary or json with the items that you want to modify def set_user_settings(self, username, post_params) -> Dict[str, Any]: return self._http_request( method="PATCH", url_suffix=f"/user/{username}/settings/", json_data=post_params, resp_type="text" ) def get_user_group(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/group/", resp_type="text") def add_user_group(self, username, new_group_name) -> Dict[str, Any]: post_params = {"username": username} return self._http_request( method="POST", url_suffix=f"/group/{new_group_name}/member/", json_data=post_params, resp_type="text" ) def remove_user_group(self, username, old_group_name) -> Dict[str, Any]: return self._http_request(method="DELETE", url_suffix=f"/group/{old_group_name}/member/{username}/", resp_type="text") def get_user_registrationcode(self, username) -> Dict[str, Any]: return self._http_request(method="GET", url_suffix=f"/user/{username}/registrationtoken/", resp_type="text") def set_user_registrationcode(self, username, expiration, attempts_left) -> Dict[str, Any]: post_params = { "username": username, "expiration": expiration, "attempts_left": attempts_left, "sent_on": "", "sent_by": "", "token": "", } return self._http_request( method="POST", url_suffix=f"/user/{username}/registrationtoken/", json_data=post_params, resp_type="text" ) def delete_user_registrationcode(self, username) -> Dict[str, Any]: return self._http_request(method="DELETE", url_suffix=f"/user/{username}/registrationtoken/", resp_type="text") def send_user_registrationcode(self, username) -> Dict[str, Any]: return self._http_request(method="POST", url_suffix=f"/user/{username}/registrationtoken/send/", resp_type="text") def create_user(self, username, password, firstname, lastname, mobilephone, email): post_params = { "username": username, "password": password, "first_name": firstname, "last_name": lastname, "mobile_phone": mobilephone, "email": email, } return self._http_request(method="POST", url_suffix="/user/", json_data=post_params, resp_type="text") def delete_user(self, username): return self._http_request(method="DELETE", url_suffix=f"/user/{username}/", resp_type="text") def get_transactionlog(client, args): page = args.get("page") search = args.get("search") locked = args.get("locked") result_raw = client.get_transactionlog(page, search, locked) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get Transaction Log Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetTransactionLog.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_users(client, args): page = args.get("page") search = args.get("search") locked = args.get("locked") result_raw = client.get_users(page, search, locked) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUsers.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_ldap_users(client, args): page = args.get("page") search = args.get("search") locked = args.get("locked") ldap = args.get("ldap") result_raw = client.get_ldap_users(page, search, locked, ldap) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get Ldap users Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetLdapUsers.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_ldaps(client, args): result_raw = client.get_ldaps() if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get Ldaps Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetLdaps.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_personalinformation(client, args): username = args.get("username") result_raw = client.get_user_personalinformation(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Personal Information Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserPersonalInformation.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_personalinformation(client, args): username = args.get("username") email = args.get("email") mobile_phone = args.get("mobile_phone") result_raw = client.set_user_personalinformation(username, email, mobile_phone) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Personal Information Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserPersonalInformation.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_accessattempts(client, args): username = args.get("username") result_raw = client.get_user_accessattempts(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Access Attempts Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserAccessAttempts.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def delete_user_accessattempts(client, args): username = args.get("username") result_raw = client.delete_user_accessattempts(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Delete User Access Attempts Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="DeleteUserAccessAttempts.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_virtual(client, args): username = args.get("username") post_params = {"device_type": "Virtual"} result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Virtual Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenVirtual.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_fastauth(client, args): username = args.get("username") post_params = { "device_type": "Fast:Auth:Mobile:Asymmetric", "serial_number": args.get("serial-number"), "password_required": "", } result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Fast Auth Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenFastAuth.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_totpmobile(client, args): username = args.get("username") post_params = { "device_type": "TOTP:Mobile", "serial_number": args.get("serial-number"), "password_required": args.get("password-required"), } result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Totp Mobile Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenTotpMobile.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_totmobilehybrid(client, args): username = args.get("username") post_params = {"device_type": "TOTP:Mobile:Hybrid", "serial_number": args.get("serial-number"), "password_required": ""} result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Tot Mobile Hybrid Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenTotMobileHybrid.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_physical(client, args): username = args.get("username") post_params = { "device_type": args.get("devicetype"), "serial_number": args.get("serial-number"), "password_required": args.get("password-required"), } result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Physical Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenPhysical.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user_token_backup(client, args): username = args.get("username") post_params = { "device_type": "Backup", "serial_number": "", "password_required": args.get("password-required"), "backuptoken_timeout": args.get("backuptoken-timeout"), "backuptoken_attempts": args.get("backuptoken_attempts"), "backuptoken_gateways": "", } result_raw = client.create_user_token(username, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Token Backup Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUserTokenBackup.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results # See def update_user_token(client, args): username = args.get("username") token_devicetype = args.get("devicetype") token_serialnumber = args.get("serialnumber") post_params = args.get("params") result_raw = client.update_user_token(username, token_devicetype, token_serialnumber, post_params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Update User Token Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="UpdateUserToken.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_tokens(client, args): username = args.get("username") result_raw = client.get_user_tokens(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Tokens Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserTokens.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def delete_user_token(client, args): username = args.get("username") token_devicetype = args.get("devicetype") token_serialnumber = args.get("serialnumber") result_raw = client.delete_user_token(username, token_devicetype, token_serialnumber) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Delete User Token Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="DeleteUserToken.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def send_user_token(client, args): username = args.get("username") token_devicetype = args.get("devicetype") token_serialnumber = args.get("serialnumber") result_raw = client.send_user_token(username, token_devicetype, token_serialnumber) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Send User Token Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SendUserToken.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def send_user_virtualtoken(client, args): username = args.get("username") token_devicetype = args.get("devicetype") token_serialnumber = args.get("serialnumber") result_raw = client.send_user_virtualtoken(username, token_devicetype, token_serialnumber) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Send User Virtual Token Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SendUserVirtualToken.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_settings(client, args): username = args.get("username") result_raw = client.get_user_settings(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_backuptoken_settings(client, args): username = args.get("username") backup_password_required = args.get("backup-password-required") backuptoken_attempts = args.get("backuptoken-attempts") backuptoken_timeout = args.get("backuptoken-timeout") params = {} if not backup_password_required: params["backup_password_required"] = backup_password_required if not backuptoken_attempts: params["backuptoken_attempts"] = backuptoken_attempts if not backuptoken_timeout: params["backuptoken_timeout"] = backuptoken_timeout result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Backup Token Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserBackupTokenSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_general_settings(client, args): username = args.get("username") user_storage = args.get("user-storage") params = {} if not user_storage: params["user_storage"] = user_storage result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User General Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserGeneralSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_hotpauthentication_settings(client, args): username = args.get("username") hotp_accept_tolerance = args.get("hotp-accept-tolerance") hotp_resend_tolerance = args.get("hotp-resend-tolerance") hotp_resend_timeout = args.get("hotp-resend-timeout") hotp_password_required = args.get("hotp-password_required") hotp_flex_password_required = args.get("hotp-flex-password-required") hotp_flex_pin_password_required = args.get("hotp-flex-pin-password-required") params = {} if not hotp_accept_tolerance: params["hotp_accept_tolerance"] = hotp_accept_tolerance if not hotp_resend_tolerance: params["hotp_resend_tolerance"] = hotp_resend_tolerance if not hotp_resend_timeout: params["hotp_resend_timeout"] = hotp_resend_timeout if not hotp_password_required: params["hotp_password_required"] = hotp_password_required if not hotp_flex_password_required: params["hotp_flex_password_required"] = hotp_flex_password_required if not hotp_flex_pin_password_required: params["hotp_flex_pin_password_required"] = hotp_flex_pin_password_required result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Hotp Authentication Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserHotpAuthenticationSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_sesamiauthentication_settings(client, args): username = args.get("username") sesami_mobile_password_required = args.get("sesami_mobile_password_required") sesami_slim_password_required = args.get("sesami_slim_password_required") gaia_ttw_level = args.get("gaia_ttw_level") params = {} if not sesami_mobile_password_required: params["sesami_mobile_password_required"] = sesami_mobile_password_required if not sesami_slim_password_required: params["sesami_slim_password_required"] = sesami_slim_password_required if not gaia_ttw_level: params["gaia_ttw_level"] = gaia_ttw_level result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Sesami Authentication Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserSesamiAuthenticationSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_totpauthentication_settings(client, args): username = args.get("username") totp_accept_tolerance = args.get("totp-accept-tolerance") totp_resend_tolerance = args.get("totp-resend-tolerance") totp_resend_timeout = args.get("totp-resend-timeout") totp_password_required = args.get("totp-password-required") totp_flex_password_required = args.get("totp-flex-password-required") totp_flex_pin_password_required = args.get("totp-flex-pin-password-required") totp_mobile_password_required = args.get("totp-mobile-password-required") params = {} if not totp_accept_tolerance: params["totp_accept_tolerance"] = totp_accept_tolerance if not totp_resend_tolerance: params["totp_resend_tolerance"] = totp_resend_tolerance if not totp_resend_timeout: params["totp_resend_timeout"] = totp_resend_timeout if not totp_password_required: params["totp_password_required"] = totp_password_required if not totp_flex_password_required: params["totp_flex_password_required"] = totp_flex_password_required if not totp_flex_pin_password_required: params["totp_flex_pin_password_required"] = totp_flex_pin_password_required if not totp_mobile_password_required: params["totp_mobile_password_required"] = totp_mobile_password_required result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Totp Authentication Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserTotpAuthenticationSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_userauthentication_settings(client, args): username = args.get("username") multiple_step_auth_timeout = args.get("multiple-step-auth-timeout") allow_password = args.get("allow-password") allow_password_for_registration = args.get("allow-password-for-registration") max_allowed_failures = args.get("max-allowed-failures") allow_access_when_pwd_expired = args.get("allow-access-when-pwd-expired") allow_password_reset_when_forgot_pwd = args.get("allow-password-reset-when-forgot-pwd") min_otp_length = args.get("min-otp-length") max_otp_length = args.get("max-otp-length") dos_tmp_lockdown_max_fail_authentications = args.get("dos-tmp-lockdown-max-fail-authentications") dos_tmp_lockdown_time_interval_in_seconds = args.get("dos-tmp-lockdown-time-interval-in-seconds") dos_tmp_lockdown_time_in_seconds = args.get("dos-tmp-lockdown-time-in-seconds") params = {} if not multiple_step_auth_timeout: params["multiple_step_auth_timeout"] = multiple_step_auth_timeout if not allow_password: params["allow_password"] = allow_password if not allow_password_for_registration: params["allow_password_for_registration"] = allow_password_for_registration if not max_allowed_failures: params["max_allowed_failures"] = max_allowed_failures if not allow_access_when_pwd_expired: params["allow_access_when_pwd_expired"] = allow_access_when_pwd_expired if not allow_password_reset_when_forgot_pwd: params["allow_password_reset_when_forgot_pwd"] = allow_password_reset_when_forgot_pwd if not min_otp_length: params["min_otp_length"] = min_otp_length if not max_otp_length: params["max_otp_length"] = max_otp_length if not dos_tmp_lockdown_max_fail_authentications: params["dos_tmp_lockdown_max_fail_authentications"] = dos_tmp_lockdown_max_fail_authentications if not dos_tmp_lockdown_time_interval_in_seconds: params["dos_tmp_lockdown_time_interval_in_seconds"] = dos_tmp_lockdown_time_interval_in_seconds if not dos_tmp_lockdown_time_in_seconds: params["dos_tmp_lockdown_time_in_seconds"] = dos_tmp_lockdown_time_in_seconds result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User User Authentication Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserUserAuthenticationSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_virtualauthentication_settings(client, args): username = args.get("username") virtual_device_accept_tolerance = args.get("virtual-device-accept-tolerance") virtual_device_gateways = args.get("virtual-device-gateways") params = {} if not virtual_device_accept_tolerance: params["virtual_device_accept_tolerance"] = virtual_device_accept_tolerance if not virtual_device_gateways: params["virtual_device_gateways"] = virtual_device_gateways result_raw = client.set_user_settings(username, params) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Virtual Authentication Settings Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserVirtualAuthenticationSettings.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_group(client, args): username = args.get("username") result_raw = client.get_user_group(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Group Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserGroup.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def update_user_group(client, args): username = args.get("username") new_group_name = args.get("new-group-name") result_raw = client.get_user_group(username) old_group_name = None for group in result_raw.get("groups"): if bool(group.get("is_member")): old_group_name = group.get("name") if old_group_name and new_group_name: client.remove_user_group(username, old_group_name) client.add_user_group(username, new_group_name) result = {"message": "Successfully updated"} if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Update User Group Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="UpdateUserGroup.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def add_user_group(client, args): username = args.get("username") new_group_name = args.get("new-group-name") result_raw = client.add_user_group(username, new_group_name) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Add User Group Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="AddUserGroup.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def remove_user_group(client, args): username = args.get("username") old_group_name = args.get("old-group-name") result_raw = client.remove_user_group(username, old_group_name) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Remove User Group Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="RemoveUserGroup.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def get_user_registrationcode(client, args): username = args.get("username") result_raw = client.get_user_registrationcode(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Get User Registration Code Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="GetUserRegistrationCode.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def set_user_registrationcode(client, args): username = args.get("username") expiration = args.get("expiration") attempts_left = args.get("attempts-left") result_raw = client.set_user_registrationcode(username, expiration, attempts_left) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Set User Registration Code Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SetUserRegistrationCode.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def delete_user_registrationcode(client, args): username = args.get("username") result_raw = client.delete_user_registrationcode(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Delete User Registration Code Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="DeleteUserRegistrationCode.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def send_user_registrationcode(client, args): username = args.get("username") result_raw = client.send_user_registrationcode(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Send User Registration Code Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="SendUserRegistrationCode.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def create_user(client, args): username = args.get("username") password = args.get("password") firstname = args.get("firstname") lastname = args.get("lastname") mobilephone = args.get("mobilephone") email = args.get("email") result_raw = client.create_user(username, password, firstname, lastname, mobilephone, email) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Create User Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="CreateUser.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def delete_user(client, args): username = args.get("username") result_raw = client.delete_user(username) if result_raw: result_raw = json.loads(result_raw) result = remove_empty_elements(result_raw) else: result = {} readable_output = tableToMarkdown( "Delete User Results", result, headers=list(result.keys()), headerTransform=string_to_table_header, ) command_results = CommandResults( readable_output=readable_output, outputs_prefix="DeleteUser.Result", outputs_key_field="", outputs=result, raw_response=result_raw, ) return command_results def test_module(client): results = client.get_transactionlog(None, None, None) if results: results = json.loads(results).get("results") if results and len(results) > 0: if results[0].get("reason_detail") == "Invalid credentials": return "Failed to run test, invalid credentials." else: return "ok" return None else: return "Failed to run test." def main(): params = demisto.params() command = demisto.command() args = demisto.args() base_url = params.get("url") base_url = base_url + "/api/v1/admin/" demisto.info("BASE_URL" + base_url) verify_certificate = not params.get("insecure", False) auth_access_token = params.get("apikey") proxy = params.get("proxy", False) demisto.debug(f"Command being called is {command}") try: client = Client( base_url=base_url, verify=verify_certificate, headers={"Authorization": f"Bearer {auth_access_token}"}, proxy=proxy ) if command == "safewalk-get-transactionlog": result = get_transactionlog(client, args) return_results(result) if command == "safewalk-get-users": result = get_users(client, args) return_results(result) if command == "safewalk-get-ldap-users": result = get_ldap_users(client, args) return_results(result) if command == "safewalk-get-ldaps": result = get_ldaps(client, args) return_results(result) if command == "safewalk-get-user-personalinformation": result = get_user_personalinformation(client, args) return_results(result) if command == "safewalk-set-user-personalinformation": result = set_user_personalinformation(client, args) return_results(result) if command == "safewalk-get-user-accessattempts": result = get_user_accessattempts(client, args) return_results(result) if command == "safewalk-delete-user-accessattempts": result = delete_user_accessattempts(client, args) return_results(result) if command == "safewalk-create-user-token-virtual": result = create_user_token_virtual(client, args) return_results(result) if command == "safewalk-create-user-token-fastauth": result = create_user_token_fastauth(client, args) return_results(result) if command == "safewalk-create-user-token-totpmobile": result = create_user_token_totpmobile(client, args) return_results(result) if command == "safewalk-create-user-token-totmobilehybrid": result = create_user_token_totmobilehybrid(client, args) return_results(result) if command == "safewalk-create-user-token-physical": result = create_user_token_physical(client, args) return_results(result) if command == "safewalk-create-user-token-backup": result = create_user_token_backup(client, args) return_results(result) if command == "safewalk-update-user-token": result = update_user_token(client, args) return_results(result) if command == "safewalk-get-user-tokens": result = get_user_tokens(client, args) return_results(result) if command == "safewalk-delete-user-token": result = delete_user_token(client, args) return_results(result) if command == "safewalk-send-user-token": result = send_user_token(client, args) return_results(result) if command == "safewalk-send-user-virtualtoken": result = send_user_virtualtoken(client, args) return_results(result) if command == "safewalk-get-user-settings": result = get_user_settings(client, args) return_results(result) if command == "safewalk-set-user-backuptoken-settings": result = set_user_backuptoken_settings(client, args) return_results(result) if command == "safewalk-set-user-general-settings": result = set_user_general_settings(client, args) return_results(result) if command == "safewalk-set-user-hotpauthentication-settings": result = set_user_hotpauthentication_settings(client, args) return_results(result) if command == "safewalk-set-user-sesamiauthentication-settings": result = set_user_sesamiauthentication_settings(client, args) return_results(result) if command == "safewalk-set-user-totpauthentication-settings": result = set_user_totpauthentication_settings(client, args) return_results(result) if command == "safewalk-set-user-userauthentication-settings": result = set_user_userauthentication_settings(client, args) return_results(result) if command == "safewalk-set-user-virtualauthentication-settings": result = set_user_virtualauthentication_settings(client, args) return_results(result) if command == "safewalk-get-user-group": result = get_user_group(client, args) return_results(result) if command == "safewalk-update-user-group": result = update_user_group(client, args) return_results(result) if command == "safewalk-add-user-group": result = add_user_group(client, args) return_results(result) if command == "safewalk-remove-user-group": result = remove_user_group(client, args) return_results(result) if command == "safewalk-get-user-registrationcode": result = get_user_registrationcode(client, args) return_results(result) if command == "safewalk-set-user-registrationcode": result = set_user_registrationcode(client, args) return_results(result) if command == "safewalk-delete-user-registrationcode": result = delete_user_registrationcode(client, args) return_results(result) if command == "safewalk-send-user-registrationcode": result = send_user_registrationcode(client, args) return_results(result) if command == "safewalk-create-user": result = create_user(client, args) return_results(result) if command == "safewalk-delete-user": result = delete_user(client, args) return_results(result) if command == "test-module": result = test_module(client) return_results(result) # Log exceptions except Exception as e: return_error(f"Failed to execute {command} command. Error: {str(e)}") if __name__ in ("__main__", "__builtin__", "builtins"): main()