def delete_review(id_article): if flask.request.data: parameters = json.body_to_dic(flask.request.data) if "id_user" in parameters: security.validateAdminRole(flask.request.headers.get("Authorization")) common_service.get_article(id_article) return json.dic_to_json(service.disable_review(id_article, parameters['id_user'])) user = security.isValidToken(flask.request.headers.get("Authorization")) common_service.get_article(id_article) common_service.get_order(flask.request.headers.get("Authorization"), id_article) result = service.disable_review(id_article, user['id']) return json.dic_to_json(result)
def getScore(userId): try: security.validateAdminRole( flask.request.headers.get("Authorization")) return json.dic_to_json(crud.getScore(userId)) except Exception as err: return errors.handleError(err)
def postPaymentsFailed(paymentId): """ payment-failed : @api {fanout} payments/payments-failed Payment Failed @apiGroup RabbitMQ POST @apiDescription Postea eventos sobre pagos fallidos @apiExample {json} Mensaje { "type": "payment-failed", "exchange" : "{payments-failed}" "queue" : "" "message" : { "paymentId": "{paymentId}", } """ try: connection = pika.BlockingConnection( pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='payments-failed', exchange_type='fanout') message = {"paymentId": paymentId} channel.basic_publish(exchange='payments-failed', routing_key='', body=json.dic_to_json(message)) connection.close() except Exception: print("Error enviando payments-failed")
def handleUnknown(err): """ Cualquier otro error. err: Exception result json error a enviar al cliente """ return json.dic_to_json({"error": "Unknown error"}), 500
def handleMultipleArgumentException(err): """ Multiples argumentos con errores. err: MultipleArgumentException result json error a enviar al cliente """ return json.dic_to_json({"messages": [{"path": k, "message": v} for k, v in err.errors.items()]}), 400
def handleInvalidRequest(err): """ Request con errores. err: InvalidRequest result json error a enviar al cliente """ return json.dic_to_json({"error": err.error}), 400
def handleInvalidAccessLevel(err): """ Usuario no autorizado. err: InvalidAuth result json error a enviar al cliente """ return json.dic_to_json({"error": "Insufficient access level"}), 401
def postPayments(paymentId): """ payment-complete : @api {fanout} payments/payment-complete Payment Complete @apiGroup RabbitMQ POST @apiDescription Postea eventos sobre pagos a ordenes completos con exito @apiExample {json} Mensaje { "type": "payment-complete", "exchange" : "{payments}" "queue" : "" "message" : { "paymentId": "{paymentId}", } """ try: connection = pika.BlockingConnection( pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='payments', exchange_type='fanout') message = {"paymentId": paymentId} channel.basic_publish(exchange='payments', routing_key='', body=json.dic_to_json(message)) connection.close() except Exception: print("Error posteando payment completado")
def send_is_article_valid(exchange, queue, type, price): connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url()) ) channel = connection.channel() channel.exchange_declare(exchange=exchange, exchange_type='fanout') channel.queue_declare(queue = queue) article = {} article["articleId"] = price["article_id"] article["referenceId"] = price["_id"] message = { "exchange": exchange, "queue": queue, "type": type, "message": article } channel.basic_publish( exchange=exchange, routing_key=queue, body=json_serializer.dic_to_json(message) ) print("RabbitMQ Catalog GET article-exist catalogId: {}, articleId: {}".format(article["referenceId"], article["articleId"])) connection.close()
def handleInvalidArgument(err): """ Argumento con errores. err: InvalidArgument result json error a enviar al cliente """ return json.dic_to_json({"path": err.path, "message": err.error}), 400
def getPayment(paymentId): try: token = flask.request.headers.get("Authorization") user = security.isValidToken(token) return json.dic_to_json(payments_crud.getPayment(paymentId)) except Exception as err: return errors.handleError(err)
def handleUnauthorized(err): """ Usuario no autorizado. err: InvalidAuth result json error a enviar al cliente """ return json.dic_to_json({"error": "Unauthorized"}), 401
def delete_score(id_article): user = security.isValidToken( flask.request.headers.get("Authorization")) common_service.get_article(id_article) common_service.get_order(flask.request.headers.get("Authorization"), id_article) result = service.disable_score(id_article, user['id']) return json.dic_to_json(result)
def create_review(id_article): user = security.isValidToken(flask.request.headers.get("Authorization")) parameters = json.body_to_dic(flask.request.data) parameters.update({'id_article': id_article}) parameters = rest_validator.validateAddorEditReview(parameters) common_service.get_article(id_article) common_service.get_order(flask.request.headers.get("Authorization"), id_article) result = service.add_review(parameters, user["id"]) return json.dic_to_json(result)
def deleteLevel(levelId): try: security.validateAdminRole( flask.request.headers.get("Authorization")) result = crud.deleteLevel(levelId) return json.dic_to_json(result) except Exception as err: return errors.handleError(err)
def get_discounts_by_article_id(article_id): try: offset = int(flask.request.args.get( 'offset')) if flask.request.args.get('offset') else MAX_OFFSET page = int(flask.request.args.get( 'page')) if flask.request.args.get('page') else PAGE return json.dic_to_json( crud.get_discounts_by_article_id(article_id, offset, page)) except Exception as err: return errors.handleError(err)
def modifyLevel(levelId): try: security.validateAdminRole( flask.request.headers.get("Authorization")) params = json.body_to_dic(flask.request.data) result = crud.modifyLevel(levelId, params) return json.dic_to_json(result) except Exception as err: return errors.handleError(err)
def sendArticleData(exchange, queue, referenceId, articleId, valid, stock, price): """ Envía eventos al Cart article-data : Es una validación solicitada por Cart para validar si el articulo puede incluirse en el cart @api {direct} cart/article-data Validación de Articulos @apiGroup RabbitMQ POST @apiDescription Enviá de mensajes article-exist desde cart. Valida articulos @apiSuccessExample {json} Mensaje { "type": "article-exist", "message" : { "referenceId": "{referenceId}", "articleId": "{articleId}", "valid": True|False, "stock": {stock}, "price": {price} } } """ connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.exchange_declare(exchange=exchange, exchange_type='direct') channel.queue_declare(queue=queue) message = { "type": "article-data", "message": { "referenceId": referenceId, "articleId": articleId, "valid": valid, "stock": stock, "price": price, } } channel.basic_publish(exchange=exchange, routing_key=queue, body=json.dic_to_json(message)) connection.close() print( "RabbitMQ Cart POST article-data catalogId:%r , articleId:%r , valid:%r", referenceId, articleId, valid)
def cancelPayment(paymentId): try: security.isValidToken(flask.request.headers.get("Authorization")) params = json.body_to_dic(flask.request.data) params = restValidator.validateCancelPaymentParams(params) params['status'] = 'cancelled' # aca hago el crud yo pero tendria que hacerse cuando llegue la notificacion de mp # llamo a mp y cancelo updated_payment = payments_crud.addStatus(paymentId, params) res = payments_crud.updatePayment(paymentId, updated_payment) return json.dic_to_json(res) except Exception as err: return errors.handleError(err)
def updateArticle(articleId): try: security.validateAdminRole(flask.request.headers.get("Authorization")) params = json.body_to_dic(flask.request.data) params = restValidator.validateEditArticleParams(articleId, params) result = crud.updateArticle(articleId, params) return json.dic_to_json(result) except Exception as err: return errors.handleError(err)
def add_discount(): try: security.validateAdminRole( flask.request.headers.get("Authorization")) token = flask.request.headers.get("Authorization") params = json.body_to_dic(flask.request.data) validated_discount = restValidator.validateAddDiscountParams( params) result = crud.add_discount(validated_discount) return json.dic_to_json(result) except Exception as err: return errors.handleError(err)
def get_article(id_article): conn = http.client.HTTPConnection( socket.gethostbyname(config.get_catalog_server_url()), config.get_catalog_server_port(), ) try: conn.request("GET", "/v1/articles/{}".format(id_article), {}) response = conn.getresponse() if response.status != 200 or (not json.body_to_dic( response.read().decode('utf-8'))['enabled']): raise errors.InvalidArgument('id_article', 'Invalido') return json.dic_to_json(response.read().decode('utf-8')) except Exception: raise Exception
def add_price(): try: security.validateAdminRole( flask.request.headers.get("Authorization")) token = flask.request.headers.get("Authorization") params = json.body_to_dic(flask.request.data) responses = [] for price in params: validated_price = restValidator.validateAddPriceParams(price) result = crud.add_price(validated_price) responses.append(result.copy()) return json.dic_to_json(responses) except Exception as err: return errors.handleError(err)
def addPayment(): try: # TODO Duda : Como sacar las busquedas order y user en otro lado? se puede hacer? token = flask.request.headers.get("Authorization") user = security.isValidToken(token) params = json.body_to_dic(flask.request.data) params = restValidator.validateAddPaymentParams(params) order = orders.getOrder(params['id_order'], token) # se comunica con un servicio externo result = payments_crud.addPayment(params, order, user) return json.dic_to_json(result) except Exception as err: return errors.handleError(err)
def sendLevelNotice(userId, levelId): print("entra a rabbit_service") """ Envía notificacion a Auth (User si existise) para informar que hay un cambio en el nivel level-data : Es una notificación al perfil del usuario informando el estado de su puntaje y su estado actual @api {direct} rewards/level-data Informar Cambio de Nivel @apiGroup RabbitMQ POST @apiDescription Enviá de mensajes level-updated. Informa el Nivel del Usuario @apiSuccessExample {json} Mensaje { "type": "level-updated", "message" : { "userId": "{userId}", "levelId": "{levelId}" } } """ connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() exchange = "rewards" channel.exchange_declare(exchange="rewards", exchange_type='direct') result = channel.queue_declare('', exclusive=True) queue_name = result.method.queue queue = queue_name message = { "type": "level-updated", "message": { "userId": userId, "levelId": levelId } } channel.basic_publish(exchange=exchange, routing_key="level-update", body=json.dic_to_json(message)) connection.close() print("RabbitMQ Cart POST level-updated uderId:%r , levelId:%r ")
def send_new_score(id_article, score): """ Envía eventos cuando hay un nuevo score para un artículo @api {fanout} score/new_score Nuevo Score @apiGroup RabbitMQ POST @apiDescription Enviá mensajes de nuevo score @apiSuccessExample {json} Mensaje { "type": "new_score", "message" : { "id_article": "{id del articulo}", "score": {score promedio del articulo} } } """ exchange = "score" connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.exchange_declare(exchange=exchange, exchange_type='fanout') message = { "type": "new_score", "message": { "id_article": id_article, "score": score, } } validator.validateSchema(MSG_NEW_SCORE, message) channel.basic_publish(exchange=exchange, routing_key='', body=json.dic_to_json(message)) connection.close() print("RabbitMQ Cart POST new_score id_article:%r", id_article)
def postTransactions(message): """ Postea eventos de notificacion acerca de transacciones de pagos @api {fanout} transactions/transaction_task_queue Post New Transaction @apiGroup RabbitMQ POST @apiDescription Postea transacciones recibidas a procesar @apiExample {json} Mensaje { "type": "transaction", "exchange" : "{''}" "queue" : "" "message" : { "amount":{Float}, "id_payment":{String}, "status":{String}, "external_reference":{String} } """ QUEUE = "transaction_task_queue" try: connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.queue_declare(queue=QUEUE, durable=False) channel.basic_publish(exchange='', routing_key=QUEUE, body=json.dic_to_json(message), properties=pika.BasicProperties(delivery_mode=2)) connection.close() except Exception as err: print(err) print("Error enviando mensaje a " + QUEUE)
def send_new_discount(exchange, queue, type, discounts): connection = pika.BlockingConnection(pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.exchange_declare(exchange=exchange, exchange_type='fanout') channel.queue_declare(queue = queue) message = { "type": type, "message": discounts } channel.basic_publish( exchange=exchange, routing_key=queue, body=json_serializer.dic_to_json(message) ) connection.close()
def sendStats(): EXCHANGE = "stats" QUEUE = "stats" connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.exchange_declare(exchange=EXCHANGE, exchange_type='topic') channel.queue_declare(queue=QUEUE) channel.queue_bind(exchange=EXCHANGE, queue=QUEUE) message = service.sendRabbit() channel.basic_publish(exchange=EXCHANGE, routing_key=QUEUE, body=json.dic_to_json(message)) print("MENSAJE ENVIADO a la cola de stats") connection.close()
def send_msg_delete_article(articleId): """ Envía eventos a category """ """ Delete_article : Es un mensaje que avisa a category de la eliminación de un artículo. @api {direct} category/mensaje de eliminación de artículos @apiGroup RabbitMQ POST @apiDescription Enviá de mensajes Delete_article @apiSuccessExample {json} Mensaje { "type": "article-exist", "message" : { "articleId": "{articleId}", } """ connection = pika.BlockingConnection( pika.ConnectionParameters(host=config.get_rabbit_server_url())) channel = connection.channel() channel.exchange_declare(exchange='category', exchange_type='direct') channel.queue_declare(queue='category') message = { "type": "Delete_article", "message": { "articleId": articleId, } } channel.basic_publish(exchange='category', routing_key='category', body=json.dic_to_json(message)) print("RabbitMQ Category DELETE article , articleId:%r", articleId) connection.close()