def get_accounts_by_guid(account_guid, **kwargs):
"""
GET on accounts by account_guid
:param account_guid:
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
try:
AccountsService.get_user_permission_on_account(
user=current_user, account_guid=account_guid)
except Exception as e:
if e.message == '[Services] user doesn\'t have permission on account':
return HttpResponse.forbidden(e.message)
if current_user.is_system:
return HttpResponse.accepted(
'All accounts should be returned [unimplemented]')
else:
accounts = AccountsService.get_account_by_guid(
account_guid=account_guid)
if not len(accounts) or len(accounts) == 0:
return HttpResponse.bad_request('The account doesn\'t exist')
return HttpResponse.success(
Transformer.account_to_json(accounts[0]))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def authenticate():
email = request.json['email']
password = request.json['password']
try:
user = UserService.get_user_by_email(email=email)[0]
except Exception as e:
return HttpResponse.internal_server_error(e.message)
if user:
if user.password == password:
claims_token = TokenService.create_jwt_token(
user_guid=user.user_guid)
response = {'claims_token': claims_token}
return HttpResponse.success(response)
return HttpResponse.unauthorized('Incorrect username or password')
def authenticate():
email = request.json['email']
password = request.json['password']
try:
user = UserService.get_user_by_email(email=email)[0]
except Exception as e:
return HttpResponse.internal_server_error(e.message)
if user:
if user.password == password:
claims_token = TokenService.create_jwt_token(user_guid=user.user_guid)
response = {
'claims_token': claims_token
}
return HttpResponse.success(response)
return HttpResponse.unauthorized('Incorrect username or password')
def get_accounts(**kwargs):
"""
GET on accounts
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
if current_user.is_system:
return HttpResponse.accepted('All accounts should be returned [unimplemented]')
else:
accounts = AccountsService.get_all_accounts_by_user(user_id=current_user.user_id)
return HttpResponse.success(Transformer.account_list_to_json_array(accounts))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def add_user_to_account(account_guid, **kwargs):
"""
This api adds users to account
:param account_guid:
:return:
"""
try:
new_user = UserService.get_user_by_email(email=request.json['email'])[0]
current_user = kwargs['current_user']
try:
permission = AccountsService.get_user_permission_on_account(user=current_user, account_guid=account_guid)
if permission == AccountPermissions.MEMBER:
HttpResponse.forbidden('User doesn\'t have permission to perform this operation')
except Exception as e:
if e.message == '[Services] user doesn\'t have permission on account':
return HttpResponse.forbidden(e.message)
if not new_user:
return HttpResponse.bad_request('This user is unknown to archaea')
else:
AccountsService.add_user_to_account(
account_guid=account_guid,
user=new_user
)
return HttpResponse.accepted('User has been added successfully')
except Exception as e:
HttpResponse.internal_server_error(e.message)
def get_accounts(**kwargs):
"""
GET on accounts
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
if current_user.is_system:
return HttpResponse.accepted(
'All accounts should be returned [unimplemented]')
else:
accounts = AccountsService.get_all_accounts_by_user(
user_id=current_user.user_id)
return HttpResponse.success(
Transformer.account_list_to_json_array(accounts))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def create_nerd(account_guid, **kwargs):
try:
nerd_name = request.json['name']
nerd_url = request.json['url']
current_user = kwargs['current_user']
account = AccountsService.get_account_by_guid(account_guid=account_guid)
if not account:
return HttpResponse.forbidden('The account doesn\'t exist')
user_permission = AccountUserService.get_permission(user=current_user, account=account)
if not user_permission:
return HttpResponse.forbidden('User doesn\'t have permission to perform this operation')
# TODO Provision request to create a AWS instance and deploy the nerd
NerdService.create_nerd(account=account,
nerd_name=nerd_name,
nerd_url=nerd_url,
user=current_user)
return HttpResponse.accepted('Nerd entry created in design db. This doesn\'t mean nerd has been created.')
except Exception as e:
return HttpResponse.bad_request(e.message)
def create_account(**kwargs):
try:
try:
account_type = request.json['type']
account_name = request.json['name']
company = request.json['company']
except Exception:
return HttpResponse.bad_request(
'One or more parameters are missing')
if not account_type or not account_name:
return HttpResponse.bad_request('Incomplete parameters')
current_user = kwargs['current_user']
if current_user.is_system:
AccountsService.create_account(current_user,
company=ProjectDetails.COMPANY_NAME,
account_name=account_name,
account_type=account_type)
return HttpResponse.accepted('Account created successfully')
else:
# TODO creating enterprise account. Do take the credit card details.
if account_type == AccountTypes.ENTERPRISE:
AccountsService.create_account(
current_user,
account_name=account_name,
company=company,
account_type=AccountTypes.ENTERPRISE)
return HttpResponse.accepted('Account created successfully')
else:
return HttpResponse.forbidden(
'You are not allowed to create this account')
except Exception as e:
return HttpResponse.bad_request(e.message)
def create_account(**kwargs):
try:
try:
account_type = request.json['type']
account_name = request.json['name']
company = request.json['company']
except Exception:
return HttpResponse.bad_request('One or more parameters are missing')
if not account_type or not account_name:
return HttpResponse.bad_request('Incomplete parameters')
current_user = kwargs['current_user']
if current_user.is_system:
AccountsService.create_account(current_user,
company=ProjectDetails.COMPANY_NAME,
account_name=account_name,
account_type=account_type)
return HttpResponse.accepted('Account created successfully')
else:
# TODO creating enterprise account. Do take the credit card details.
if account_type == AccountTypes.ENTERPRISE:
AccountsService.create_account(current_user,
account_name=account_name,
company=company,
account_type=AccountTypes.ENTERPRISE)
return HttpResponse.accepted('Account created successfully')
else:
return HttpResponse.forbidden('You are not allowed to create this account')
except Exception as e:
return HttpResponse.bad_request(e.message)
def get_nerd_by_guid(account_guid, nerd_guid, **kwargs):
"""
GET on accounts by account_guid
:param bot_guid:
:param account_guid:
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
account = AccountsService.get_account_by_guid(account_guid=account_guid)
if not account:
return HttpResponse.forbidden('Unexpected request')
user_permission = AccountUserService.get_permission(user=current_user, account=account)
if not user_permission:
return HttpResponse.forbidden('User doesn\'t have permission to perform this operation')
if current_user.is_system:
return HttpResponse.accepted('All accounts should be returned [unimplemented]')
else:
nerds = NerdService.get_nerd_guid(account=account, user=current_user, nerd_guid=nerd_guid)
if len(nerds) == 0:
return HttpResponse.bad_request('The nerd you are looking for is not found in this account')
return HttpResponse.success(Transformer.nerd_to_json(nerds[0]))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def create_user():
try:
try:
email = request.json['email']
password = request.json['password']
first_name = request.json['first_name']
last_name = request.json['last_name']
company = request.json['company']
except Exception:
return HttpResponse.bad_request('One or parameters are missing')
user_by_email = UserService.get_user_by_email(email=email)
if len(user_by_email) > 0:
return HttpResponse.bad_request('An user account with this email already exists')
UserService.create_user_and_add_to_niche(
email=email,
password=password,
first_name=first_name,
last_name=last_name,
company=company)
return HttpResponse.accepted('User created and added to niche account successfully')
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def get_nerds(account_guid, **kwargs):
"""
GET on bots
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
account = AccountsService.get_account_by_guid(account_guid=account_guid)
if not account:
return HttpResponse.forbidden('Unexpected request')
user_permission = AccountUserService.get_permission(user=current_user, account=account)
if not user_permission:
return HttpResponse.forbidden('User doesn\'t have permission to perform this operation')
if current_user.is_system:
return HttpResponse.accepted('All accounts should be returned [unimplemented]')
else:
bots = NerdService.read(account=account, user=current_user)
return HttpResponse.success(Transformer.nerd_list_to_json_array(bots))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def get_application(account_guid, nerd_guid, application_guid, **kwargs):
try:
current_user = kwargs['current_user']
account = AccountsService.get_account_by_guid(
account_guid=account_guid)
if not account:
return HttpResponse.forbidden('Account doesn\'t exists')
user_permission = AccountUserService.get_permission(user=current_user,
account=account)
if not user_permission:
return HttpResponse.forbidden(
'User doesn\'t have permission to perform this operation')
nerd = NerdService.get_nerd_guid(account=account,
user=current_user,
nerd_guid=nerd_guid)
if len(nerd) == 0:
return HttpResponse.forbidden(
'The user has no permission on this nerd')
nerd_response = ApplicationService.get_application_by_guid(
nerd_url=nerd[0].nerd_url, application_guid=application_guid)
return HttpResponse.custom_http_response(loads(nerd_response.text),
nerd_response.status_code)
except Exception as e:
return HttpResponse.bad_request(e.message)
def get_accounts_by_guid(account_guid, **kwargs):
"""
GET on accounts by account_guid
:param account_guid:
:param kwargs:
:return:
"""
try:
current_user = kwargs['current_user']
try:
AccountsService.get_user_permission_on_account(user=current_user, account_guid=account_guid)
except Exception as e:
if e.message == '[Services] user doesn\'t have permission on account':
return HttpResponse.forbidden(e.message)
if current_user.is_system:
return HttpResponse.accepted('All accounts should be returned [unimplemented]')
else:
accounts = AccountsService.get_account_by_guid(account_guid=account_guid)
if not len(accounts) or len(accounts) == 0:
return HttpResponse.bad_request('The account doesn\'t exist')
return HttpResponse.success(Transformer.account_to_json(accounts[0]))
except Exception as e:
return HttpResponse.internal_server_error(e.message)
def create_application(account_guid, nerd_guid, **kwargs):
try:
try:
name = request.json['name']
algorithm = request.json['algorithm']
app_metadata = request.json['app_metadata']
except Exception:
return HttpResponse.bad_request(
'One or more parameters are missing')
current_user = kwargs['current_user']
account = AccountsService.get_account_by_guid(
account_guid=account_guid)
if not account:
return HttpResponse.forbidden('Account doesn\'t exists')
user_permission = AccountUserService.get_permission(user=current_user,
account=account)
if not user_permission:
return HttpResponse.forbidden(
'User doesn\'t have permission to perform this operation')
nerd = NerdService.get_nerd_guid(account=account,
user=current_user,
nerd_guid=nerd_guid)
if len(nerd) == 0:
return HttpResponse.forbidden(
'The user has no permission on this nerd')
nerd_response = ApplicationService.create_application(
account_id=account.account_id,
application_name=name,
application_algorithm=algorithm,
created_user_id=current_user.user_id,
parameters=app_metadata,
nerd_url=nerd[0].nerd_url)
return HttpResponse.custom_http_response(loads(nerd_response.text),
nerd_response.status_code)
except Exception as e:
return HttpResponse.bad_request(e.message)