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