def initiate_auth(username, password):
resp = None
try:
resp = client.admin_initiate_auth(UserPoolId=USER_POOL_ID,
ClientId=CLIENT_ID,
AuthFlow='ADMIN_NO_SRP_AUTH',
AuthParameters={
'USERNAME':
username,
'SECRET_HASH':
get_secret_hash(username),
'PASSWORD':
password
},
ClientMetadata={
'username': username,
'password': password
})
except client.exceptions.NotAuthorizedException as e:
traceback.print_exc(file=sys.stdout)
#raise Exception("400: The username or password is incorrect") #REMOVED
raise exceptions.ValidationError(
"400: Username or password is incorrect")
except Exception as e:
traceback.print_exc(file=sys.stdout)
exceptions.server_error(e)
return resp, None
def delete(self, request, pk=None):
lead = get_object(pk)
try:
lead.delete()
return Response({"status": "success"}, status=status.HTTP_200_OK)
except Exception as err:
raise server_error({"status": "failure", "reason": str(err)})
def delete_policy_address(request):
"""
Delete an address policy level
"""
try:
response = generic_procbridge_request('delete_client', request.body)
except:
return server_error(request)
return response
def delete_policy_group(request):
"""
Delete a group policy level
"""
try:
response = generic_procbridge_request('delete_group', request.body)
except:
return server_error(request)
return response
def add_policy_group(request):
"""
Add a group policy level
"""
try:
response = generic_procbridge_request('add_group', request.body)
except:
return server_error(request)
return response
def module_schema(request):
"""
Get the schema information of modules
"""
try:
response = generic_procbridge_request('get_module_configs')
except:
return server_error(request)
return response
def module_config(request):
"""
Get the current module configurations
"""
try:
response = generic_procbridge_request('read_state')
except:
return server_error(request)
return response
def destroy(self, request, pk=None):
try:
ann = self.mapped_object_class.get(id=pk)[0]
ann.delete()
except IndexError:
return does_not_exists()
except RuntimeError:
return server_error(request, None)
return Response({})
def update_policy_network(request):
"""
Update the network policy level
"""
try:
response = generic_procbridge_request('update_network_policy',
request.body)
except Exception as e:
print(e)
return server_error(request)
return response
def authenticate(self, request):
user = User()
try:
client = boto3.client('cognito-idp',
region_name=settings.AWS_REGION,
aws_access_key_id=settings.ACCESS_KEY,
aws_secret_access_key=settings.ACCESS_SECRET)
except (Exception):
traceback.print_exc(file=sys.stdout)
msg = ("Connection to Cognito IDP failed")
exceptions.server_error(msg)
try:
authToken = request.META.get('HTTP_AUTHORIZATION', b'')
token = authToken.split()[1]
# print(token)
userInformation = client.get_user(AccessToken=token)
user.username = userInformation['Username']
for userAttributes in userInformation['UserAttributes']:
if userAttributes['Name'] == 'email':
user.email = userAttributes['Value']
groupInformation = client.admin_list_groups_for_user(
Username=userInformation["Username"],
UserPoolId=settings.COGNITO_USER_POOL_ID)
groupList = groupInformation['Groups']
settings.USER_GROUPS = []
for group in groupList:
settings.USER_GROUPS.append(group['GroupName'])
settings.ALL_GROUPS = []
groups = client.list_groups(
UserPoolId=settings.COGNITO_USER_POOL_ID)
for group in groups['Groups']:
settings.ALL_GROUPS.append(group["GroupName"])
#print("all groups " + str(settings.ALL_GROUPS))
except Exception as e:
traceback.print_exc(file=sys.stdout)
msg = ('Authorization token is not valid.')
raise exceptions.AuthenticationFailed(msg)
return (user, None) #authentication successful
def get_object(pk):
if not pk:
raise ValidationError({
"status": "failure",
"reason": "lead_id is required"
})
try:
return Lead.objects.get(pk=pk)
except Lead.DoesNotExist:
raise NotFound({})
except Exception as err:
raise server_error({"status": "failure", "reason": str(err)})
def tiles_data(request):
"""
Get data for a specific tile
"""
try:
if 'name' in request.data:
response = generic_procbridge_request(request.data['name'], None,
PROC_PORT_DATA)
else:
raise ProcessLookupError("Invalid request")
except Exception as e:
print(e)
return server_error(request)
return response
def update(self, request, pk=None):
try:
ann = self.mapped_object_class.get(id=pk)[0]
except IndexError:
return does_not_exists()
try:
for field in self.mapped_object_class.required_fields:
setattr(ann, field, request.POST.get(field, getattr(ann, field)))
ann.update()
except KeyError:
return bad_request(request, None)
except RuntimeError:
return server_error(request, None)
serializer = self.serializer_class(instance=ann)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
"""Upload image and save info to database, payload is an array of base64 string"""
images = request.data
if not images:
raise ("Lỗi, payload không đúng")
# Is request a list?
if not isinstance(images, list):
raise ParseError("request body is not iterable")
headers = {
'token': settings.SECRET_KEY,
'bucket': settings.DONTLOOP_BUCKET
}
try:
results = requests.post(settings.MEDIA_SERVER + "/images",
json=images,
headers=headers)
data = results.json()
print(data)
print(results)
return_images = []
for result in data:
original = result.get("original", None)
small = result.get("smallUrl", None)
medium = result.get("mediumUrl", None)
large = result.get("largeUrl", None)
image = Image.objects.create(original=original,
small=small,
medium=medium,
large=large)
return_images.append(image)
# Try to save image
return Response(
ImageSerializer(return_images, many=True).data,
status.HTTP_201_CREATED)
except Exception as e:
print(e)
raise server_error(request=request)
def test_server_error():
request = RequestFactory().get('/')
response = server_error(request)
assert response.status_code == 500
assert response["content-type"] == 'application/json'
def test_server_error():
request = RequestFactory().get('/')
response = server_error(request)
assert response.status_code == 500
assert response["content-type"] == 'application/json'
