def delete_comment(cls, db, room_id, comment_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") comment = db.query(RoomComment).get(comment_id) if comment is None: raise NotFoundError("room comment") if not comment.is_from(room_id): raise NoRelationError("room", "room comment") db.delete(comment) if not comment.is_answer(): answers = db.query(RoomComment)\ .filter(RoomComment.main_comment_id == comment_id)\ .all() for answer in answers: db.delete(answer) db.commit() return comment.serialize()
def get_room_review(cls, db, room_id, review_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") room_review = db.query(RoomReview).get(review_id) if room_review is None: raise NotFoundError("room review") if not room_review.is_from(room_id): raise NoRelationError("room", "room review") return room_review.serialize()
def get_comment(cls, db, room_id, comment_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") comment = db.query(RoomComment).get(comment_id) if comment is None: raise NotFoundError("room comment") if not comment.is_from(room_id): raise NoRelationError("room", "room comment") return comment.serialize()
def get_room_rating(cls, db, room_id, rating_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") room_rating = db.query(RoomRating).get(rating_id) if room_rating is None: raise NotFoundError("room rating") if not room_rating.is_from(room_id): raise NoRelationError("room", "room rating") return room_rating.serialize()
def _remove_image(self, filename): bucket = storage.bucket(app=self.app) blob = bucket.get_blob(filename) if blob is None: raise NotFoundError("Photo") blob.delete()
def get_room(cls, db, room_id): room = db.query(Room).get(room_id) if room is None: raise NotFoundError("room") return room.serialize()
def get_user(cls, db, uuid): registerd_user = (db.query(RegisteredUser).filter( RegisteredUser.uuid == uuid).first()) if registerd_user is None: raise NotFoundError("User") return registerd_user.serialize()
def delete_room_booking(cls, db, room_id, booking_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") room_booking = db.query(RoomBooking)\ .get(booking_id) if room_booking is None: raise NotFoundError("room booking") if not room_booking.is_from(room_id): raise NoRelationError("room", "room booking") db.delete(room_booking) db.commit() return room_booking.serialize()
def get_by_email(cls, db, email): registerd_user = (db.query(RegisteredUser).filter( RegisteredUser.email == email).first()) if registerd_user is None: raise NotFoundError("User") return registerd_user.serialize()
def get_room_photo(cls, db, room_id, firebase_id): room_photo = (db.query(RoomPhoto).filter( RoomPhoto.room_id == room_id).filter( RoomPhoto.firebase_id == firebase_id).first()) if room_photo is None: raise NotFoundError("room_photo") return room_photo.serialize()
def delete_by_uuid(cls, db, uuid): registerd_user = db.query(RegisteredUser).get(uuid) if registerd_user is None: raise NotFoundError("User") db.delete(registerd_user) db.commit() return registerd_user.serialize()
def delete_room(cls, db, room_id): room = db.query(Room).get(room_id) # TODO -> borrar todos los comentarios y reviews/ratings if room is None: raise NotFoundError("room") db.delete(room) db.commit() return room.serialize()
def get_all_ratings(cls, db, room_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") rating_list = db.query(RoomRating)\ .filter(room_id == RoomRating.room_id)\ .all() serialized_list = [] for rating in rating_list: serialized_list.append(rating.serialize()) return serialized_list
def add_new_comment(cls, db, room_id, comment_args): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") if comment_args.main_comment_id is not None: if not cls.comment_is_present(db, comment_args.main_comment_id): raise NotFoundError("room comment") main_comment = db.query(RoomComment).get( comment_args.main_comment_id) if main_comment.is_answer(): raise MainCommentIsAnswerError() new_comment = RoomComment(comment=comment_args.comment, room_id=room_id, commentator=comment_args.commentator, commentator_id=comment_args.commentator_id, main_comment_id=comment_args.main_comment_id) db.add(new_comment) db.commit() return new_comment.serialize()
def add_new_room_rating(cls, db, room_id, room_rating_args): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") new_room_rating = RoomRating( rating=room_rating_args.rating, room_id=room_id, reviewer=room_rating_args.reviewer, reviewer_id=room_rating_args.reviewer_id, ) db.add(new_room_rating) db.commit() return new_room_rating.serialize()
def get_comment_with_answers(cls, db, room_id, comment_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") comment = db.query(RoomComment).get(comment_id) answers = db.query(RoomComment) \ .filter(comment.id == RoomComment.main_comment_id) \ .all() serialized_answers = [] for answer in answers: serialized_answers.append(answer.serialize()) return {"comment": comment.serialize(), "answers": serialized_answers}
def add_new_room_review(cls, db, room_id, room_review_args): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") new_room_review = RoomReview( review=room_review_args.review, room_id=room_id, reviewer=room_review_args.reviewer, reviewer_id=room_review_args.reviewer_id, ) db.add(new_room_review) db.commit() return new_room_review.serialize()
def get_all_comments(cls, db, room_id): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") main_comments = db.query(RoomComment) \ .filter(room_id == RoomComment.room_id and RoomComment.main_comment_id is None) \ .all() all_comments = [] for comment in main_comments: comment_with_answers = cls.get_comment_with_answers( db, room_id, comment.id) all_comments.append(comment_with_answers) return all_comments
def get_uuid_from_token(cls, token): # if not cls.url: # cls._mock_get_info(int(token)) # return int(token) response, code = Requester.auth_srv_fetch( method="GET", path="/user/id", expected_statuses={HTTP_200_OK}, payload={}, extra_headers=cls.tkn_hdr(token), ) logger.debug("Auth server get uuid response: %s, status_code: %s", response, code) if code != 200: raise NotFoundError("User") logger.info("Obtained user uuid: %d", response["uuid"]) return response["uuid"]
def update_room(cls, db, room_id, update_args): room = db.query(Room).get(room_id) if room is None: raise NotFoundError("room") # we should see if is necessary to update # owner and owner id. May be this should # be a restricted method) if update_args.title is not None: room.title = update_args.title if update_args.description is not None: room.description = update_args.description if update_args.type is not None: room.type = update_args.type if update_args.price_per_day is not None: room.price_per_day = update_args.price_per_day if validate_location_args(update_args): room.coordinates = WKTElement( f'POINT({update_args.longitude} {update_args.latitude})', srid=4326) room.location = update_args.location if update_args.capacity is not None: room.capacity = update_args.capacity if update_args.blocked is not None: room.blocked = update_args.blocked db.commit() return room.serialize()
def add_new_room_booking(cls, db, room_id, room_booking_args): if not RoomDAO.room_is_present(db, room_id): raise NotFoundError("room") booking_to = room_booking_args.date_to booking_from = room_booking_args.date_from bookings_on_same_date = cls.bookings_on_same_date( db, room_id, booking_from, booking_to) if bookings_on_same_date > 0: raise RoomAlreadyBookedError() new_room_booking = RoomBooking( id=room_booking_args.id, room_id=room_id, date_to=booking_to, date_from=booking_from, ) db.add(new_room_booking) db.commit() return new_room_booking.serialize()