예제 #1
0
 def get_user_by_id(user_id):
     """"""
     user = "******".format(USER_MICROSERVICE_URL, user_id)
     response = HttpUtils.make_get_request(user)
     if response is None:
         return None
     user_model = UserModel()
     user_model.fill_from_json(response)
     return user_model
예제 #2
0
 def force_reload_rating_all_restaurants():
     """
     This method call the restaurants api to force the microservice to recalculate
     the rating for each restaurants
     :return if the request is ok I rill return the request, otherwise None
     """
     user = "******".format(
         RESTAURANTS_MICROSERVICE_URL)
     return HttpUtils.make_get_request(user)
예제 #3
0
 def get_menu_restaurant(restaurant_id: int):
     """
     This method help to retrieve all information inside the
     """
     url = "{}/{}/menu".format(RESTAURANTS_MICROSERVICE_URL, restaurant_id)
     current_app.logger.debug("URL to microservices is {}".format(url))
     response = HttpUtils.make_get_request(url)
     if response is None:
         return None
     return response["menus"]
예제 #4
0
    def get_restaurant_name(restaurant_id):
        """
        Given the id return the name of the restaurant
        """
        response = HttpUtils.make_get_request("{}/{}/name".format(
            RESTAURANTS_MICROSERVICE_URL, restaurant_id))
        if response is None:
            return ""

        return response["result"]
예제 #5
0
 def get_count_of_positive_user():
     """
     This method perform the request to get all positive user inside the database
     """
     url = "{}/report_positive".format(USER_MICROSERVICE_URL)
     response = HttpUtils.make_get_request(url)
     if response is None or len(response) == 0:
         return []
     users = response["users"]
     return len(users)
예제 #6
0
    def get_restaurant_people(restaurant_id: int):
        """
        Given the id of the restaurant return the number of people at lunch and dinner
        """
        response = HttpUtils.make_get_request("{}/stats/{}".format(
            BOOKING_MICROSERVICE_URL, restaurant_id))
        if response is None:
            return [0, 0, 0]

        return [response["lunch"], response["dinner"], response["now"]]
예제 #7
0
 def get_opening_hours_restaurant(restaurant_id: int):
     """
     This method help to retreival all information inside the
     """
     url = "{}/{}/openings".format(RESTAURANTS_MICROSERVICE_URL,
                                   restaurant_id)
     response = HttpUtils.make_get_request(url)
     if response is None:
         return None
     return response["openings"]
예제 #8
0
 def get_all_restaurants():
     """
     Method to return a list of all restaurants inside the database
     """
     url = "{}".format(RESTAURANTS_MICROSERVICE_URL)
     current_app.logger.debug("URL microservices: {}".format(url))
     response = HttpUtils.make_get_request(url)
     if response is None:
         current_app.logger.error("Microservices error")
         return []
     return response["restaurants"]
예제 #9
0
    def get_customer_reservation(fromDate: str, toDate: str, customer_id: str):
        current_app.logger.debug("Filtering by: {}".format(
            [fromDate, toDate, customer_id]))

        # bind filter params...
        url = "{}?user_id={}".format(BOOKING_MICROSERVICE_URL, customer_id)
        if fromDate:
            url = HttpUtils.append_query(url, "fromDate", fromDate)
        if toDate:
            url = HttpUtils.append_query(url, "toDate", toDate)

        response = HttpUtils.make_get_request(url)
        return response
예제 #10
0
 def search_possible_contacts(email: str = None, phone: str = None):
     """
     Search all possible contact for the user with email of phone
     """
     if email is not None and len(email) != 0:
         url = USER_MICROSERVICE_URL + "/positiveinfo/email/" + str(email)
     elif phone is not None and len(phone) != 0:
         url = USER_MICROSERVICE_URL + "/positiveinfo/phone/" + str(phone)
     else:
         return None
     # check if the user exists (ON VIEW)
     # check if the user is positive (get also date of marking) (API) ????
     return HttpUtils.make_get_request(url)
예제 #11
0
    def get_reservation_rest(restaurant_id, from_date, to_date):
        """
        This method contains the logic to find all reservation in the restaurant
        with the filter on the date
        """

        url = "{}/list/{}".format(BOOKING_MICROSERVICE_URL, restaurant_id)
        if from_date:
            url = HttpUtils.append_query(url, "fromDate", from_date)
        if to_date:
            url = HttpUtils.append_query(url, "toDate", to_date)

        response = HttpUtils.make_get_request(url)
        return response
예제 #12
0
 def get_rest_by_id(id: int):
     """
     This method contains the logic to get an restaurants by id
     :param id: The restaurants id
     """
     url = "{}/{}".format(RESTAURANTS_MICROSERVICE_URL, id)
     current_app.logger.debug("URL to microservices is {}".format(url))
     restaurant = HttpUtils.make_get_request(url)
     if restaurant is None:
         return None
     current_app.logger.debug(restaurant)
     restaurant_model = RestaurantModel()
     restaurant_model.fill_from_json(restaurant)
     return restaurant_model
