def post(self, request, format=None):
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
try:
if Account.objects.filter(productType=request.data['productType'], instanceId=request.data['instanceId']):
print (" [ERROR] There is an entry already with that InstanceId (%s) for the same ProductType (%s)" % (request.data['instanceId'], request.data['productType']))
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer.save()
#prepares and sends the message to the queue
message = {}
message['instanceId'] = request.data['instanceId']
message['event'] = request.data['status']
#send_msg(str(message))
send_msg(json.dumps(serializer.data))
#create the SLA agreements in the SLA module based on the already created templates
templateId = request.data['productType']+request.data['productId']+request.data['flavour']
createAgreement(templateId, request.data['clientId'], request.data['agreementId'])
#start the Agreement enforcement
f = restclient.Factory(settings.SLA_URL)
a_enforcement = f.enforcements()
a_enforcement.start(request.data['agreementId'])
except ReferenceError:
print " [ERROR] Could not update the messages queue"
return Response(status=status.HTTP_408_REQUEST_TIMEOUT)
except Exception as e:
print "DEBUG: ", e
return Response(status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, vnf_instance, new_status, format=None):
queryset = Account.objects.filter(productType=settings.VNF,
instanceId=vnf_instance)
if queryset.exists():
jsonStatus = '{"status":"' + new_status + '"}'
for account in queryset:
serializer = AccountSerializer(account,
data=json.loads(jsonStatus))
try:
if serializer.is_valid():
#saves the new status
serializer.save()
print "status changed "
#prepares and sends the message to the queue
message = {}
message['instanceId'] = vnf_instance
message['event'] = new_status
#send_msg(json.dumps(serializer.data))
return Response(serializer.data,
status=status.HTTP_201_CREATED)
except ReferenceError:
print " [ERROR] Could not update the messages queue"
return Response(status=status.HTTP_408_REQUEST_TIMEOUT)
except Exception:
return Response(status=status.HTTP_400_BAD_REQUEST)
return Response(queryset, status=status.HTTP_404_NOT_FOUND)
def get(self, request, format=None):
"""
---
parameters:
- name: vnfId
description: VNF ID
type: string
paramType: form
serializer: AccountSerializer
"""
if self.request.query_params:
vnfId = self.request.query_params.get('vnfId', None)
if vnfId is not None:
#find all the VNF running instances with the given VNF ID
queryset = Account.objects.filter(productId=vnfId, productType=settings.VNF, status=settings.STATUS_RUNNING)
serviceListing = list()
try:
for obj in queryset:
if (obj.relatives) is not None:
#find all the running services that use that VNF
serviceListing.append(Account.objects.filter(status=settings.STATUS_RUNNING, productType=settings.NETWORK_SERVICE, instanceId=obj.relatives)[0])
#remove duplicates
serviceListing= sorted(set(serviceListing))
serializer = AccountSerializer(serviceListing, many=True)
print "vnfid: ", vnfId
return Response(serializer.data)
except Exception:
print " [ERROR] Database malformed: the service does not exist."
#raise
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer = AccountSerializer(Account.objects.filter(productType=settings.VNF, status=settings.STATUS_RUNNING), many=True)
return Response(serializer.data)#, status=status.HTTP_400_BAD_REQUEST)
def accounts_delete(request):
"""
Function to manage the deletion of the accounts
"""
# Creating the default value
account = None
# If not declared in settings, configuring a default value
# http://www.django-rest-framework.org/api-guide/exceptions/#exception-handling-in-rest-framework-views
try:
nfe = settings.NON_FIELD_ERRORS_KEY
except AttributeError:
nfe = 'non_field_errors'
# Parsing data from the request and changing the creator field for the user who did the request
data = JSONParser().parse(request)
data['creator'] = request.user.pk
# Check if all the data is valid to be used
serializer = AccountSerializer(data=data)
if serializer.is_valid():
# If valid, try to get the model instance to check if already exists
try:
account = Account.objects.get(id=serializer.validated_data['id'])
# Check if the creator is who did the request
if request.user.pk == account.creator.pk:
account.delete()
return Response({
'status': 'ok',
'message': 'deleted'
})
else:
return Response(
{
'errors': {
nfe: 'No permissions',
}
},
status=status.HTTP_400_BAD_REQUEST,
)
except Account.DoesNotExist:
return Response(
{
'errors': {
nfe: 'Not exists',
}
},
status=status.HTTP_400_BAD_REQUEST,
)
else:
return Response(
{
'errors': {
'data_validation_error': 'Error validating data',
}
},
status=status.HTTP_400_BAD_REQUEST,
)
def put(self, request, pk, format=None):
account = self.get_object(pk)
serializer = AccountSerializer(account, data=request.data)
print "request: ", request.data
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.account_data = {
'username': '******',
'email': '*****@*****.**',
'password': '******'
}
self.account = Account(**self.account_data)
self.account.save()
self.serializer = AccountSerializer(data=self.account_data)
def post(self, request):
if request.user.is_authenticated:
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
serializer.save(owner=request.user)
return JsonResponse(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, ns_instance, new_status, format=None):
"""
---
response_serializer: AccountSerializer
"""
queryset = Account.objects.filter(productType=settings.NETWORK_SERVICE, instanceId=ns_instance)
if queryset.exists():
jsonStatus='{"status":"' + new_status + '"}'
service = queryset[0]
serializer = AccountSerializer(service, data=json.loads(jsonStatus))
try:
if serializer.is_valid():
#saves the new status
serializer.save()
print "status changed "
#start/stop the SLA enforcement accordingly
if (new_status == settings.STATUS_RUNNING):
self.startEnforcement(service.agreementId)
if (new_status == settings.STATUS_STOPPED):
self.stopEnforcement(service.agreementId)
#prepares and sends the message to the queue
message = {}
message['instanceId'] = ns_instance
message['event'] = new_status
#print (json.dumps(serializer.data))
send_msg(json.dumps(serializer.data))
#update the status of the participant VNFs
vnf_list = service.relatives.replace(" ", "").split(",")
print "VNF list: ", vnf_list
for vnfInstance in vnf_list:
time.sleep(1)
print "VNF: ", vnfInstance
vnfquery = Account.objects.filter(productType=settings.VNF, instanceId=vnfInstance)
vnf = vnfquery[0]
vnfserializer = AccountSerializer(vnf, many=False, data=json.loads(jsonStatus))
if vnfserializer.is_valid():
#print "VNF2: ", json.dumps(vnfserializer.data)
vnfserializer.save()
#start/stop the SLA enforcement accordingly
if (new_status == settings.STATUS_RUNNING):
self.startEnforcement(vnf.agreementId)
if (new_status == settings.STATUS_STOPPED):
self.stopEnforcement(vnf.agreementId)
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ReferenceError:
print " [ERROR] Could not update the messages queue"
return Response(status=status.HTTP_408_REQUEST_TIMEOUT)
except Exception as e:
print " [ERROR] ", e
return Response(status=status.HTTP_400_BAD_REQUEST)
return Response(queryset, status=status.HTTP_404_NOT_FOUND)
def post(request):
account = Account.get_by_pk(request.user.username)
if account is None:
return Response({'detail': 'account is not found'},
status=status.HTTP_404_NOT_FOUND)
serializer = AccountSerializer(instance=account, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({'detail': 'account has been edited'},
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
data = request.data.copy()
data['password'] = gen_password(len_to=10)
serializer = AccountSerializer(data=data)
if serializer.is_valid():
serializer.save()
threading.Thread(target=self._send_credentials,
kwargs=data).start()
return Response({'detail': 'account has been created'},
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(request):
email = request.data.get('email')
if email is None:
return Response({'detail': 'email was not provided'},
status=status.HTTP_400_BAD_REQUEST)
account = Account.objects.filter(email=email).first()
if account is None:
return Response({'detail': 'account is not found'},
status=status.HTTP_404_NOT_FOUND)
if 'confirmation_code' not in request.data:
return Response({'detail': 'missing verification code'},
status=status.HTTP_400_BAD_REQUEST)
session = SessionStore(session_key=account.session_key)
if request.data.get('confirmation_code', '-1') == session['v_code']:
new_password = request.data.get('new_password', None)
new_password_confirm = request.data.get('new_password_confirm',
None)
if new_password is None or new_password_confirm is None:
return Response(
{'detail': 'missing new password or its confirmation'},
status=status.HTTP_400_BAD_REQUEST)
if new_password != new_password_confirm:
return Response({'detail': 'password confirmation failed'},
status=status.HTTP_400_BAD_REQUEST)
data = request.data.copy()
data['username'] = account.username
data['password'] = new_password
serializer = AccountSerializer(instance=account, data=data)
if serializer.is_valid():
serializer.save()
session.delete()
account.session_key = None
account.save()
try:
request.user.auth_token.delete()
except (AttributeError, ObjectDoesNotExist):
pass
logout(request)
return Response({'detail': 'password has been changed'},
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'detail': 'verification code is incorrect'},
status=status.HTTP_400_BAD_REQUEST)
def add(request):
data = AccountSerializer(data=request.data)
if not data.is_valid():
return Response({
'status': 400,
'result': False
},
status=resp_status.HTTP_404_NOT_FOUND)
uuid = data.validated_data['uuid']
value = data.validated_data['value']
try:
model = Account.objects.get(pk=uuid)
except ObjectDoesNotExist:
return Response({
'status': 400,
'result': False
},
status=resp_status.HTTP_404_NOT_FOUND)
if not model.status:
return Response(
{
'status': 405,
'result': False,
'addition': {
'uuid': model.uuid,
'name': model.name,
'balance': model.balance,
'status': model.status
},
'description': {
'status': 'Счет закрыт'
}
},
status=resp_status.HTTP_405_METHOD_NOT_ALLOWED)
model.balance += value
model.save()
return Response(
{
'status': 200,
'result': True,
'addition': {
'uuid': model.uuid,
'name': model.name,
'balance': model.balance,
'status': model.status
},
'description': {
'status': 'Счет пополнен'
}
},
status=resp_status.HTTP_200_OK)
def test_create(self):
data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'max_backups': 7
}
serializer = AccountSerializer(data=data)
serializer.create(data)
account = Account.objects.get(pk='test_username1')
self.assertEqual(account.email, data['email'])
self.assertEqual(account.username, data['username'])
self.assertEqual(account.max_backups, data['max_backups'])
self.assertTrue(account.check_password('test_password1'))
def stopVNF(self, vnfInstance, jsonStatus, new_status):
vnfquery = Account.objects.filter(productType=settings.VNF, instanceId=vnfInstance)
vnf = vnfquery[0]
vnfSerializer = AccountSerializer(vnf, many=False, data=json.loads(jsonStatus))
if vnfSerializer.is_valid():
#print "VNF2: ", json.dumps(vnfserializer.data)
vnfSerializer.save()
#Send the message to the billing module
send_msg(json.dumps(vnfSerializer.data))
#start/stop the SLA enforcement accordingly
if (new_status == settings.STATUS_RUNNING):
self.startEnforcement(vnf.agreementId)
if (new_status == settings.STATUS_STOPPED):
self.stopEnforcement(vnf.agreementId)
def test_serialize(self):
a_0 = ef.account()
a_1 = ef.account()
ci = ef.catalogue_item(name='names',
created_by=a_0,
maintained_by=a_1,
spec=[{
'name': 'name',
'type': 'STRING',
'is_nullable': False,
'is_enum': False,
'size': None,
'distribution': None,
}],
sample=[{
'name': 'Jack'
}],
executor_type='ATHENA')
assert CatalogueItemSerializer(ci).data == {
'@type':
'catalogue_item',
'id':
ci.id,
'created_by':
AccountSerializer(a_0).data,
'updated_by':
None,
'maintained_by':
AccountSerializer(a_1).data,
'name':
'names',
'spec': [
{
'name': 'name',
'type': 'STRING',
'is_nullable': False,
'is_enum': False,
'size': None,
'distribution': None,
},
],
'sample': [{
'name': 'Jack'
}],
'executor_type':
'ATHENA',
}
def get_context_data(self, **kwargs):
context_data = super(ImprestJVView, self).get_context_data(**kwargs)
if 'form' in context_data:
instance = context_data['form'].instance
context_data['data'] = {
'jv':
ImprestJVSerializer(instance).data,
'dr_ledgers':
AccountSerializer(self.project_fy.dr_ledgers(),
many=True).data,
'cr_ledgers':
AccountSerializer(self.project_fy.cr_ledgers(),
many=True).data,
}
return context_data
class ChatMessagesSerializer(serializers.ModelSerializer):
thread = serializers.RelatedField(source='chatmessage', read_only=True)
user = AccountSerializer()
class Meta:
model = ChatMessage
fields = ['thread', 'user', 'message', 'timestamp']
class UserSerializer(serializers.ModelSerializer):
diary_list = UserDiarySerializer(many=True, read_only=True)
account = AccountSerializer(many=True, read_only=True)
class Meta:
model = User
fields = ('id', 'email', 'username', 'phone', 'account', 'diary_list')
class DashboardSerializer(serializers.ModelSerializer):
owner = AccountSerializer(Account)
class Meta:
model = Dashboard
fields = '__all__'
def get(self, request, format=None):
"""
---
parameters:
- name: clientId
description: Client ID
type: string
paramType: form
serializer: AccountSerializer
"""
if self.request.query_params:
clientId = self.request.query_params.get('clientId', None)
if clientId:
queryset = Account.objects.filter(
status=settings.STATUS_RUNNING,
productType=settings.NETWORK_SERVICE,
clientId=clientId)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
queryset = Account.objects.filter(
status=settings.STATUS_RUNNING,
productType=settings.NETWORK_SERVICE)
serializer = AccountSerializer(queryset, many=True)
return Response(serializer.data)
class InvoiceSerializer(serializers.ModelSerializer):
location = LocationSerializer()
invoice_type = InvoiceTypeSerializer()
account = AccountSerializer()
labor = LaborSerializer(many=True, required=False)
services = ServiceSerializer(many=True, required=False)
history = VehicleLogSerializer(many=True, required=False)
class Meta:
model = Invoice
fields = (
"id",
"invoice_number",
"location",
"invoice_type",
"account",
"receive_date",
"complete_date",
"year",
"make",
"model",
"color",
"vin",
"stock_number",
"po_number",
"is_complete",
"is_paid",
"tax_rate",
"labor",
"services",
"history",
)
class ProjectCommentSerializer(serializers.ModelSerializer):
project = serializers.SlugRelatedField(read_only=True, slug_field='title')
user = AccountSerializer(Account)
class Meta:
model = ProjectComment
fields = '__all__'
class ProjectSerializer(serializers.ModelSerializer):
members = AccountSerializer(many=True, read_only=True, source='member')
client = ClientSerializer(read_only=True)
class Meta:
model = Project
fields = ('id', 'name', 'client', 'members')
depth = 3
def user_list(request, pk=None):
"""
List all required messages, or create a new message.
"""
if request.method == 'GET':
if pk: # If PrimaryKey (id) of the user is specified in the url
users = Account.objects.filter(
id=pk) # Select only that particular user
else:
users = Account.objects.all() # Else get all user list
serializer = AccountSerializer(users,
many=True,
context={'request': request})
return JsonResponse(serializer.data,
safe=False) # Return serialized data
elif request.method == 'POST':
data = JSONParser().parse(
request
) # On POST, parse the request object to obtain the data in json
serializer = AccountSerializer(data=data) # Seraialize the data
if serializer.is_valid():
serializer.save() # Save it if valid
return JsonResponse(serializer.data,
status=201) # Return back the data on success
return JsonResponse(serializer.errors,
status=400) # Return back the errors if not valid
def get(self, request, format=None):
"""
---
response_serializer: AccountSerializer
"""
accounts = Account.objects.all()
serializer = AccountSerializer(accounts, many=True)
return Response(serializer.data)
def test_account_getting(self):
"""Account should created"""
# account = Account.objects.create_user('*****@*****.**', 'password')
test_account = Account.objects.latest('created_at')
self.assertEqual(test_account.email, self.account.email)
serialized_account = AccountSerializer(test_account)
self.assertEqual(serialized_account.data.get('email'), self.account.email)
self.assertEqual(serialized_account.data.get('first_name'), self.account.first_name)
self.assertEqual(serialized_account.data.get('is_active'), None)
def accounts_add(request):
"""
Function to manage the addition of new accounts
"""
# Creating the default value
response = {}
# If not declared in settings, configuring a default value
# http://www.django-rest-framework.org/api-guide/exceptions/#exception-handling-in-rest-framework-views
try:
nfe = settings.NON_FIELD_ERRORS_KEY
except AttributeError:
nfe = 'non_field_errors'
# Parsing data from the request and changing the creator field for the user who did the request
data = JSONParser().parse(request)
data['creator'] = request.user.pk
# Check if all the data is valid to be used
serializer = AccountSerializer(data=data)
if serializer.is_valid():
# If valid, create it and notify
try:
Account.objects.get(iban=serializer.validated_data['iban'])
response = {
'errors': {
nfe: 'iban already exists',
}
}
return Response(response, status=status.HTTP_400_BAD_REQUEST)
except Account.DoesNotExist:
serializer.create(serializer.validated_data)
response = {
'status': 'ok',
'message': 'created'
}
return Response(response, status=status.HTTP_201_CREATED)
else:
# If not valid, raise an error for data_validation
response = {
{'errors': {'data_validation_error': 'Error validating data'}}
}
return Response(response, status=status.HTTP_400_BAD_REQUEST)
def test_serialize(self):
a = ef.account()
assert AccountSerializer(a).data == {
'@type': 'account',
'id': a.id,
'email': a.email,
'type': a.type,
}
def post(self, request, ns_instance, new_status, format=None):
"""
---
response_serializer: AccountSerializer
"""
queryset = Account.objects.filter(productType=settings.NETWORK_SERVICE, instanceId=ns_instance)
if queryset.exists():
jsonStatus='{"status":"' + new_status + '"}'
service = queryset[0]
serializer = AccountSerializer(service, data=json.loads(jsonStatus))
try:
if serializer.is_valid():
#saves the new status
serializer.save()
print "status changed "
#start/stop the SLA enforcement accordingly
if (new_status == settings.STATUS_RUNNING):
self.startEnforcement(service.agreementId)
if (new_status == settings.STATUS_STOPPED):
self.stopEnforcement(service.agreementId)
#prepares and sends the message to the queue
message = {}
message['instanceId'] = ns_instance
message['event'] = new_status
#print (json.dumps(serializer.data))
send_msg(json.dumps(serializer.data))
#update the status of the participant VNFs
vnf_list = service.relative_instances.replace(" ", "").split(",")
print "VNF list: ", vnf_list
for vnfInstance in vnf_list:
time.sleep(1)
print "VNF: ", vnfInstance
self.stopVNF(vnfInstance, jsonStatus, new_status)
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ReferenceError:
print " [ERROR] Could not update the messages queue"
return Response(status=status.HTTP_408_REQUEST_TIMEOUT)
except Exception as e:
print " [ERROR] ", e
return Response(status=status.HTTP_400_BAD_REQUEST)
return Response(queryset, status=status.HTTP_404_NOT_FOUND)
def test_validate_raises_max_backups_is_non_number(self):
data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'max_backups': 'f'
}
serializer = AccountSerializer(data=data)
self.assertRaises(serializers.ValidationError, serializer.validate,
*(data, ))
def search(request):
data = {}
search_term = request.GET['q']
tags = request.GET['type'].split(",")
offset, limit = get_offset_limit(request=request)
for tag in tags:
addition = '&q=' + search_term + '&type=' + tag
if tag == 'restaurant':
restaurants = Restaurant.objects.filter(
name__icontains=search_term)[offset:offset + limit + 1]
next = pagination_maker(request=request,
offset=offset,
limit=limit,
more=restaurants[limit:])
restaurant_list = []
for restaurant in restaurants[:limit]:
restaurant_serializer = RestaurantSerializer(restaurant)
restaurant_list.append(restaurant_serializer.data)
data['restaurants'] = {'items': restaurant_list}
data['restaurants']['next'] = next
elif tag == 'user':
accounts = Account.objects.filter(
Q(first_name__icontains=search_term)
| Q(last_name__icontains=search_term))[offset:offset + limit +
1]
next = pagination_maker(request=request,
offset=offset,
limit=limit,
more=accounts[limit:])
accounts_list = []
for account in accounts:
account_serializer = AccountSerializer(account)
accounts_list.append(account_serializer.data)
data['users'] = {'items': accounts_list}
data['users']['next'] = next
return Response(data)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
print(request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
accountSerializer=AccountSerializer()
if (accountSerializer.validate_mobile(serializer.data['mobile'])):
data = {
'apikey': settings.YUNPIAN_API_KEY,
'mobile': serializer.data['mobile'],
'text': settings.MOBILE_VERIFICATION_MESSAGE_TEMPLATE % (
serializer.data['code'],
settings.VERIFICATION_CODE_EXPIRATION_IN_MINUTES,
),
}
try:
r = requests.post(settings.YUNPIAN_SMS_API, data=data)
if r.status_code == 200:
return Response(status=status.HTTP_201_CREATED)
response = {
'detail': six.text_type(_('YUNPIAN service request failed.')),
'reason': six.text_type(_('Response code is not 200.')),
'code': r.status_code,
}
return Response(response, status=status.HTTP_503_SERVICE_UNAVAILABLE)
except:
response = {
'detail': six.text_type(_('YUNPIAN service request failed.')),
'reason': six.text_type(_('Exception catched when made request to YUNPIAN SMS API.')),
}
return Response(response, status=status.HTTP_503_SERVICE_UNAVAILABLE)
response = {
'detail': six.text_type(_('The number has been registered.')),
'reason': six.text_type(_('The number has been registered.')),
'code': r.status_code,
}
return Response(response, status=status.HTTP_503_SERVICE_UNAVAILABLE)
def get(self, request, vnf_instance, new_status, format=None):
queryset = Account.objects.filter(productType=settings.VNF, instanceId=vnf_instance)
if queryset.exists():
jsonStatus='{"status":"' + new_status + '"}'
for account in queryset:
serializer = AccountSerializer(account, data=json.loads(jsonStatus))
try:
if serializer.is_valid():
#saves the new status
serializer.save()
print "status changed "
#prepares and sends the message to the queue
message = {}
message['instanceId'] = vnf_instance
message['event'] = new_status
#send_msg(str(message))
send_msg(json.dumps(serializer.data))
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ReferenceError:
print " [ERROR] Could not update the messages queue"
return Response(status=status.HTTP_408_REQUEST_TIMEOUT)
except Exception:
return Response(status=status.HTTP_400_BAD_REQUEST)
return Response(queryset, status=status.HTTP_404_NOT_FOUND)
