def post(cls):
json_data = request.get_json()
user = UserModel.find_by_id(json_data["userId"])
device = DeviceModel.find_by_id(json_data["deviceId"])
print(json_data["releaseDate"])
if device.status == "available" or device.status == "created":
if user and device:
if device.isActivated:
if device.status == "created" or device.status == "available":
try:
req_obj = {
"deviceId": json_data["deviceId"],
"userId": json_data["userId"]
}
request_data = request_schema.load(req_obj)
except ValidationError as err:
return err.messages, 401
try:
request_model = RequestModel(**request_data)
device.status = "blocked"
device.releaseDate = json_data["releaseDate"]
request_model.insert_request()
device.insert_device()
except:
return {"Message": "REQUEST INSERT ERROR"}, 401
return {"Message": "REQUEST SUCCESSFULLY ADDED"}, 201
return {"Message": "DEVICE IS NOT AVAILABLE"}, 401
return {"Message": "DEVICE IS NOT ACTIVATED"}, 401
return {"Message": "SOMETHING GETTING WRONG"}, 401
return {"Messgae": "Device is not available to request"}, 401
def put(cls, reqId):
json_data = request.get_json()
request_data = RequestModel.find_by_id(reqId)
if request_data.reqStatus == "pending":
device_data = DeviceModel.find_by_id(request_data.deviceId)
user_data = UserModel.find_by_id(request_data.userId)
req_audit_obj = {"reqId": reqId, "handleBy": json_data["admin_id"]}
req_audit_model = RequestAuditModel(**req_audit_obj)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if request_data and admin_data.role == "admin":
request_data.reqStatus = "declined"
device_data.status = "available"
device_data.assignTo = "0"
device_data.releaseDate = None
request_data.insert_request()
device_data.insert_device()
req_audit_model.insert_request_audit()
# declined request
return {"Message": "Request Declined Successfully"}, 201
return {"Message": "Request Not Found"}, 401
return {"Message": "Request Already Resolve"}, 403
def put(cls, deviceId, userId):
json_data = request.get_json()
device_data = DeviceModel.find_by_id(deviceId)
if device_data.status == "blocked" or device_data.status == "allocated":
return {"Message": "Device is not available"}, 401
user_data = UserModel.find_by_id(userId)
req_obj = {"deviceId": deviceId, "userId": userId}
request_model = RequestModel(**req_obj)
device_obj = {
"deviceId": deviceId,
"userId": userId,
"allocateBy": json_data["admin_id"]
}
device_audit_model = DeviceAuditModel(**device_obj)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if device_data and user_data and admin_data.role == "admin":
# if device_data.status == "created" or device_data.status == "available" :
if user_data.isActivated:
if device_data.isActivated:
# device_data.isAvailable = False
# if user_data.role == "admin":
request_model.reqStatus = "approved"
device_data.status = "allocated"
device_data.assignTo = user_data.email
device_data.releaseDate = json_data["releaseDate"]
try:
device_data.insert_device()
request_model.insert_request()
# return {"Message": "DEVICE ASSIGNED"}, 201
except:
return {"Message": "INTERNAL SERVER ERROR"}, 401
req_model = RequestModel.get_my_last_request(
deviceId, userId)
req_audit_obj = {
"reqId": req_model.reqId,
"handleBy": json_data["admin_id"]
}
req_audit_model = RequestAuditModel(**req_audit_obj)
# try:
req_audit_model.insert_request_audit()
device_audit_model.insert_device_audit()
return {"Message": "DEVICE ASSIGNED"}, 201
# except:
# return {"Message": "INTERNAL SERVER ERROR"}, 403
# return {"Message": "DEVICE ALREADY ASSIGNED TO USER"}, 403
return {"Message": "DEVICE IS NOT ACTIVATED TO ASSIGN"}, 400
return {"Message": "USER IS NOT ACTIVATED TO ASSIGN"}, 400
return {"MESSAGE": "INVALID REQUEST"}, 400
def put(cls, deviceId):
json_data = request.get_json()
device_data = DeviceModel.find_by_id(deviceId)
if device_data:
device_data.osVersion = json_data['osVersion']
device_data.rom = json_data['rom']
device_data.insert_device()
return {"Message": "Device Updated Successfully"}, 201
return {"Message": "Internal server error"}, 401
def get(self, _id=None):
if _id:
device = DeviceModel.find_by_id(_id)
if device:
return BaseResponse.ok_response('Successful.', device.json())
return BaseResponse.bad_request_response('Device does not exists.', {})
else:
devices = list(map(lambda x: x.json(), DeviceModel.find_all()))
return BaseResponse.ok_response('Successful.', devices)
def put(cls, deviceId):
device_data = DeviceModel.find_by_id(deviceId)
if device_data:
device_data.isActivated = True
try:
device_data.insert_device()
return {"Message": "DEVICE ACTIVATED"}, 201
except:
return {"Message": "INTERNAL SERVER ERROR"}, 401
return {"MESSAGE": "INVALID REQUEST"}, 400
def put(cls, deviceId):
device_data = DeviceModel.find_by_id(deviceId)
if device_data:
if device_data.assignTo != "0":
return {"Message": "DEVICE IS ASSIGNED TO SOMEONE"}, 401
device_data.isActivated = False
try:
device_data.insert_device()
return {"Message": "DEVICE DE ACTIVATED"}, 201
except:
return {"Message": "INTERNAL SERVER ERROR"}, 401
return {"MESSAGE": "INVALID REQUEST"}, 401
def put(cls, deviceId):
json_data = request.get_json()
device_data = DeviceModel.find_by_id(deviceId)
user_data = UserModel.find_by_email(device_data.assignTo)
device_audit = DeviceAuditModel.find_my_device(deviceId, user_data.id)
if device_data and device_audit:
# device_data.isAvailable = True
device_data.status = "available"
device_data.assignTo = "0"
device_data.releaseDate = None
device_audit.deallocateBy = json_data['admin_id']
device_audit.deallocateDate = str(
date.today().strftime("%d/%m/%Y"))
try:
device_data.insert_device()
device_audit.insert_device_audit()
return {"Message": "DEVICE DE ALLOCATED"}, 201
except:
return {"Message": "INTERNAL SERVER ERROR"}, 401
return {"MESSAGE": "INVALID REQUEST"}, 400
def put(cls, reqId):
json_data = request.get_json()
request_data = RequestModel.find_by_id(reqId)
device_data = DeviceModel.find_by_id(request_data.deviceId)
if request_data.reqStatus == "pending":
if device_data.status == "blocked":
user_data = UserModel.find_by_id(request_data.userId)
req_audit_obj = {
"reqId": reqId,
"handleBy": json_data["admin_id"]
}
req_audit_model = RequestAuditModel(**req_audit_obj)
device_obj = {
"deviceId": request_data.deviceId,
"userId": request_data.userId,
"allocateBy": json_data["admin_id"]
}
device_audit_model = DeviceAuditModel(**device_obj)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if request_data and admin_data.role == "admin":
request_data.reqStatus = "approved"
device_data.status = "allocated"
device_data.assignTo = user_data.email
request_data.insert_request()
device_data.insert_device()
req_audit_model.insert_request_audit()
device_audit_model.insert_device_audit()
return {"Message": "Request Approved"}, 201
return {"Message": "Request Not Found"}, 401
return {"Message": "Device is not requested"}, 401
return {"Message": "Request Already Resolve"}, 403
def get(cls, deviceId):
device_data = DeviceModel.find_by_id(deviceId)
return DeviceSchema().dump(device_data), 201