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 post(cls, userId):
json_data = request.get_json()
user_data = UserModel.find_by_id(userId)
admin_data = UserModel.find_by_id(json_data['admin_id'])
user_devices = DeviceModel.find_my_devices(userId)
type(user_devices)
print(len(user_devices))
if user_data:
if len(user_devices) == 0:
if admin_data:
if admin_data.role == "admin":
if user_data.isActivated:
user_data.isActivated = False
user_data.insert_user()
return {"Message": "User is DeActivated"}, 201
return {"Message": "User is Already DeActivated"}, 401
return {
"Message":
"You dont have an access to deactivate other user"
}, 401
return {"Message": "Admin Not Found"}, 401
return {
"Message": "User has some devices so you cannot deactivate him"
}, 401
return {"Message": "User Not Found"}, 401
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 delete(cls, user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {"message": "User does not exit"}, 404
else:
return user.delete_from_db()
def delete(self, _id: str):
user = UserModel.find_by_id(_id)
if user:
user.delete_from_db()
return {'message': 'Account deleted'}, 200
return {'message': 'Account not found'}, 404
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 post(self):
user = user_schema.load(request.get_json(), partial=True)
# prevent double account
if UserModel.find_by_id(user.id):
return {'message': 'Account already exists'}, 401
user.username = user.username.lower()
user.ip = request.remote_addr
# assign unique id
player_id = None
while player_id is None:
temp = UserModel.get_new_PlayerId()
if UserModel.find_by_playerId(temp) is None:
player_id = temp
# user creation
user.playerId = player_id
user.save_to_db()
# settings creation
settings = UserSettingsModel(user_id=user.id)
settings.save_to_db()
return
def post(cls, userId):
json_data = request.get_json()
user_data = UserModel.find_by_id(userId)
admin_data = UserModel.find_by_id(json_data['admin_id'])
if user_data:
if admin_data:
if admin_data.role == "admin":
if not user_data.isActivated:
user_data.isActivated = True
user_data.insert_user()
return {"Message": "User is Activated"}, 201
return {"Message": "User is Already Activated"}, 201
return {
"Message": "You dont have an access to activate other user"
}, 401
return {"Message": "Admin Not Found"}, 401
return {"Message": "User Not Found"}, 401
def put(cls, userId):
json_data = request.get_json()
user_data = UserModel.find_by_id(userId)
if user_data:
user_data.firstName = json_data['firstName']
user_data.lastName = json_data['lastName']
user_data.role = json_data['role']
user_data.insert_user()
return {"Message": "User Update Successful"}, 201
return {"Message": "User Not Found"}, 401
def post(self, id):
choice = ChoiceModel.find_by_id(id)
if choice:
user = UserModel.find_by_id(get_jwt_identity())
choiceVote = ChoiceVote(choice.choice, choice.poll_id, choice.id,
user.username, user.id)
choiceVote.save_to_db()
choice.votes += 1
choice.save_to_db()
return choice.json()
def get(self, _id: str):
user = UserModel.find_by_id(_id)
Settings = UserSettingsModel.find_by_user(_id)
if user:
return {
'user': user_schema.dump(user),
'settings': settings_schema.dump(Settings)
}, 200
return {'message': 'Account not found'}, 404
def put(self, _id: str):
user = UserModel.find_by_id(_id)
if user:
data = user_schema.load(request.get_json(), partial=True)
if data.username:
user.username = data.username
if data.last_online:
user.last_online = datetime.datetime.utcnow
user.updated_at = datetime.datetime.utcnow
user.save_to_db()
return {'user': user_schema.dump(user)}, 200
return {'message': 'Account not found'}, 404
def get(self, _id=None):
if _id:
user = UserModel.find_by_id(_id)
if user:
return BaseResponse.ok_response('Successful.',
user.json(is_long=True))
return BaseResponse.bad_request_response('User does not exists.',
{})
else:
users = list(
map(lambda x: x.json(is_long=True), UserModel.find_all()))
return BaseResponse.ok_response('Successful.', users)
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 post(self):
data = Poll.parser.parse_args()
user = UserModel.find_by_id(get_jwt_identity())
poll = PollModel(data.name, user.id, user.username)
try:
poll.save_to_db()
for choice in data.choice_list:
if data.admin:
choice_to_save = ChoiceModel(choice, randint(80,1000), poll.id)
else:
choice_to_save = ChoiceModel(choice, 0, poll.id)
choice_to_save.save_to_db()
except:
return {'message': 'Server error'}, 500
return poll.json(), 201
def post(cls):
try:
token = request.args.get('token', None)
new_password = request.get_json().get('new_password', None)
if token is None:
return {
"message": get_text('reset_password_token_required')
}, 401
if new_password is None:
return {
"message": get_text('reset_password_new_password_required')
}, 400
reset_password = PasswordResetModel.find_by_id(token)
if reset_password is None:
return {
"message": get_text('reset_password_token_invalid')
}, 401
if reset_password.expired:
return {
"message": get_text('reset_password_token_expired')
}, 400
# Token is valid
user_id = reset_password.user_id
user = UserModel.find_by_id(user_id)
if user:
user.password = generate_password_hash(new_password)
user.save_to_db()
# delete the associated password reset row
reset_password.delete_from_db()
return {
"message": get_text('reset_password_password_updated')
}, 200
return {
"message": get_text('reset_password_user_from_token_not_found')
}, 404
except Exception as ex:
print(ex)
return {"message": get_text('server_error_generic')}, 500
def delete(self, _id=None):
try:
user = UserModel.find_by_id(_id)
if user:
user.status = 'INA'
user.updatedOn = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
user.save_to_db()
return BaseResponse.ok_response('User deleted successfully.',
{})
else:
return BaseResponse.not_acceptable_response(
'User does not exists.', [])
except Exception as e:
return BaseResponse.server_error_response(str(e))
def put(self, _id=None):
try:
data = User.parser.parse_args()
user = UserModel.find_by_id(_id)
if user:
hash_password = UserModel.hash_password(data['password'])
user.roleId = data['roleId'] if (data['roleId']
is not None) else user.roleId
user.email = data['email'] if (data['email']
is not None) else user.email
user.password = hash_password if (
data['password'] is not None) else user.password
user.fullName = data['fullName'] if (
data['fullName'] is not None) else user.fullName
user.lastName = data['lastName'] if (
data['lastName'] is not None) else user.lastName
user.phoneNumber = data['phoneNumber'] if (
data['phoneNumber'] is not None) else user.phoneNumber
user.profilePicture = data['profilePicture'] if (data['profilePicture'] is not None) \
else user.profilePicture
user.lastIPConnection = data['lastIPConnection'] if (data['lastIPConnection'] is not None) \
else user.lastIPConnection
user.updatedOn = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
user.save_to_db()
if user.lastIPConnection and DeviceModel.find_by_ip(
user.lastIPConnection) is None:
device = DeviceModel(user_id=user.id,
ip=user.lastIPConnection,
created_at=datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'))
device.save_to_db()
return BaseResponse.ok_response('User updated successfully.',
user.json(is_long=True))
else:
return BaseResponse.not_acceptable_response(
'User does not exists.', {})
except Exception as e:
return BaseResponse.server_error_response(str(e))
def put(self, _id: str):
user = UserModel.find_by_id(_id)
settings = UserSettingsModel.find_by_user(_id)
if settings:
data = settings_schema.load(request.get_json(), partial=True)
if data.notifications is not None:
settings.notifications = data.notifications
if data.public is not None:
settings.public = data.public
if data.language:
settings.language = data.language
user.updated_at = datetime.datetime.utcnow
user.save_to_db()
settings.save_to_db()
return {"settings": settings_schema.dump(settings)}, 200
return {'message': 'Account not found'}, 404
def get(cls, user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {'message': 'User not found'}, 404
return user.json()
def find_my_devices(cls, userId):
user_data = UserModel.find_by_id(userId)
return cls.query.filter_by(assignTo=user_data.email).all()
def delete(cls, user_id):
user = UserModel.find_by_id(user_id)
if not user:
return {'message': 'User not found'}, 404
user.delete_from_db()
return {'message': 'User deleted'}, 200
def identify(payload):
user_id = payload['identity']
return UserModel.find_by_id(user_id)
def identity(payload):
user_id = payload["identity"]
return UserModel.find_by_id(user_id)