예제 #13
0
 def get_list_of_positive_user():
     """
     This method perform the request to get all positive user inside the database
     """
     url = "{}/report_positive".format(USER_MICROSERVICE_URL)
     response = HttpUtils.make_get_request(url)
     if response is None or len(response) == 0:
         return []
     users = response["users"]
     list_user = []
     for user in users:
         new_user = UserModel()
         new_user.fill_from_json(user)
         list_user.append(new_user)
     return list_user
예제 #14
0
    def get_three_reviews(restaurant_id):
        """
        Given the restaurant_di return three random reviews
        """
        response = HttpUtils.make_get_request("{}/{}/reviews/3".format(
            RESTAURANTS_MICROSERVICE_URL, restaurant_id))

        if response is None:
            return []

        review_list = []
        for json in response["Reviews"]:
            review = ReviewModel()
            review.fill_from_json(json)
            review_list.append(review)
        return review_list
예제 #15
0
 def get_photos_restaurants(restaurant_id: int):
     """
     This method retrieval all information about the restaurants photos
     """
     url = "{}/{}/photos".format(RESTAURANTS_MICROSERVICE_URL,
                                 restaurant_id)
     current_app.logger.debug("URL to microservices is {}".format(url))
     response = HttpUtils.make_get_request(url)
     if response is None:
         return None
     photos = []
     for json_photo in response["photos"]:
         current_app.logger.debug("photo {}, url {}".format(
             json_photo["id"], json_photo["url"]))
         new_photo = PhotoModel()
         new_photo.fill_from_json(json_photo)
         photos.append(new_photo)
     return photos
예제 #16
0
    def get_dishes_restaurant(restaurant_id: int):
        """
        This method return the restaurants dished
        """
        url = "{}/{}/dishes".format(RESTAURANTS_MICROSERVICE_URL,
                                    restaurant_id)
        current_app.logger.debug("URL to microservices is {}".format(url))
        response = HttpUtils.make_get_request(url)
        if response is None:
            return None
        dishes = []
        json_dishes = response["dishes"]
        for json_dish in json_dishes:
            new_dish = DishModel()
            new_dish.fill_from_json(json_dish)
            dishes.append(new_dish)

        return dishes
예제 #17
0
    def get_restaurants_by_keyword(name: str = None):
        """
        This method contains the logic to perform the search restaurant by keywords
        The keywords supported are:
        https://stackoverflow.com/questions/3325467/sqlalchemy-equivalent-to-sql-like-statement
        :param name: is the name of restaurants
        """
        if name is None:
            raise Exception("Name is required to make this type of research")
        response = HttpUtils.make_get_request("{}/search/{}".format(
            RESTAURANTS_MICROSERVICE_URL, name))

        rest_list = []
        for json in response["restaurants"]:
            rest = RestaurantModel()
            rest.fill_from_json(json)
            rest_list.append(rest)

        return rest_list
예제 #18
0
 def mark_positive(email: str = None, phone: str = None):
     """
     This method perform the request to user microservices to make the user positive
     """
     current_app.logger.debug("Asking to mark. Called with: {} , {}".format(
         email, phone))
     if email is not None and len(email) != 0:
         current_app.logger.debug(
             "marking with email because email len: {}".format(len(email)))
         key = "email"
         value = email
     elif phone is not None and len(phone) != 0:
         current_app.logger.debug(
             "marking with phone because phone len: {}".format(len(phone)))
         key = "phone"
         value = phone
     else:
         return None
     url = "{}/mark/{}/{}".format(USER_MICROSERVICE_URL, key, value)
     return HttpUtils.make_get_request(url)
예제 #19
0
    def get_restaurant_tables(restaurant_id: int):
        """
        This method retrieves all tables of a restaurant
        :param restaurant_id: id of the restaurant
        """
        url = "{}/{}/tables".format(RESTAURANTS_MICROSERVICE_URL,
                                    restaurant_id)
        response = HttpUtils.make_get_request(url)
        # if no tables
        if response is None:
            return []

        # otherwise pick from json all tables
        # model them into TableModel
        # and return a list of them
        all_tables = []
        for json_table in response["tables"]:
            current_app.logger.debug("table {}, seats {}".format(
                json_table["name"], json_table["max_seats"]))
            new_table = TableModel()
            new_table.fill_from_json(json_table)
            all_tables.append(new_table)
        return all_tables
