def post(self):
request_dict = request.get_json()
if not request_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
errors = bookable_room_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
try:
resort_name = request_dict['resort']['name']
resort = Resort.query.filter_by(name=resort_name).first()
if resort is None:
# Resort does not exist
resp = {'message': 'resort name does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
room_type_name = request_dict['room_type']['name']
room_type = RoomType.query.filter_by(name=room_type_name).first()
if room_type is None:
# Room Type does not exist
resp = {'message': 'room type name does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
bookable_room = BookableRoom(resort, room_type)
bookable_room.add(bookable_room)
log_event(get_jwt_identity(), "ADD - " + bookable_room.__repr__())
query = BookableRoom.query.get(bookable_room.id)
result = bookable_room_schema.dump(query)
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def put(self, id):
room_type = RoomType.query.get_or_404(id)
update_dict = request.get_json()
if not update_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
if 'name' in update_dict:
room_type.name = update_dict['name']
if 'sleeps' in update_dict:
room_type.sleeps = update_dict['sleeps']
dumped_message, dump_errors = room_type_schema.dump(room_type)
if dump_errors:
return dump_errors, status.HTTP_400_BAD_REQUEST
validate_errors = room_type_schema.validate(dumped_message)
if validate_errors:
return validate_errors, status.HTTP_400_BAD_REQUEST
try:
room_type.update()
log_event(get_jwt_identity(), "UPDATE - " + room_type.__repr__())
return self.get(id)
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def put(self, owner_id):
owner_email = OwnerEmail.query.get_or_404(owner_id)
update_dict = request.get_json()
if not update_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
if 'owner_email' in update_dict:
owner_email.owner_email = update_dict['owner_email']
if 'access_level' in update_dict:
owner_email.access_level = update_dict['access_level']
dumped_message, dump_errors = owner_email_schema.dump(owner_email)
if dump_errors:
return dump_errors, status.HTTP_400_BAD_REQUEST
validate_errors = owner_email_schema.validate(dumped_message)
if validate_errors:
return validate_errors, status.HTTP_400_BAD_REQUEST
try:
log_event(get_jwt_identity(), 'UPDATE - ' + owner_email.__repr__())
owner_email.update()
return self.get(owner_id)
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def post(self):
request_dict = request.get_json()
if not request_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
errors = owner_email_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
try:
owner_name = request_dict['owner']['name']
owner = Owner.query.filter_by(name=owner_name).first()
if owner is None:
# Owner does not exist
resp = {'message': 'owner name does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
# Now that we are sure we have an owner
# create a new owner email
owner_email = OwnerEmail(request_dict['owner_email'], owner)
if 'access_level' in request_dict:
owner_email.access_level = request_dict['access_level']
owner_email.add(owner_email)
log_event(get_jwt_identity(), 'ADD - ' + owner_email.__repr__())
query = OwnerEmail.query.get(owner_email.id)
result = owner_email_schema.dump(query)
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def post(self):
request_dict = request.get_json()
if not request_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
bank_date = datetime.datetime.fromtimestamp(
request_dict['epoch_bank_date'])
bankable_points = ActualPoint.query.\
filter(ActualPoint.use_year < bank_date,
ActualPoint.use_year > (bank_date + relativedelta(years=-1))).\
filter(ActualPoint.trip_id.is_(None)).filter(ActualPoint.banked_date.is_(None)).\
limit(request_dict['count_to_bank']).all()
if request_dict['count_to_bank'] > len(bankable_points):
resp = jsonify(
{"error": "requested bank is more than available bankable points"})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
for point in bankable_points:
point.banked_date = bank_date
log = 'POINTS BANKED - %s points banked with a bank date of %s' % (len(bankable_points),
bank_date.strftime('%Y-%m-%d %H:%M:%S'))
db.session.commit()
log_event(get_jwt_identity(), log)
resp = jsonify({})
resp.status_code = status.HTTP_201_CREATED
return resp
def put(self, trip_id):
trip = Trip.query.get_or_404(trip_id)
update_dict = request.get_json()
if not update_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
if not update_dict['notes']:
resp = {'message': 'Notes field required for update'}
return resp, status.HTTP_400_BAD_REQUEST
# ## trips update only allows notes to be updated ##
# errors = trip_schema.validate(update_dict)
# if errors:
# return errors, status.HTTP_400_BAD_REQUEST
try:
if trip.notes is None:
original_notes = '<NULL>'
else:
original_notes = trip.notes
if 'notes' in update_dict:
if update_dict['notes'] == trip.notes:
resp = jsonify(
{"error": "Notes value did not change from DB value"})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
trip.notes = update_dict['notes']
trip.update()
log_event(get_jwt_identity(), 'UPDATE - Trip ' + str(trip.id) + ' notes to (' + trip.notes + ') from ('
+ original_notes + ')')
return self.get(trip_id)
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def delete(self, id):
resort = Resort.query.get_or_404(id)
try:
resort.delete(resort)
log_event(get_jwt_identity(), "DELETE - " + resort.__repr__())
return None, status.HTTP_200_OK
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_401_UNAUTHORIZED
return resp
def delete(self, owner_id):
owner_email = OwnerEmail.query.get_or_404(owner_id)
try:
owner_email.delete(owner_email)
log_event(get_jwt_identity(), 'DELETE - ' + owner_email.__repr__())
return '', status.HTTP_204_NO_CONTENT
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_401_UNAUTHORIZED
return resp
def post(self):
request_dict = request.get_json()
if not request_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
errors = resort_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
try:
resort = Resort(request_dict['name'])
resort.add(resort)
log_event(get_jwt_identity(), "ADD - " + resort.__repr__())
query = Resort.query.get(resort.id)
result = resort_schema.dump(query)
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def put(self, owner_id):
owner = Owner.query.get_or_404(owner_id)
update_dict = request.get_json()
if not update_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
errors = owner_schema.validate(update_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
try:
if 'name' in update_dict:
owner.name = update_dict['name']
owner.update()
log_event(get_jwt_identity(), 'UPDATE - ' + owner.__repr__())
return self.get(owner_id)
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def delete(self, trip_id: int):
trip: Trip = db.session.query(Trip).get_or_404(trip_id)
personal_points = db.session.query(
PersonalPoint).filter_by(trip_id=trip_id).all()
for point in personal_points:
point.trip_id = None
actual_points = db.session.query(
ActualPoint).filter_by(trip_id=trip_id).all()
for point in actual_points:
point.trip_id = None
try:
db.session.delete(trip)
db.session.commit()
log_event(get_jwt_identity(), 'DELETE - ' + trip.__repr__())
return None, status.HTTP_200_OK
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_401_UNAUTHORIZED
return resp
def put(self, id):
bookable_room = BookableRoom.query.get_or_404(id)
update_dict = request.get_json()
if not update_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
if 'resort' in update_dict:
resort_name = update_dict['resort']['name']
resort = Resort.query.filter_by(name=resort_name).first()
if resort is None:
# Resort does not exist
resp = {'message': 'resort name does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
bookable_room.resort = resort
if 'room_type' in update_dict:
room_type_name = update_dict['room_type']['name']
room_type = RoomType.query.filter_by(name=room_type_name).first()
if room_type is None:
# Resort does not exist
resp = {'message': 'room type name does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
bookable_room.room_type = room_type
dumped_message, dump_errors = bookable_room_schema.dump(bookable_room)
if dump_errors:
return dump_errors, status.HTTP_400_BAD_REQUEST
validate_errors = bookable_room_schema.validate(dumped_message)
if validate_errors:
return validate_errors, status.HTTP_400_BAD_REQUEST
try:
bookable_room.update()
log_event(get_jwt_identity(),
"UPDATE - " + bookable_room.__repr__())
return self.get(id)
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
def google_auth_login(post_data):
token = post_data.get('google_id_token')
client_id = '352426068501-r1o358blf1hqnhvnh5olce4b5toasadj.apps.googleusercontent.com'
idinfo = id_token.verify_oauth2_token(token, requests.Request(),
client_id)
# check issuer
if idinfo['iss'] not in [
'accounts.google.com', 'https://accounts.google.com'
]:
response_object = {
'status': 'fail',
'message': 'Not a valid issuer.'
}
log_event(idinfo['email'], 'UNAUTHORIZED - Not a valid user')
return response_object, status.HTTP_401_UNAUTHORIZED
# check expired
if idinfo['exp'] < time.time():
response_object = {'status': 'fail', 'message': 'Token is expired'}
log_event(idinfo['email'], 'UNAUTHORIZED - Token is expired')
return response_object, status.HTTP_401_UNAUTHORIZED
# find a valid owner email
# owner = OwnerEmail.query.filter_by(owner_email = idinfo['email']).first()
owner = Owner.query.join(OwnerEmail).filter(
OwnerEmail.owner_email == idinfo['email']).first()
if owner:
access_level = 0
for owner_emails in owner.email:
if owner_emails.owner_email == idinfo['email']:
access_level = owner_emails.access_level
# print(owner_emails.owner_email + " has access level " + str(owner_emails.access_level))
user_claims = {"access_level": access_level}
access_token = create_access_token(
identity=idinfo['email'],
expires_delta=timedelta(minutes=60),
user_claims=user_claims)
refresh_token = create_refresh_token(identity=idinfo['email'])
decoded_token = decode_token(access_token)
response_object = {
'status': 'success',
'message': 'Successfully logged in.',
'access_token': access_token,
'refresh_token': refresh_token,
'exp': decoded_token['exp'],
'owner': owner.name,
'email': idinfo['email'],
'picture': idinfo['picture'],
'access_level': access_level
}
log_event(idinfo['email'],
'User authenticated - ' + owner.__repr__())
return response_object, status.HTTP_201_CREATED
else:
response_object = {
'status': 'fail',
'message': 'Matching owner email not found'
}
log_event(idinfo['email'], 'UNAUTHORIZED - Valid owner not found')
return response_object, status.HTTP_401_UNAUTHORIZED
def post(self):
request_dict = request.get_json()
if not request_dict:
resp = {'message': 'No input data provided'}
return resp, status.HTTP_400_BAD_REQUEST
errors = trip_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
else:
# create a new trip object and validate data
trip_owner = Owner.query.filter_by(
name=request_dict['owner']['name']).first()
if trip_owner is None:
# owner does not exist
resp = {'message': 'owner does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
# new_trip.owner_id = trip_owner.id
trip_bookable_room = BookableRoom.query. \
filter(BookableRoom.resort.has(name=request_dict['bookable_room']['resort']['name'])). \
filter(BookableRoom.room_type.has(
name=request_dict['bookable_room']['room_type']['name'])).first()
if trip_bookable_room is None:
# Resort does not exist
resp = {'message': 'bookable room does not exist'}
return resp, status.HTTP_400_BAD_REQUEST
new_trip = Trip(trip_owner, trip_bookable_room)
new_trip.check_in_date = datetime.strptime(
request_dict['check_in_date'].split('T')[0], '%Y-%m-%d')
new_trip.check_out_date = datetime.strptime(
request_dict['check_out_date'].split('T')[0], '%Y-%m-%d')
if new_trip.check_in_date >= new_trip.check_out_date:
resp = {'message': 'check out must be after check in date'}
return resp, status.HTTP_400_BAD_REQUEST
new_trip.booked_date = datetime.strptime(
request_dict['booked_date'].split('T')[0], '%Y-%m-%d')
new_trip.notes = request_dict['notes']
new_trip.points_needed = request_dict['points_needed']
if new_trip.points_needed < 0:
resp = {'message': 'points needed must be at least 1'}
return resp, status.HTTP_400_BAD_REQUEST
db.session.flush()
# New trip is valid now try to allocate points
current_use_year = new_trip.check_in_date
previous_use_year = current_use_year+relativedelta(years=-1)
next_use_year = current_use_year+relativedelta(years=1)
previous_two_use_year = current_use_year+relativedelta(years=-2)
booked_date = new_trip.booked_date
personal_points_needed = new_trip.points_needed
trip_owner_id = new_trip.owner_id
# Find banked personal points
personal_points_banked = db.session.query(PersonalPoint)\
.filter(PersonalPoint.owner_id == trip_owner_id,
PersonalPoint.trip_id.is_(None),
PersonalPoint.use_year < previous_use_year)\
.order_by("use_year").order_by("point_number")\
.limit(personal_points_needed).all()
for point in personal_points_banked:
point.trip_id = new_trip.id
personal_points_needed -= len(personal_points_banked)
# IF more points needed look for current personal points
if personal_points_needed > 0:
personal_points_current = db.session.query(PersonalPoint)\
.filter(PersonalPoint.use_year < current_use_year, PersonalPoint.use_year > previous_use_year)\
.filter(PersonalPoint.owner_id == new_trip.owner_id)\
.filter(PersonalPoint.trip_id.is_(None))\
.order_by("use_year").order_by("point_number")\
.limit(personal_points_needed).all()
for point in personal_points_current:
point.trip_id = new_trip.id
personal_points_needed -= len(personal_points_current)
else:
personal_points_current = []
# IF more points needed look for borrow personal points
if personal_points_needed > 0:
personal_points_borrow = db.session.query(PersonalPoint) \
.filter(PersonalPoint.use_year < next_use_year, PersonalPoint.use_year > current_use_year) \
.filter(PersonalPoint.owner_id == new_trip.owner_id) \
.filter(PersonalPoint.trip_id.is_(None)) \
.order_by("use_year").order_by("point_number") \
.limit(personal_points_needed).all()
for point in personal_points_borrow:
point.trip_id = new_trip.id
personal_points_needed -= len(personal_points_borrow)
else:
personal_points_borrow = []
# IF more personal points requirement was satisfied
if personal_points_needed > 0:
db.session.rollback()
resp = {
'message': 'personal points shortage of %s points' % personal_points_needed}
return resp, status.HTTP_400_BAD_REQUEST
# FIND actual points
actual_points_needed = new_trip.points_needed
actual_points_banked = db.session.query(ActualPoint)\
.filter(ActualPoint.use_year < previous_use_year, ActualPoint.use_year > previous_two_use_year)\
.filter(ActualPoint.trip_id.is_(None))\
.filter(ActualPoint.banked_date < booked_date) \
.order_by("use_year").order_by("point_number") \
.limit(actual_points_needed).all()
for point in actual_points_banked:
point.trip_id = new_trip.id
actual_points_needed -= len(actual_points_banked)
# IF actual points requirement is satisfied
if actual_points_needed > 0:
actual_points_current = db.session.query(ActualPoint)\
.filter(ActualPoint.use_year < current_use_year, ActualPoint.use_year > previous_use_year)\
.filter(ActualPoint.trip_id.is_(None))\
.filter(or_(ActualPoint.banked_date.is_(None), ActualPoint.banked_date > booked_date)) \
.order_by("use_year").order_by("point_number") \
.limit(actual_points_needed).all()
for point in actual_points_current:
point.trip_id = new_trip.id
actual_points_needed -= len(actual_points_current)
else:
actual_points_current = []
# IF actual points requirement is satisfied
if actual_points_needed > 0:
actual_points_borrow = db.session.query(ActualPoint)\
.filter(ActualPoint.use_year < next_use_year, ActualPoint.use_year > current_use_year)\
.filter(ActualPoint.trip_id.is_(None))\
.order_by("use_year").order_by("point_number")\
.limit(actual_points_needed).all()
for point in actual_points_borrow:
point.trip_id = new_trip.id
actual_points_needed -= len(actual_points_borrow)
else:
actual_points_borrow = []
# IF more personal points requirement was satisfied
if actual_points_needed > 0:
db.session.rollback()
resp = {
'message': 'actual points shortage of %s points' % actual_points_needed}
return resp, status.HTTP_400_BAD_REQUEST
# ALL is good commit to db and return success
try:
log_event(get_jwt_identity(), 'CREATE - ' + new_trip.__repr__())
log_event(get_jwt_identity(),
'Personal Points Allocated: [%s,%s,%s]' % (len(personal_points_banked),
len(personal_points_current),
len(personal_points_borrow)))
log_event(get_jwt_identity(),
'Actual Points Allocated: [%s,%s,%s]' % (len(actual_points_banked),
len(actual_points_current),
len(actual_points_borrow)))
db.session.commit()
result = trip_schema.dump(new_trip)
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = status.HTTP_400_BAD_REQUEST
return resp
