def get_list_of_guardian_enrollments(self, user_id):
if self.debug:
print('command - get_list_of_guardian_enrollments'+lineno())
users = Users(self.domain, self.token)
results = users.get_guardian_enrollments(user_id=user_id)
return pretty(results)
def blacklist_a_token(self, body):
if self.debug:
print('command - blacklist a token'+lineno())
blacklists = Blacklists(self.domain, self.token)
return pretty(blacklists.create())
def list_enrollment_templates(self):
if self.debug:
print('command - list_enrollment_templates'+lineno())
guardian = Guardian(self.domain, self.token)
return pretty(guardian.get_templates())
def delete_a_users_multifactor_provider(self, user_id, provider):
if self.debug:
print('command - delete user multifactor provider'+lineno())
users = Users(self.domain, self.token)
results = users.delete_multifactor(id=user_id, provider=provider)
return pretty(results)
def delete_user(self, user_id):
if self.debug:
print('command - delete'+lineno())
users = Users(self.domain, self.token)
results = users.delete(id=user_id)
return pretty(results)
def unlink_a_user_identity(self, id, provider, user_id ):
if self.debug:
print('command - unlink_a_user_identity'+lineno())
users = Users(self.domain, self.token)
results = users.unlink_user_account(id=id, provider=provider, user_id=user_id)
return pretty(results)
def get_a_user(self, id, fields, include_fields):
if self.debug:
print('command - get_a_user'+lineno())
users = Users(self.domain, self.token)
results = users.get(id=id, fields=fields, include_fields=include_fields)
return pretty(results)
def link_a_user_account(self, id, body):
if self.debug:
print('command - link_a_user_account'+lineno())
users = Users(self.domain, self.token)
results = users.link_user_account(user_id=id, body=body)
return pretty(results)
def search_log_events(
self,
page,
per_page,
sort,
fields,
include_fields,
include_totals,
from_id,
take,
query
):
if self.debug:
print('command - search_log_events'+lineno())
logs = Logs(self.domain, self.token)
return pretty(logs.search(
page=page,
per_page=per_page,
sort=sort,
q=query,
include_totals=include_totals,
fields=fields,
from_param=from_id,
take = take
))
def list_sns_factor_provider_config(self):
if self.debug:
print('command - list_sns_factor_provider_config'+lineno())
guardian = Guardian(self.domain, self.token)
return pretty(guardian.get_factor_providers(factor_name='push-notification',name='sns'))
def get_blacklist(self):
if self.debug:
print('command - get_blacklists'+lineno())
blacklists = Blacklists(self.domain, self.token)
return pretty(blacklists.get())
def daily_stats(self,days):
if self.debug:
print('command - daily_stats'+lineno())
stats = Stats(self.domain, self.token)
old_date = datetime.today() - timedelta(days=int(days))
return pretty(stats.daily_stats(from_date=old_date.strftime('%Y%m%d'), to_date=date.today().strftime('%Y%m%d')))
def create_user(self, body):
if self.debug:
print('command - create'+lineno())
users = Users(self.domain, self.token)
body = json.loads(body)
# See if the connection is valid
connection_ids = []
connections = json.loads(self.get_all_connections())
for conn in connections:
print('conn: '+str(conn))
if 'name' in conn:
print('found name')
connection_ids.append(conn['name'])
if 'connection' in body and body['connection'] not in connection_ids:
print('The connection id should be : '+str(pretty(connection_ids)))
sys.exit(1)
results = users.create(body=body)
return pretty(results)
def get_all_connections(self):
if self.debug:
print('command - get_connections'+lineno())
connection_data = []
connections_per_page = 10
connections = Connections(self.domain, self.token)
pages = math.ceil(len(connections.all()) / connections_per_page)
for page in range(pages):
results = connections.all(page=page, per_page=connections_per_page)
for connection in results:
connection_data.append(connection)
return pretty(connection_data)
def get_client_grants(self):
if self.debug:
print('command - get_client_grants'+lineno())
grant_data = []
grants_per_page = 10
grants = ClientGrants(self.domain, self.token)
pages = math.ceil(len(grants.all()) / grants_per_page)
for page in range(pages):
results = grants.all(page=page, per_page=grants_per_page)
for data in results:
grant_data.append(data)
return pretty(grant_data)
def get_user_log_events(self, user_id):
if self.debug:
print('command - get_user_log_events'+lineno())
print('user_id: '+str(user_id))
log_data = []
logs_per_page = 10
users = Users(self.domain, self.token)
pages = math.ceil(len(users.get_log_events(user_id=user_id, per_page=0)) / logs_per_page)
for page in range(pages):
results = users.get_log_events(user_id=user_id,page=page, per_page=logs_per_page)
for log in results:
log_data.append(log)
return pretty(log_data)
def list_users(self):
if self.debug:
print('command - list_users'+lineno())
user_data = []
users_per_page = 10
users = Users(self.domain, self.token)
pages = math.ceil(users.list(per_page=0, search_engine='v3')['total'] / users_per_page)
total_users = int(pages)*int(users_per_page)
acceptable_number_of_pages = math.ceil(1000 / int(users_per_page))
if self.debug:
print('number of pages: '+str(pages))
print('total_users: '+str(total_users))
print('acceptable number of pages: '+str(acceptable_number_of_pages))
if pages > acceptable_number_of_pages:
pages = acceptable_number_of_pages -1
print("\n##############################")
print('Limited to a 1000 users by the api')
print("#################################\n")
if self.debug:
pages=1
for page in range(pages):
results = users.list(search_engine='v3',page=page, per_page=users_per_page)
if 'users' in results:
for user in results['users']:
user_data.append(user)
return pretty(user_data)
def user_by_email(self, email):
if self.debug:
print('command - user_by_email'+lineno())
users = UsersByEmail(self.domain, self.token)
return pretty(users.search_users_by_email(email=email))
def unblock_a_user(self, id):
if self.debug:
print('command - unblock_a_user'+lineno())
blocks = UserBlocks(self.domain, self.token)
return pretty(blocks.unblock(id=id))
def unblock_by_identifier(self, identifier):
if self.debug:
print('command - unblock_by_identifier'+lineno())
blocks = UserBlocks(self.domain, self.token)
return pretty(blocks.unblock_by_identifier(identifier=identifier))
def list_user_blocks(self, user_id):
if self.debug:
print('command - list_user_blocks'+lineno())
blocks = UserBlocks(self.domain, self.token)
return pretty(blocks.get(id=user_id))
def remove_rules_config_for_given_key(self,key):
if self.debug:
print('command - remove_rules_config_for_given_key'+lineno())
rules = RulesConfigs(self.domain, self.token)
return pretty(rules.remove(key))
def set_the_rules_config_for_a_given_key(self,key, body):
if self.debug:
print('command - set_the_rules_config_for_a_given_key'+lineno())
rules = RulesConfigs(self.domain, self.token)
return pretty(rules.set_rule_for_key(key=key, body=body))
def active_users(self):
if self.debug:
print('command - active_users'+lineno())
stats = Stats(self.domain, self.token)
return pretty(stats.active_users())
def get_tenants(self):
if self.debug:
print('command - get_tenant'+lineno())
tenants = Tenants(self.domain, self.token)
return pretty(tenants.get())
def update_tenant_settings(self, body):
if self.debug:
print('command - update_tenant_settings'+lineno())
tenants = Tenants(self.domain, self.token)
return pretty(tenants.update(body=body))
def create_an_email_verification_ticket(self, body):
if self.debug:
print('command - create_an_email_verification_ticket'+lineno())
tickets = Tickets(self.domain, self.token)
return pretty(tickets.create_email_verification(body=body))
def create_a_password_change_ticket(self, body):
if self.debug:
print('command - create_a_password_change_ticket'+lineno())
tickets = Tickets(self.domain, self.token)
return pretty(tickets.create_pswd_change(body=body))
def dump_account_details(ini, debug):
# Get client
client = Auth0Client(get_config_dict(ini, debug))
# Get all clients applications
print("\n#######################")
print('Client Applications')
print("#########################")
client_data = client.get_all_client_applications()
# Clean the json
#client_data = client_data.replace('"utf-8"','\"utf-8\"').replace('"X-UA-Compatible"','\"X-UA-Compatible\"')
print(client_data)
if debug:
print('trying to load client data' + lineno())
#client_data = json.loads(client_data[0])
if debug:
print('done loading client data: ' + lineno())
client_ids = {}
for client_info in client_data:
if 'client_id' in client_info:
temp = {}
temp['client_id'] = client_info['client_id']
temp['name'] = client_info['name']
client_ids[client_info['client_id']] = client_info['name']
print('client ids:')
print(pretty(client_ids))
input("\n\nPress Enter To Continue\n")
# Get all users
print("\n#######################")
print('Users')
print("#########################")
user_data = client.list_users()
#print(user_data)
user_data = json.loads(user_data)
user_ids = []
for user in user_data:
print('user: '******'user_id' in user and 'email' in user:
user_ids.append(user['user_id'])
print('###################')
print('id: ' + str(user['user_id']))
print('email:' + str(user['email']))
print('###################')
print("\n\t#######################")
print("\t" + 'Guardian Enrollments')
print("\t#########################")
guardian_enrollment_data = client.get_list_of_guardian_enrollments(
user_id=user['user_id'])
print(guardian_enrollment_data)
print("\n\t#######################")
print("\t" + 'User Blocks')
print("\t#########################")
user_blocks_data = client.list_user_blocks(user_id=user['user_id'])
print(user_blocks_data)
print("\n\t#######################")
print("\t" + 'User Logs')
print("\t#########################")
user_logs_data = client.get_user_log_events(
user_id=user['user_id'])
print(user_logs_data)
input("\n\nPress Enter To Continue\n")
# Get all rules
print("\n#######################")
print('Rules')
print("#########################")
rules_data = client.get_all_rules()
print(rules_data)
input("\n\nPress Enter To Continue\n")
# Get all grants
print("\n#######################")
print('Grants')
print("#########################")
grants_data = client.get_client_grants()
print(grants_data)
grants_data = json.loads(grants_data)
grant_ids = {}
for grants_info in grants_data:
if 'client_id' in grants_info and 'audience' in grants_info:
temp = {}
temp['client_id'] = grants_info['client_id']
temp['audience'] = grants_info['audience']
grant_ids[grants_info['id']] = []
grant_ids[grants_info['id']].append(temp)
print("\n###### Grant Ids #########")
print(pretty(grant_ids))
input("\n\nPress Enter To Continue\n")
# Get more grants
for id in grant_ids:
print(grant_ids[id])
for user in user_ids:
print('user: '******'client_id'],
audience=grant_ids[id][0]['audience'])
print(user_grants)
input("\n\nPress Enter To Continue\n")
# Get all connections
print("\n#######################")
print('Connections')
print("#########################")
connection_data = client.get_all_connections()
print(connection_data)
input("\n\nPress Enter To Continue\n")
# Get all Guardian Factors
print("\n#######################")
print('Guardian Factors')
print("#########################")
factor_data = client.list_factors()
print(factor_data)
input("\n\nPress Enter To Continue\n")
# Get all Guardian Enrollment Templates
print("\n#######################")
print('Guardian Enrollment Templates')
print("#########################")
template_data = client.list_enrollment_templates()
print(template_data)
input("\n\nPress Enter To Continue\n")
# Get all Guardian SNS Factor Provider Config
print("\n#######################")
print('Guardian SNS Factor Provider Config')
print("#########################")
sns_factor_config_data = client.list_sns_factor_provider_config()
print(sns_factor_config_data)
input("\n\nPress Enter To Continue\n")
# Get all Guardian Twilio Factor Provider Config
print("\n#######################")
print('Guardian Twilio Factor Provider Config')
print("#########################")
twilio_factor_config_data = client.list_twilio_factor_provider_config()
print(twilio_factor_config_data)
input("\n\nPress Enter To Continue\n")
# Get all Resource Servers
print("\n#######################")
print('Resource Servers')
print("#########################")
resource_data = client.get_all_resource_servers()
print(resource_data)
input("\n\nPress Enter To Continue\n")
# Daily Stats
print("\n#######################")
print('Daily Stats')
print("#########################")
stats_data = client.daily_stats(2)
print(stats_data)
input("\n\nPress Enter To Continue\n")
# Tenants
print("\n#######################")
print('Tenants')
print("#########################")
tenants_data = client.get_tenants()
print(tenants_data)
def generate_new_user_guardian_recovery_code(self, user_id):
if self.debug:
print('command - generate_new_user_guardian_recovery_code'+lineno())
users = Users(self.domain, self.token)
return pretty(users.regenerate_recovery_code(user_id=user_id))
