def reset_password_link(space_id, data):
user_record = db_utils.find(space_id, domain, {
'email': data['email'],
'emailConfirmation': True
})
if len(user_record) < 1:
return (404, {'data': 'user does not exist'})
else:
db_utils.delete(space_id, domain_passwordresetcode,
{'userId': user_record[0]['_id']})
updated_record = db_utils.upsert(space_id, domain_passwordresetcode,
{'userId': user_record[0]['_id']})
if space_id == 100:
auth_url = ONEAUTH_URL + "/#/login?type=reset&auth=" + updated_record[
'_id']
else:
auth_url = ONEAUTH_URL + "/#/space/" + space_id + "/login?type=reset&auth=" + updated_record[
'_id']
message_body = email_template_service.compose_message(
'reset_password_link', {
'TEMPLATE_AUTH_URL':
auth_url,
'TEMPLATE_AUTH_CODE':
updated_record['_id'],
'TEMPLATE_USER_DISPLAY_NAME':
user_record[0]['firstName'] + ' ' + user_record[0]['lastName']
})
mail_utils.send_mail(data['email'],
"Link to reset your oneauth user account",
message_body)
return (200, {'data': 'password reset link sent'})
def do_delete_app(app_id):
appData = db_utils.find(database_name, domain, {'appId': app_id})
domain_id = []
for data in appData:
domain_id = data['_id']
roleData = db_utils.delete(database_name, 'role', {'domainId': domain_id})
deleteApp = db_utils.delete(database_name, app_id,{})
deleteAppData = db_utils.delete(database_name, domain,{'appId': app_id})
return (200, {'deletedData': ''})
def do_delete_space(space_id):
spaceData = db_utils.find(database_name, domain, {'spaceId': space_id})
domain_id = []
for data in spaceData:
domain_id = data['_id']
roleData = db_utils.delete(database_name, 'role', {'domainId': domain_id})
deleteSpace = db_utils.delete(database_name,space_id,{'spaceId':space_id})
deleteSpaceData = db_utils.delete(database_name, domain,{'spaceId': space_id})
dropped_database = db_utils.drop_database(space_id)
return (200, {'deletedData': dropped_database})
def delete_by_id(space_id, id, user_id):
task_result = db_utils.delete(space_id, domain, {'_id': id}, user_id)
attachment_result = db_utils.delete(space_id, domain_attachment,
{'taskId': id}, user_id)
comment_result = db_utils.delete(space_id, domain_comment, {'taskId': id},
user_id)
checklist_result = db_utils.delete(space_id, domain_checklistitem,
{'taskId': id}, user_id)
return {
'tasks_deleted': task_result.deleted_count,
'attachments_deleted': attachment_result.deleted_count,
'comments_deleted': comment_result.deleted_count,
'checklists_deleted': checklist_result.deleted_count
}
def delete(request, space_id, project_id, team_id):
if role_service.is_project_admin(space_id, request.user_id, project_id):
result = db_utils.delete(space_id, domain, {
'projectId': project_id,
'teamId': team_id
}, request.user_id)
return (200, {'deleted_count': result.deleted_count})
else:
return (401, {'data': 'unauthorized'})
def reset_password(space_id, auth_code, data):
reset_link = db_utils.find(space_id, domain_passwordresetcode,
{'_id': auth_code})
if len(reset_link) < 1:
return (404, {'data': 'password reset code is invalid'})
elif int(
(datetime.datetime.now() -
reset_link[0]['createdAt']).total_seconds()) > (2 * 24 * 60 * 60):
return (410, {'data': 'password reset code is expired'})
else:
user_data = db_utils.find(space_id, domain,
{'_id': reset_link[0]['userId']})
user_data[0]['password'] = data['password']
auth_user_data = get_user_with_auth_data(user_data[0])
db_utils.upsert(space_id, domain, auth_user_data)
db_utils.delete(space_id, domain_passwordresetcode,
{'userId': reset_link[0]['userId']})
return (200, {'data': 'password updated'})
def delete_role(request, type_name, user_id, domain_id):
print(type_name, user_id, domain_id)
out = db_utils.delete(database_name, domain, {
'type': type_name,
'userId': user_id,
'domainId': domain_id
})
print(out.deleted_count)
return (200, {'data': out.deleted_count})
def delete(request, space_id, id):
project_member_list = projectmember_service.find_by_projectid_userid(
request, space_id, id, request.user_id)
for item in project_member_list:
print(item)
if item['type'] == 'ADMINISTRATOR':
result = db_utils.delete(space_id, domain, {'_id': id},
request.user_id)
return 200, {'deleted_count': result.deleted_count}
else:
return 406, {'data': 'User is not a Member or administrator'}
def delete_by_id(request, space_id, id):
existing_record = db_utils.find(space_id, domain, {'_id': id})
if len(existing_record) == 1:
if role_service.is_project_admin(space_id, request.user_id,
existing_record[0]['projectId']):
result = db_utils.delete(space_id, domain, {'_id': id},
request.user_id)
return (200, {'deleted_count': result.deleted_count})
else:
return (401, {'data': 'unauthorized'})
else:
return (404, {'data': 'no matching role to remove'})
def send_email_confirmation_link(space_id, user):
db_utils.delete(space_id, domain_emailconfirmationcode,
{'userId': user['_id']})
updated_record = db_utils.upsert(space_id, domain_emailconfirmationcode,
{'userId': user['_id']})
if space_id == 100:
auth_url = ONEAUTH_URL + "/#/login?type=confirmemail&auth=" + updated_record[
'_id']
else:
auth_url = ONEAUTH_URL + "/#/space/" + space_id + "/login?type=confirmemail&auth=" + updated_record[
'_id']
message_body = email_template_service.compose_message(
'confirm_email_link', {
'TEMPLATE_AUTH_URL':
auth_url,
'TEMPLATE_AUTH_CODE':
updated_record['_id'],
'TEMPLATE_USER_DISPLAY_NAME':
user['firstName'] + ' ' + user['lastName']
})
mail_utils.send_mail(
user['email'],
"Confirm your email to activate your oneauth user account",
message_body)
def delete(request, space_id, data):
authorized = False
if data['type'] == 'ProjectAdministrator' or data[
'type'] == 'ProjectMember':
authorized = is_project_admin(space_id, request.user_id,
data['domainId'])
if authorized:
result = db_utils.delete(
space_id, domain, {
'type': data['type'],
'userId': data['userId'],
'domainId': data['domainId']
}, request.user_id)
return (200, {'deleted_count': result.deleted_count})
else:
return (401, {'data': 'unauthorized'})
def delete(request, space_id, id):
existing_record = db_utils.find(space_id, domain, {'_id': id})
if len(existing_record) > 0:
authorized = False
if existing_record[0]['type'] == 'ProjectAdministrator':
authorized = is_project_admin(space_id, request.user_id,
existing_record[0]['domainId'])
elif existing_record[0]['type'] == 'TeamAdministrator':
authorized = is_team_admin(space_id, request.user_id,
existing_record[0]['domainId'])
if authorized:
result = db_utils.delete(space_id, domain, {'_id': id},
request.user_id)
return (200, {'deleted_count': result.deleted_count})
else:
return (401, {'data': 'unauthorized'})
else:
return (404, {'data': 'no matching role found'})
def delete(request, space_id, id):
tasks = db_utils.find(space_id, domain_task, {'stageId': id})
task_deleted_count = 0
task_attachment_deleted_count = 0
task_checklist_deleted_count = 0
task_comment_deleted_count = 0
for task in tasks:
result = task_service.delete_by_id(space_id, task['_id'],
request.user_id)
task_attachment_deleted_count += result['attachments_deleted']
task_checklist_deleted_count += result['checklists_deleted']
task_comment_deleted_count += result['comments_deleted']
task_deleted_count += result['tasks_deleted']
stage_result = db_utils.delete(space_id, domain, {'_id': id},
request.user_id)
return (200, {
'task_deleted_count': task_deleted_count,
'task_attachment_deleted_count': task_attachment_deleted_count,
'task_checklist_deleted_count': task_checklist_deleted_count,
'task_comment_deleted_count': task_comment_deleted_count,
'stages_deleted': stage_result.deleted_count
})
def delete(request, space_id, attachment_id):
result = db_utils.delete(space_id, domain, {'_id': attachment_id},
request.user_id)
return (200, {'deleted_count': result.deleted_count})
def invalidate_session_token(space_id, auth_key):
result = db_utils.delete(space_id, domain_session, {'key': auth_key})
if result.deleted_count > 0:
return (200, {'data': 'session invalidated'})
else:
return (404, {'data': 'no matching session'})
def delete_by_id(space_id, app_id):
out = db_utils.delete(database_name, domain, {
'spaceId': space_id,
'appId': app_id
})
return (200, {'deleted_count': out.deleted_count})
def delete(request, space_id, id):
result = db_utils.delete(space_id, domain, {'_id': id}, request.user_id)
return 200, {'deleted_count': result.deleted_count}
def delete(request, space_id, team_id, user_id):
result = db_utils.delete(space_id, domain, {
'teamId': team_id,
'userId': user_id
}, request.user_id)
return (200, {'deleted_count': result.deleted_count})