예제 #20
0
    def search_contacts_for_email(user_email: str, user_phone: str):

        if user_email == "" and user_phone == "":
            return "Insert an email or a phone number"

        friends = []
        contacts = []
        past_restaurants = []
        future_restaurants = []

        if user_email != "":
            URL = USER_MICROSERVICE_URL + "/positiveinfo/email/" + str(
                user_email)
        else:
            URL = USER_MICROSERVICE_URL + "/positiveinfo/phone/" + str(
                user_phone)

        # check if the user exists
        # check if the user is positive (get also date of marking) (API)
        response = HttpUtils.make_get_request(URL)
        if response is None:
            return "Error, please try again"

        # now we have the information about the positivity of the user in response
        date_marking = response["from_date"]
        user_id = response["user_id"]

        # start to check contacts
        # API: get all reservation of the customer between date_marking and date_marking -14
        date_marking = datetime.strptime(date_marking, "%Y-%m-%d")
        to_date = date_marking - timedelta(days=14)
        reservations_customer = BookingServices.get_reservation_by_constraint(
            user_id, from_data=to_date, to_data=date_marking)

        if reservations_customer is not None:

            # API: get all reservations between date_marking and date_m -14
            all_reservations = BookingServices.get_reservation_by_constraint(
                from_data=to_date, to_data=date_marking)
            for reservation in reservations_customer:
                restaurant_id = reservation["table"]["restaurant"]["id"]
                restaurant = RestaurantServices.get_rest_by_id(restaurant_id)
                if restaurant is None:
                    continue
                friends = friends + reservation["people"]
                start = datetime.strptime(reservation["reservation_date"],
                                          "%Y-%m-%dT%H:%M:%SZ")
                end = datetime.strptime(reservation["reservation_end"],
                                        "%Y-%m-%dT%H:%M:%SZ")
                past_restaurants.append({
                    "email":
                    restaurant.owner_email,
                    "name":
                    restaurant.name,
                    "date":
                    start.strftime("%Y-%m-%dT%H:%M:%SZ"),
                })
                for one_reservation in all_reservations:
                    restaurant_id_contact = one_reservation["table"][
                        "restaurant"]["id"]
                    if restaurant_id_contact != restaurant_id:
                        continue

                    start_contact = datetime.strptime(
                        one_reservation["reservation_date"],
                        "%Y-%m-%dT%H:%M:%SZ")
                    end_contact = datetime.strptime(
                        one_reservation["reservation_end"],
                        "%Y-%m-%dT%H:%M:%SZ")
                    # if people are in the same restaurant in the same day
                    if start.date() != start_contact.date():
                        continue
                    openings = RestaurantServices.get_opening_hours_restaurant(
                        restaurant_id)

                    dayNumber = start.weekday()
                    restaurant_hours = []
                    for opening in openings:
                        if opening["week_day"] == dayNumber:
                            restaurant_hours.append(
                                datetime.strptime(opening["open_lunch"],
                                                  "%H:%M"))
                            restaurant_hours.append(
                                datetime.strptime(opening["close_lunch"],
                                                  "%H:%M"))
                            restaurant_hours.append(
                                datetime.strptime(opening["open_dinner"],
                                                  "%H:%M"))
                            restaurant_hours.append(
                                datetime.strptime(opening["close_dinner"],
                                                  "%H:%M"))

                    # if people are in the restaurant at lunch or dinner
                    if (restaurant_hours[0].time() <= start.time()
                            and restaurant_hours[1].time() >= end.time()) or (
                                restaurant_hours[2].time() <= start.time()
                                and restaurant_hours[3].time() >= end.time()):
                        # people are in the same restaurant at lunch
                        # if they are in the same time
                        if not ((end_contact < start) or
                                (start_contact > end)):
                            # they are contacts!
                            # API: get user email and name of the contact
                            user = UserService.get_user_by_id(
                                one_reservation["customer_id"])
                            if user is not None:
                                contacts.append({
                                    "email":
                                    user.email,
                                    "name":
                                    user.firstname,
                                    "restaurant_name":
                                    restaurant.name,
                                    "date":
                                    start.strftime("%Y-%m-%dT%H:%M:%SZ"),
                                })
                                friends = friends + one_reservation["people"]
        if user_email != "":
            customer_email = user_email
        else:
            URL = USER_MICROSERVICE_URL + "/" + str(user_id)
            user = HttpUtils.make_get_request(URL)
            customer_email = user["email"]

        # API booking: get all future booking of the customer
        future_reservations = BookingServices.get_reservation_by_constraint(
            user_id, from_data=to_date, to_data=date_marking)
        for future_reservation in future_reservations:
            date = datetime.strptime(reservation["reservation_date"],
                                     "%Y-%m-%dT%H:%M:%SZ")
            restaurant_id = future_reservation["table"]["restaurant"]["id"]
            restaurant = RestaurantServices.get_rest_by_id(restaurant_id)
            if restaurant is not None:
                future_restaurants.append({
                    "email":
                    restaurant.owner_email,
                    "name":
                    restaurant.name,
                    "date":
                    date.strftime("%Y-%m-%dT%H:%M:%SZ"),
                    "customer_email":
                    customer_email,
                })
        return {
            "friends": friends,
            "contacts": contacts,
            "past_restaurants": past_restaurants,
            "reservation_restaurants": future_restaurants,
        }
예제 #21
0
 def checkin_reservations(reservation_id: int):
     response = HttpUtils.make_get_request("{}/{}/checkin".format(
         BOOKING_MICROSERVICE_URL, reservation_id))
     return response