def attend(self, order): Logger.info( f"Attending order_id={order['orderId']} item_id={order['item']['id']}" ) self.__product_dao.update_item(order_id=int(order['orderId']), item_id=int(order["item"]["id"]), status="DONE")
def call_support(self, user_id: int, message: str): Logger.info(f"publishing to {self.__drink_topic}: {user_id}") self.__producer.send(topic=self.__drink_topic, value={ "userId": user_id, "message": message })
def process_dataset(self): movies_count = 0 for movie in self.__dataset_repository.iterate_over_movies(): if movies_count > self.__max_movies: break self.__movies_repository.add_movie(movie) Logger.info(f"Sent movie {movies_count+1}/{self.__max_movies} - {movie['name']}") movies_count += 1
def list_movies(): response: dict status_code: int = 200 try: Logger.info(f"list_movies") response = service.list_movies() except Exception as exception: status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def ranking_by_gender(gender: str): response: dict status_code: int = 200 try: Logger.info(f"ranking_by_gender - gender={gender}") response = ranking_service.ranking_by_gender(gender) except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def post_watched(user_id: int, movie_id: int): response: dict = {} status_code: int = 204 try: Logger.info(f"post_watched: user_id:{user_id} movie_id={movie_id}") watched_service.post_watched(user_id, movie_id) except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback( exception, status_code) return UtilController.build_response(response, status_code)
def list_reminder(): response: dict status_code: int = 200 try: Logger.info(f"list_reminder") response = reminder_service.list_reminder() except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback( exception, status_code) return UtilController.build_response(response, status_code)
def get_reminder(user_id: int): response: dict status_code: int = 200 try: Logger.info(f"get_reminder: user_id={user_id}") response = reminder_service.get_reminder(user_id) except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback( exception, status_code) return UtilController.build_response(response, status_code)
def post_support(user_id: int): response: dict status_code: int = 204 try: Logger.info(f"post_support") message = request.json response = support_service.call_support(user_id, message) except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def filter_movie(movie_id: int): response: dict status_code: int = 200 try: Logger.info(f"filter_movie - movie_id:{movie_id}") response = service.filter_movie(movie_id) if not response: status_code = 404 response = {} except Exception as exception: status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def similar_to(self, shoes: Shoes) -> List[Shoes]: query: str = ''' SELECT ?shoes ?shoes_name ?characteristic FROM <http://mecansei.com/ontology/v1>{ :''' + shoes.id + ''' :similar ?shoes . ?shoes :has_characteristic ?characteristic; :name ?shoes_name . } ORDER BY ?shoes ?shoes_name ?characteristic ''' Logger.info(query) response = self.__client.select(query, reasoning=True) return self.__build_shoes_array(response)
def filter_movies_by_gender(gender: str): response: dict status_code: int = 200 try: Logger.info(f"filter_movies_by_gender - gender:{gender}") response = service.filter_movies_by_gender(gender) if not response: status_code = 404 response = {} except Exception as exception: status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def find_shoes(self) -> List[Shoes]: query: str = """ SELECT ?shoes ?shoes_name ?characteristic FROM <http://mecansei.com/ontology/v1>{ ?shoes a :Shoes; :has_characteristic ?characteristic; :name ?shoes_name . } ORDER BY ?shoes ?shoes_name ?characteristic """ Logger.info(query) response = self.__client.select(query) return self.__build_shoes_array(response)
def filter_movies_by_query_string(): response: dict status_code: int = 200 try: query = request.args["q"] Logger.info(f"filter_movies_by_query_string - query:{query}") response = service.filter_movies_by_query_string(query) if not response: status_code = 404 response = {} except Exception as exception: status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def add_movie(): response: dict status_code: int = 204 try: movie = request.json Logger.info(f"add_movie: movie={movie['name']}") response = service.add_movie( movie=movie ) except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback(exception, status_code) return UtilController.build_response(response, status_code)
def get_votes_by(movie_id: int): response: dict status_code: int = 200 try: Logger.info(f"get_votes_by: movie_id={movie_id}") response = vote_service.get_votes_by(movie_id) if not response: status_code = 404 response = {} except Exception as exception: Logger.error(str(exception)) status_code = 500 response = UtilController.build_error_payback( exception, status_code) return UtilController.build_response(response, status_code)
def insert(self, shoes: Shoes): properties: str = "" for prop in shoes.properties: properties += f" {prop}," properties = properties[:-1] query: str = """ INSERT DATA { GRAPH <http://mecansei.com/ontology/v1> { :""" + shoes.id + """ a :Shoes ; :has_characteristic""" + properties + """ ; :name '""" + shoes.name + """' . } } """ Logger.info(query) self.__client.update(query)
def __init__(self, host: str, port: int, default_db: str): Logger.info(f"Connecting to mongo using host: {host} and port: {port}") self.__client = MongoClient( host=host, port=port ) Logger.info(f"Mongo connected. Accessing database: {default_db}") self.__database = self.__client[default_db] Logger.info(f"Database connection status: {self.status()}")
def publish(self, item): Logger.info(f"publishing prepared drink to balcony_topic: {item}") self.__producer.send(topic=self.__balcony_topic, value=item)
def attend(self, order): Logger.info( f"Attending user_id={order['userId']} message={order['message']}")
import configparser import os from src.library.logger.Logger import Logger if __name__ == "__main__": configuration = configparser.ConfigParser() configuration.read("./application.ini") environment: str = os.getenv("ENVIRONMENT", "DEV") Logger.info(f"Running with environment: {environment}") for key, value in configuration[environment].items(): if not os.getenv(key.upper(), None): os.environ[key.upper()] = str(value) from src.web.serverconfig.FlaskConfig import FlaskConfig # Must be here to initiate the env variables before initialize # all components FlaskConfig()()
def publish(self, order): Logger.info(f"publishing to drink_topic: {order['orderId']}") self.__producer.send(topic=self.__drink_topic, value=order)
def consumes(self, item): Logger.info(f"publishing prepared food to balcony_topic: {item}") self.__producer.send(topic=self.__balcony_topic, value=item)