def create(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value) for key, value in data.items())
print(new_data)
objs = HCI.objs.filter(MachineID=request.data['MachineID'])
existHCI = None
if objs.exists():
existHCI = objs.first()
print(existHCI)
if not existHCI.isArchived:
return Response({"message": "Already a HCI is present with the given HCI ID"}, status=400)
if existHCI and existHCI.isArchived:
existHCI.isArchived = False
existHCI.save()
data = HCISerializer(existHCI, data=request.data)
if data.is_valid():
obj1 = data.save()
audit = AuditTrail.objects.create(user=request.user.username, rowId=existHCI.id, action="Create",
table_name="HCI", new_data=new_data)
audit.save()
return Response({"output": "HCI created successfully", "HCI": HCISerializer(obj1).data},
status=201)
return Response({"output": "Error in data"},
status=400)
response = super(HCICreateView, self).create(request, *args, **kwargs)
audit = AuditTrail.objects.create(user=request.user.username,rowId=response.data['id'],action="Create",table_name="HCI",new_data=new_data)
if response.status_code == 201:
audit.save()
return response
except Exception as error:
print(error)
logging("ERROR : ClientApp->HCICreate : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def destroy(self, request, *args, **kwargs):
try:
licObj = Licence.objects.get(pk=kwargs["id"])
serzLicence = LicenceSerializer(licObj)
old_data = "; ".join("{0} = {1}".format(key, value)
for key, value in serzLicence.data.items()
if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,
rowId=licObj.id,
action="Delete",
table_name="Licence",
old_data=old_data)
audit.save()
licObj.isArchived = True
licObj.save()
return Response(status=204)
# obj = self.get_object()
# order = obj.OrderID
# order.delete()
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->LicenceDeletion : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def update(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
git_update = GitUpdate.objects.get(pk=kwargs['id'])
serzData = GitUpdateSerializer(git_update)
old_data = "; ".join("{0} = {1}".format(key, value)
for key, value in serzData.data.items()
if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,
rowId=git_update.id,
action="Update",
table_name="GitUpdate",
new_data=new_data,
old_data=old_data)
response = super(GitUpdateRDEView,
self).update(request, *args, **kwargs)
if response.status_code == 200:
audit.save()
return response
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->GitUpdateUpdate : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request):
try:
quescount = SecurityQuestion.objects.all().count()
count = 0
userpk = int()
for data in request.data['values']:
obj = UserSecurityDetail.objects.filter(
userid=data['userid'],
questionId=data['questionId'],
value__iexact=data['value'])
if obj.exists() and obj.count() == 1:
userpk = data['userid']
count += 1
else:
return Response({"error": "Invalid User"}, status=400)
if count == quescount:
userp = UserProfile.objects.get(user=userpk)
userp.reset = True
userp.save()
return Response({
"output": "Successfully Validated",
'Reset': True
})
return Response({
"output": "Invalid User",
"Reset": False
},
status=400)
except Exception as error:
print(error)
logging(
"ERROR : UserApp->ResetVerification : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value) for key, value in data.items())
objs = Client.objs.filter(Q(Name=request.data['Name']) | Q(CusId=request.data['CusId']))
existClient = None
if objs.exists():
existClient = objs.first()
print(existClient)
if not existClient.isArchived:
return Response({"message": "Already a Client is present with the given Name or CusID"}, status=400)
if existClient and existClient.isArchived:
existClient.isArchived = False
existClient.save()
data = ClientSerializer(existClient, data=request.data)
if data.is_valid():
obj1 = data.save()
audit = AuditTrail.objects.create(user=request.user.username, rowId=existClient.id, action="Create",
table_name="Client", new_data=new_data)
audit.save()
return Response({"output": "Client created successfully","client":ClientSerializer(obj1).data}, status=201)
return Response({"output": "Error in data"},
status=400)
response = super(ClientCreateView, self).create(request, *args, **kwargs)
audit = AuditTrail.objects.create(user=request.user.username,rowId=response.data['id'], action="Create", table_name="Client",
new_data=new_data)
if response.status_code == 201:
audit.save()
return response
except Exception as error:
print(error)
logging("ERROR : ClientApp->ClientCreation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
quescount = SecurityQuestion.objects.all().count()
count = 0
for data in request.data['values']:
obj = UserSecurityDetailSerializer(data=data)
if obj.is_valid():
obj.save()
count += 1
else:
return Response({
"error": "Failure, unable to add user reset details.",
"errors": obj.errors
})
if count == quescount:
user = User.objects.get(username=request.user.username)
userp = UserProfile.objects.get(user=user.pk)
userp.firstLogin = False
userp.save()
print("Success")
return Response(
{"Output": "Successfully added the User Reset Details."})
print("Failure")
return Response(
{"error": "Failure, unable to add user reset details."})
except Exception as error:
print(error)
logging(
"ERROR : UserApp->UserSecurityQuestion : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request):
try:
print(request.data)
user = User.objects.filter(username="******")
if not user.exists():
usr = User.objects.create(username="******")
usr.set_password("User@12#$")
usr.save()
appObj = Application.objects.get(id=request.data['appid'])
hciObj = HCI.objects.get(id=request.data['mid'])
ts = time.time()
date = datetime.datetime.fromtimestamp(ts).date()
data = {
"username": "******",
"mid": hciObj.MachineID,
"appid": appObj.ApplicationName,
"password": "******",
"dummy": True
}
enc = encrypt_message(
json.dumps(data, cls=DjangoJSONEncoder).encode('utf-8'))
print(enc)
licenceObj = Licence.objects.filter(MachineID=request.data['mid'],
App=request.data['appid'])
if licenceObj.exists() and licenceObj.count(
) == 1 and not licenceObj.first().isArchived:
lic = licenceObj.first()
orderObj = lic.OrderID
data = {
"username": "******",
# "customer": lic.MachineID.Customer.Name,
# "cusid": lic.MachineID.Customer.CusId,
"mid": lic.MachineID.MachineID,
"appid": lic.App.ApplicationName,
"password": "******",
"start": orderObj.orderStartDate,
"expire": lic.expiryDate,
"graceStart": lic.graceIssueDate,
"graceExpire": lic.graceExpiryDate,
"trial": lic.trial,
"licence_attrs": lic.licence_attrs,
"period": orderObj.period,
"serverTime": date,
"updated_on": lic.updated,
"Category": lic.Category
}
enc = encrypt_message(
json.dumps(data, cls=DjangoJSONEncoder).encode('utf-8'))
print(data)
return Response([{"data": enc}], status=200)
return Response([{"msg": "dummy", "data": enc}], status=200)
except Exception as error:
print(error)
logging("ERROR : UserApp->GetLicence : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def get(self, *args, **kwargs):
try:
queryset = Client.objects.all()
objs = ClientSerializer(queryset,many=True)
context = {}
context['clients'] = objs.data
return Response(context)
except Exception as error:
print(error)
logging("ERROR : ClientApp->ClientListRetrieval : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def get_queryset(self):
try:
queryset_list = HCI.objects.all()
query = self.request.GET.get("cid")
if query:
queryset_list = queryset_list.filter(Customer=query)
return queryset_list
except Exception as error:
print(error)
logging("ERROR : ClientApp->HCIListRetrieval : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request, *args, **kwargs):
try:
user = User.objects.get(pk=kwargs['id'])
print(user.is_active)
user.is_active = False
user.save()
audit = AuditTrail.objects.create(user=request.user.username, rowId=user.id, action="InActivate", table_name="User")
audit.save()
return Response({"info":"User InActivated Succesfully"},status=200)
except Exception as error:
print(error)
logging("ERROR : ClientApp->UserDeactivation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
objs = Application.objs.filter(
ApplicationName=request.data['ApplicationName'])
existApp = None
if objs.exists():
existApp = objs.first()
print(existApp)
if not existApp.isArchived:
return Response(
{
"message":
"Already a Application is present with the given Application Name"
},
status=400)
if existApp and existApp.isArchived:
request.data['isArchived'] = False
data = ApplicationArchiveSerializer(existApp,
data=request.data)
if data.is_valid():
app = data.save()
audit = AuditTrail.objects.create(
user=request.user.username,
rowId=app.id,
action="Create",
table_name="App",
new_data=new_data)
audit.save()
return Response(
{"output": "Application created successfully"},
status=201)
else:
return Response({"output": data.errors}, status=400)
response = super(ApplicationCreateView,
self).create(request, *args, **kwargs)
audit = AuditTrail.objects.create(user=request.user.username,
rowId=response.data['id'],
action="Create",
table_name="App",
new_data=new_data)
if response.status_code == 201:
audit.save()
return response
except Exception as error:
print(error)
logging("ERROR : LicenceApp->ApplicationCreation : {0}.\n".format(
error))
return Response({"Error": "Wrong Request"}, status=500)
def get_queryset(self):
try:
queryset_list = Licence.objects.all()
mid = self.request.GET.get("mid")
appid = self.request.GET.get("appid")
cid = self.request.GET.get("cid")
if mid:
queryset_list = queryset_list.filter(MachineID=mid)
return queryset_list
except Exception as error:
print(error)
logging("ERROR : LicenceApp->LicenceListRetrieval : {0}.\n".format(
error))
return Response({"Error": "Wrong Request"}, status=500)
def delete(self, request, *args, **kwargs):
try:
user = User.objects.get(pk=kwargs["id"])
serzUser = UserSerializer(user)
old_data = "; ".join("{0} = {1}".format(key, value) for key, value in serzUser.data.items() if key != "id")
audit = AuditTrail.objects.create(user=request.user.username, rowId=user.id, action="delete", table_name="User", old_data=old_data)
response = super(ClientUserDeleteView, self).delete(request, *args, **kwargs)
if response.status_code == 200:
audit.save()
return response
except Exception as error:
print(error)
logging("ERROR : ClientApp->UserDeletion : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def delete(self, request, *args, **kwargs):
try:
client = Client.objects.get(pk=kwargs["id"])
serzClient = ClientSerializer(client)
old_data = "; ".join("{0} = {1}".format(key, value) for key, value in serzClient.data.items() if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,rowId=client.id,action="Delete",table_name="Client",old_data=old_data)
audit.save()
client.isArchived = True
client.save()
return Response(status=204)
except Exception as error:
print(error)
logging("ERROR : ClientApp->ClientDeletion : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request):
try:
licId = request.data['id']
tableName = request.data['table']
if licId and licId != 0 and tableName != "":
audits = AuditTrail.objects.filter(rowId=licId,
table_name=tableName)
if audits.exists() and audits.count() > 0:
serdata = AuditSerializer(audits, many=True)
return Response(serdata.data, status=200)
return Response({"output": "No record is available"}, status=200)
except Exception as error:
print(error)
logging("ERROR : UserApp->AuditRetrieve : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def get(self, request, format=None):
try:
user = User.objects.filter(username=request.user.username)
if user.exists() and user.count() == 1:
users = user.first()
print(users.id)
pkid = users.id
queryset = SecurityQuestion.objects.all()
qs = SecurityQuestionSerializer(queryset, many=True)
return Response({"questions": qs.data, 'userid': pkid})
return Response({"error": "Invalid Username"}, status=400)
except Exception as error:
print(error)
logging(
"ERROR : UserApp->ResetQuestion(GET) : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request, *args, **kwargs):
try:
user = User.objects.get(pk=kwargs['id'])
print(user.is_active)
user.is_active = True
user.save()
audit = AuditTrail.objects.create(user=request.user.username, rowId=user.id, action="Activate", table_name="User")
audit.save()
if 'mail' in request.data and request.data['mail'] == True:
mail(to_address=user.email, username=user.username, purpose="activate",link="https://35.237.170.221/#/auth/activate?uid={id}&token={token}"
.format(id=urlsafe_base64_encode(force_bytes(user.id)),token=user.profile.key), companyName=user.profile.cid.Name)
return Response({"info":"User Activated Succesfully"},status=200)
except Exception as error:
print(error)
logging("ERROR : ClientApp->UserActivation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def update(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
licence = Licence.objects.get(pk=kwargs['id'])
serzLice = LicenceSerializer(licence)
old_data = "; ".join("{0} = {1}".format(key, value)
for key, value in serzLice.data.items()
if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,
rowId=licence.id,
action="Update",
table_name="Licence",
new_data=new_data,
old_data=old_data)
flag = 0
if licence.issueDate == licence.OrderID.orderStartDate:
flag = 1
order = OrderCreateUpdateSerializer(licence.OrderID,
data=request.data)
if order.is_valid():
obj1 = order.save()
request.data['OrderID'] = obj1.id
if flag == 1:
licence = LicenceCreateSerializer(licence,
data=request.data)
else:
licence = LicenceUpdateSerializer(licence,
data=request.data)
if licence.is_valid():
obj2 = licence.save()
audit.save()
return Response({
"order":
OrderSerializer(obj1).data,
"licence":
LicenceDetailSerializer(obj2).data
})
else:
print(licence.errors)
print(order.errors)
return Response({"error": "Failed to create"}, status=400)
except Exception as error:
print(error)
logging("ERROR : LicenceApp->LicenceUpdate : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
objs = GitUpdate.objs.filter(version=request.data['version'])
existApp = None
if objs.exists():
existApp = objs.first()
print(existApp)
if not existApp.isArchived:
return Response(
{"message": "Already this App Version is present"},
status=400)
if existApp and existApp.isArchived:
request.data['isArchived'] = False
data = GitUpdateSerializer(existApp, data=request.data)
if data.is_valid():
app = data.save()
# existApp.isArchived = False
# existApp = GitUpdate(id=existApp.id, **data)
# existApp.save()
audit = AuditTrail.objects.create(user=request.user.username,
rowId=existApp.id,
action="Create",
table_name="GitUpdate",
new_data=new_data)
audit.save()
return Response(
{"output": "Git Update details created successfully"},
status=201)
response = super(GitUpdateView,
self).create(request, *args, **kwargs)
audit = AuditTrail.objects.create(user=request.user.username,
rowId=response.data['id'],
action="Create",
table_name="GitUpdate",
new_data=new_data)
if response.status_code == 201:
audit.save()
return response
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->GitUpdateCreation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def update(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value) for key, value in data.items())
hci = HCI.objects.get(pk=kwargs["id"])
serzHCI = HCISerializer(hci)
old_data = "; ".join("{0} = {1}".format(key, value) for key, value in serzHCI.data.items() if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,rowId=hci.id,action="Update",table_name="HCI",new_data=new_data,old_data=old_data)
response = super(HCIUpdateView, self).update(request, *args, **kwargs)
if response.status_code == 200:
audit.save()
print("saved")
return response
except Exception as error:
print(error)
logging("ERROR : ClientApp->HCIUpdation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request, *args, **kwargs):
try:
username = request.user.username
user_id = request.user.id
original_response = super(CustomLogoutView,
self).post(request, *args, **kwargs)
if original_response.status_code == 200:
if username != 'user':
audit = AuditTrail.objects.create(user=username,
rowId=user_id,
action="Logout")
audit.save()
return original_response
except Exception as error:
print(error)
logging("ERROR : UserApp->Logout : {0}.\n".format(error))
return Response({"Error": "Internal Server Error"}, status=500)
def post(self, request):
try:
userid = request.data['userid']
user = User.objects.filter(pk=userid)
if user.exists() and user.count() == 1:
user = user.first()
userp = UserProfile.objects.get(user=userid)
if userp.reset == True:
user.set_password(request.data['password'])
user.save()
userp.reset = False
userp.save()
return Response({"output": "Successfully Password Reset"})
print(request.data)
return Response({"output": "Invalid User"}, status=400)
except Exception as error:
print(error)
logging("ERROR : UserApp->PassswordReset : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def update(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value) for key, value in data.items())
qusers1 = User.objects.filter(email=request.data['email']).exclude(pk=kwargs['id'])
print(qusers1)
if not qusers1.exists():
user = User.objects.get(pk=kwargs["id"])
serzUser = UserSerializer(user)
old_data = "; ".join("{0} = {1}".format(key, value) for key, value in serzUser.data.items() if key != "id")
audit = AuditTrail.objects.create(user=request.user.username, rowId=user.id, action="Update", table_name="User",
new_data=new_data, old_data=old_data)
response = super(ClientUserUpdateView, self).update(request, *args, **kwargs)
if response.status_code == 200:
audit.save()
return response
return Response({"info": "User with the given email id is already present"}, status=400)
except Exception as error:
print(error)
logging("ERROR : ClientApp->UserUpdation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
data = request.data
qusers1 = User.objects.filter(profile__cid=request.data['profile']['cid'])
qusers2 = User.objects.filter(email=request.data['email'])
print(qusers2)
if ( not qusers1.exists() or ( qusers1.exists() and qusers1.count() < 2)) and not qusers2.exists():
new_data = "; ".join("{0} = {1}".format(key, value) for key, value in data.items())
response = super(ClientUserCreateView, self).create(request, *args, **kwargs)
audit = AuditTrail.objects.create(user=request.user.username,rowId=response.data['id'], action="Create", table_name="User",
new_data=new_data)
if response.status_code == 201:
audit.save()
return response
if qusers2.exists():
return Response({"info": "User with the given email id is already present"}, status=400)
return Response({"info": "Only two users could be created Users"}, status=400)
except Exception as error:
print(error)
logging("ERROR : ClientApp->UserCreation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def delete(self, request, *args, **kwargs):
try:
git_update = GitUpdate.objects.get(pk=kwargs["id"])
serzData = GitUpdateSerializer(git_update)
old_data = "; ".join("{0} = {1}".format(key, value)
for key, value in serzData.data.items()
if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,
rowId=git_update.id,
action="Delete",
table_name="GitUpdate",
old_data=old_data)
audit.save()
git_update.isArchived = True
git_update.save()
return Response(status=204)
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->GitUpdateDeletion : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request):
try:
queryset_list = Licence.objects.all()
if "cid" in request.data and request.data["cid"]:
machines = HCI.objects.filter(Customer__in=request.data["cid"])
queryset_list = queryset_list.filter(MachineID__in=machines)
if "mid" in request.data and request.data["mid"]:
queryset_list = queryset_list.filter(
MachineID__in=request.data["mid"])
if "appid" in request.data and request.data["appid"]:
queryset_list = queryset_list.filter(
App__in=request.data["appid"])
if "statusAlive" in request.data and request.data[
"statusAlive"] is not None:
date = datetime.datetime.today()
if request.data["statusAlive"] == "Active":
queryset_list = queryset_list.filter(expiryDate__gte=date)
elif request.data["statusAlive"] == "Ingrace":
queryset_list = queryset_list.filter(
graceExpiryDate__gte=date,
expiryDate__lt=date,
trial=False)
elif request.data["statusAlive"] == "Expired":
queryset_list = queryset_list.filter(
graceExpiryDate__lt=date)
elif request.data["statusAlive"] == "Trail":
queryset_list = queryset_list.filter(
trial=True, graceExpiryDate__gte=date)
elif request.data["statusAlive"] == "Perpetual":
queryset_list = queryset_list.filter(OrderID__period=77)
if "issueStartDate" in request.data and request.data[
'issueStartDate']:
date = request.data['issueStartDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(issueDate__gte=date)
if "issueEndDate" in request.data and request.data['issueEndDate']:
date = request.data['issueEndDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(issueDate__lte=date)
if "expiryStartDate" in request.data and request.data[
'expiryStartDate']:
date = request.data['expiryStartDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(expiryDate__gte=date)
if "expiryEndDate" in request.data and request.data[
'expiryEndDate']:
date = request.data['expiryEndDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(expiryDate__lte=date)
# if "gracePeriod" in request.data and request.data['gracePeriod'] is not None:
# date = datetime.datetime.today()
# if request.data['gracePeriod']:
# queryset_list = queryset_list.filter(graceExpiryDate__gte = date)
# else:
# queryset_list = queryset_list.filter(graceExpiryDate__lte = date)
serData = LicenceDetailSerializer(queryset_list, many=True)
return Response(serData.data, status=200)
except ValueError:
return Response({"Error": "Wrong Request"}, status=400)
except Exception as error:
print(error)
logging("ERROR : LicenceApp->Report : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def update(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
licence = Licence.objects.get(pk=kwargs['id'])
serzLice = LicenceSerializer(licence)
old_data = "; ".join("{0} = {1}".format(key, value)
for key, value in serzLice.data.items()
if key != "id")
audit = AuditTrail.objects.create(user=request.user.username,
rowId=licence.id,
action="GraceRenew",
table_name="Licence",
new_data=new_data,
old_data=old_data)
order = OrderGraceUpdateSerializer(licence.OrderID,
data=request.data)
if order.is_valid():
obj1 = order.save()
order = licence.OrderID
order.graceCount += 1
# if order.is_valid():
obj1 = order.save()
# mutable = request.POST._mutable
# request.POST._mutable = True
# request.data['OrderID'] = obj1.id
# request.POST._mutable = mutable
licence = Licence.objects.get(pk=kwargs['id'])
licence = LicenceGraceTrailUpdateSerializer(licence,
data=request.data)
if licence.is_valid():
obj2 = licence.save()
print(obj2)
audit.save()
purpose = "graceNotify"
users = User.objects.filter(
profile__cid=obj2.MachineID.Customer)
if users.exists():
print("yes users are presentr")
for user in users:
if user.is_active == True:
print(user)
mail(to_address=user.email,
username=user.username,
purpose=purpose,
link=None,
hciId=obj2.MachineID.MachineID,
app=obj2.App.ApplicationName,
grace=(obj2.graceExpiryDate -
obj2.graceIssueDate).days + 1,
start=obj2.graceIssueDate.strftime(
'%d-%m-%Y'),
end=obj2.graceExpiryDate.strftime(
'%d-%m-%Y'),
companyName=user.profile.cid.Name)
return Response({
"order":
OrderSerializer(order).data,
"licence":
LicenceDetailSerializer(obj2).data
})
print(licence.errors)
return Response({"Error": "Wrong Input"}, status=400)
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->LicenceGraceRenew : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def post(self, request):
"""
Method: POST
Param request: CustomerId, MachineID, AppID, IssueStart-End, ExpiryStart-End, GracePerido
return: List of Orders that matches the query passed
Doing checkout process
"""
try:
queryset_list = Order.objects.all()
if "cid" in request.data and request.data["cid"]:
machines = HCI.objects.filter(Customer__in=request.data["cid"])
queryset_list = queryset_list.filter(MachineID__in=machines)
if "mid" in request.data and request.data["mid"]:
queryset_list = queryset_list.filter(
MachineID__in=request.data["mid"])
if "appid" in request.data and request.data["appid"]:
queryset_list = queryset_list.filter(
App__in=request.data["appid"])
if "statusAlive" in request.data and request.data[
"statusAlive"] is not None:
date = datetime.datetime.today()
if request.data["statusAlive"]:
queryset_list = queryset_list.filter(expiryDate__gte=date)
else:
queryset_list = queryset_list.filter(expiryDate__lte=date)
if "issueStartDate" in request.data and request.data[
'issueStartDate']:
date = request.data['issueStartDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(issueDate__gte=date)
if "issueEndDate" in request.data and request.data['issueEndDate']:
date = request.data['issueEndDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(issueDate__lte=date)
if "expiryStartDate" in request.data and request.data[
'expiryStartDate']:
date = request.data['expiryStartDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(expiryDate__gte=date)
if "expiryEndDate" in request.data and request.data[
'expiryEndDate']:
date = request.data['expiryEndDate']
date = datetime.datetime.strptime(date, "%d-%m-%Y").date()
queryset_list = queryset_list.filter(expiryDate__lte=date)
if "gracePeriod" in request.data and request.data[
'gracePeriod'] is not None:
date = datetime.datetime.today()
if request.data['gracePeriod']:
queryset_list = queryset_list.filter(
graceExpiryDate__gte=date)
else:
queryset_list = queryset_list.filter(
graceExpiryDate__lte=date)
serData = OrderSerializer(queryset_list, many=True)
return Response(serData.data, status=200)
except ValueError:
return Response({"Error": "Wrong Input"}, status=400)
except Exception as error:
print(error)
logging("ERROR : OrderApp->Report : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
def create(self, request, *args, **kwargs):
try:
data = request.data
new_data = "; ".join("{0} = {1}".format(key, value)
for key, value in data.items())
macid = request.data['MachineID']
appid = request.data['App']
objs = Licence.objs.filter(MachineID=macid, App=appid)
existLic = None
if objs.exists():
existLic = objs.first()
print(existLic)
if not existLic.isArchived:
return Response(
{
"message":
"Already a Licence is present for the given HCI and Application"
},
status=400)
order = OrderCreateUpdateSerializer(data=request.data)
if order.is_valid():
obj1 = order.save()
# mod_data = request.data.copy()
request.data['OrderID'] = obj1.id
if existLic and existLic.isArchived:
request.data['isArchived'] = False
data = LicenceCreateArchiveSerializer(existLic,
data=request.data)
else:
data = LicenceCreateSerializer(data=request.data)
if data.is_valid():
obj2 = data.save()
audit = AuditTrail.objects.create(
user=request.user.username,
rowId=obj2.id,
action="Create",
table_name="Licence",
new_data=new_data)
audit.save()
purpose = ""
users = User.objects.filter(
profile__cid=obj2.MachineID.Customer)
if users.exists():
print("yes users are presentr")
for user in users:
if user.is_active == True:
print(user)
if request.data['period'] == 77:
purpose = "licenceNotify"
mail(to_address=user.email,
username=user.username,
purpose=purpose,
link=None,
hciId=obj2.MachineID.MachineID,
app=obj2.App.ApplicationName,
grace="-",
start="-",
end="-",
companyName=user.profile.cid.Name)
elif 'trial' in request.data and request.data[
'trial']:
purpose = "trialNotify"
mail(to_address=user.email,
username=user.username,
purpose=purpose,
link=None,
hciId=obj2.MachineID.MachineID,
app=obj2.App.ApplicationName,
grace=(obj2.graceExpiryDate -
obj2.graceIssueDate).days + 1,
start=obj2.graceIssueDate.strftime(
'%d-%m-%Y'),
end=obj2.graceExpiryDate.strftime(
'%d-%m-%Y'),
companyName=user.profile.cid.Name)
elif 'trial' not in request.data or (
'trial' in request.data
and not request.data['trial']):
purpose = "licenceNotify"
mail(to_address=user.email,
username=user.username,
purpose=purpose,
link=None,
hciId=obj2.MachineID.MachineID,
app=obj2.App.ApplicationName,
grace=(obj2.graceExpiryDate -
obj2.graceIssueDate).days + 1,
start=obj2.OrderID.orderStartDate.
strftime('%d-%m-%Y'),
end=obj2.expiryDate.strftime(
'%d-%m-%Y'),
companyName=user.profile.cid.Name)
return Response({
"order":
OrderSerializer(obj1).data,
"licence":
LicenceDetailSerializer(obj2).data
})
print(data.errors)
print(order.errors)
return Response({"error": "Failed to create"}, status=400)
except Exception as error:
print(error)
logging(
"ERROR : LicenceApp->LicenceCreation : {0}.\n".format(error))
return Response({"Error": "Wrong Request"}, status=500)
