def callback(ch, method, properties, body):
event = json_serializer.body_to_dic(body.decode('utf-8'))
if(len(validator.validateSchema(EVENT, event)) > 0):
return
if (event["type"] == "article-change"):
message = event["message"]
if(len(validator.validateSchema(MSG_ARTICLE_CHANGE, message)) > 0):
return
article_id = message['_id']
print("RabbitMQ Pricing POST article-change article_id: {}".format(article_id))
try:
price = {}
price['max_price'] = message['price']
price['min_price'] = message['price']
price['price'] = message['price']
price['price_currency'] = 'ARS'
price['article_id'] = article_id
price['state'] = ACTIVE
crud._addOrUpdatePrice(price)
except Exception:
print('Cannot handle article-change')
def isValidToken(authKey):
"""
Obtiene el currentUser desde el servicio de autentificación
authKey: string El header Authorization enviado por el cliente
return dict<property, value> CurrentUser
"""
if (not isinstance(authKey, str) or len(authKey) == 0):
raise errors.InvalidAuth()
headers = {"Authorization".encode("utf-8"): authKey.encode("utf-8")}
conn = http.client.HTTPConnection(
socket.gethostbyname(config.get_security_server_url()),
config.get_security_server_port(),
)
conn.request("GET", "/v1/users/current", {}, headers)
response = conn.getresponse()
if (response.status != 200):
raise errors.InvalidAuth()
result = json.body_to_dic(response.read().decode('utf-8'))
if (len(result) == 0):
raise errors.InvalidAuth()
return result
def callback(ch, method, properties, body):
event = json_serializer.body_to_dic(body.decode('utf-8'))
if(len(json_serializer.validateSchema(EVENT, event)) > 0):
return
if (event["type"] == "logout"):
security.invalidateSession(event["message"])
def callback(ch, method, properties, body):
event = json.body_to_dic(body.decode('utf-8'))
if len(validator.validateSchema(EVENT, event)) > 0:
return
if event["type"] == "logout":
security.invalidate_session(event["message"])
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 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 manageScore():
try:
security.validateAdminRole(
flask.request.headers.get("Authorization"))
params = json.body_to_dic(flask.request.data)
userId = params['userId']
result = crud.manageScore(userId, params)
return result
except Exception as err:
return errors.handleError(err)
def callback(ch, method, properties, body):
event = json.body_to_dic(body.decode('utf-8'))
if (len(validator.validateSchema(EVENT_CALLBACK, event)) > 0):
return
if (event["type"] == "article-exist"):
message = event["message"]
if (len(validator.validateSchema(MSG_ARTICLE_EXIST, message)) >
0):
return
exchange = event["exchange"]
queue = event["queue"]
referenceId = message["referenceId"]
articleId = message["articleId"]
print(
"RabbitMQ Catalog GET article-exist catalogId:%r , articleId:%r",
referenceId, articleId)
try:
articleValidation.validateArticleExist(articleId)
sendArticleValid(exchange, queue, referenceId, articleId,
True)
except Exception:
sendArticleValid(exchange, queue, referenceId, articleId,
False)
if (event["type"] == "article-data"):
message = event["message"]
if (len(validator.validateSchema(MSG_ARTICLE_EXIST, message)) >
0):
return
exchange = event["exchange"]
queue = event["queue"]
referenceId = message["referenceId"]
articleId = message["articleId"]
print(
"RabbitMQ Catalog GET article-data catalogId:%r , articleId:%r",
referenceId, articleId)
try:
article = crud.getArticle(articleId)
valid = ("enabled" in article and article["enabled"])
stock = article["stock"]
price = article["price"]
articleValidation.validateArticleExist(articleId)
sendArticleData(exchange, queue, referenceId, articleId,
valid, stock, price)
except Exception:
sendArticleData(exchange, queue, referenceId, articleId,
False, 0, 0)
def callback(ch, method, properties, body):
event = json.body_to_dic(body.decode('utf-8'))
if (len(validator.validateSchema(EVENT, event)) > 0):
return
if (event["type"] == "Delete_article"):
message = event["message"]
if (len(validator.validateSchema(MSG_DELETE_ARTICLE, message))
> 0):
return
articleId = message["articleId"]
results = db.category.find({"validation": True})
for r in results:
listArticle = r["articlesCategory"]
for element in listArticle:
if (element["_id"] == articleId):
listArticle.remove(element)
r["articlesCategory"] = listArticle
r["updated"] = datetime.datetime.utcnow()
db.category.replace_one(
{"_id": bson.ObjectId(r["_id"])}, r)
if (event["type"] == "Updated_article"):
message = event["message"]
if (len(validator.validateSchema(MSG_UPDATE_ARTICLE, message))
> 0):
return
articleId = message["articleId"]
new_element = {
"_id": message["articleId"],
"name": message["name"],
"description": message["description"],
"image": message["image"],
"price": message["price"],
"stock": message["stock"],
"updated": message["updated"],
"created": message["created"],
"enabled": message["enabled"]
}
results = db.category.find({"validation": True})
for r in results:
listArticle = r["articlesCategory"]
for element in listArticle:
if (element["_id"] == articleId):
n = listArticle.index(element)
listArticle.remove(element)
listArticle.insert(n, new_element)
r["articlesCategory"] = listArticle
r["updated"] = datetime.datetime.utcnow()
db.category.replace_one(
{"_id": bson.ObjectId(r["_id"])}, r)
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 updateValuePoint():
try:
security.validateAdminRole(
flask.request.headers.get("Authorization"))
params = json.body_to_dic(flask.request.data)
result = crud.updateValuePoint(params)
return result
except Exception as err:
return errors.handleError(err)
def notificationMercadoPago():
'''
Metodo para recibir notificaciones acerca de creaciones de pagos
'''
try:
# validar que la request sea de mercadopago
# TODO : Validar lo que entra por este endpoint
params = json.body_to_dic(flask.request.data)
#creo el evento de rabbit y lo mando
rabbit_service.postTransactions(params)
return flask.Response(status=200)
except Exception as err:
return errors.handleError(err)
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 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 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 callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body))
event = json.body_to_dic(body.decode('utf-8'))
"""if(len(validator.validateSchema(EVENT_CALLBACK, event)) > 0):
return
"""
if (event["type"] == "order-payed"):
message = event["message"]
exchange = event["exchange"]
queue = event["queue"]
orderId = message["orderId"]
userId = message["userId"]
amount = message["amount"]
print("RabbitMQ order-placed orderId:", orderId, "userId: ",
userId, " amount= $", amount)
crud.updateScore(userId, amount)
print("Score Updated Succesfully")
def get_specific_order(token, id_order, id_article):
headers = {"Authorization".encode("utf-8"): token.encode("utf-8")}
conn = http.client.HTTPConnection(
socket.gethostbyname(config.get_order_server_url()),
config.get_order_server_port())
try:
conn.request("GET", "/v1/orders/{}".format(id_order), {}, headers)
response = conn.getresponse()
if response.status != 200:
raise errors.InvalidRequest('No existe una orden con ese id')
else:
order = json.body_to_dic(response.read().decode('utf-8'))
for article in order['articles']:
if article['id'] == id_article:
return order
return ""
except Exception:
raise Exception
def callback(ch, method, properties, body):
event = json_serializer.body_to_dic(body.decode('utf-8'))
if(len(validator.validateSchema(EVENT, event)) > 0):
return
if (event["type"] == "article-exist"):
message = event.get('message')
if(len(validator.validateSchema(MSG_ARTICLE_EXIST, message)) > 0):
return
article_id = message.get('articleId')
print("RabbitMQ Catalog POST article-exist article_id: {}".format(article_id))
try:
if not message['valid']:
crud.del_price(article_id)
except Exception:
print('Cannot handle article-exist')
def get_article(articleId, authKey):
if (not isinstance(authKey, str) or len(authKey) == 0):
raise errors.InvalidAuth()
headers = {"Authorization".encode("utf-8"): authKey.encode("utf-8")}
conn = http.client.HTTPConnection(
socket.gethostbyname(config.get_connection_catalog_server_url()),
config.get_connection_catalog_server_port(),
)
conn.request('GET',"/v1/articles/" + articleId, {}, headers)
response = conn.getresponse()
if (response.status != 200):
raise errors.InvalidAuth()
result = json.body_to_dic(response.read().decode('utf-8'))
if (len(result) == 0):
raise errors.InvalidAuth()
return result
def get_order(token, id_article):
conn = http.client.HTTPConnection(
socket.gethostbyname(config.get_order_server_url()),
config.get_order_server_port())
try:
headers = {"Authorization".encode("utf-8"): token.encode("utf-8")}
conn.request("GET", "/v1/orders", {}, headers)
response = conn.getresponse()
except Exception:
raise Exception
if response.status == 200:
for obj in json.body_to_dic(response.read().decode('utf-8')):
if obj['status'] == 'PAYMENT_DEFINED':
order = get_specific_order(token, obj['id'], id_article)
if order != "":
return order
raise errors.InvalidRequest(
'No existen ordenes pagadas para este articulo')
else:
raise errors.InvalidRequest("Invalid Request")
def getOrder(orderId, authKey):
"""
Obtiene el order desde el servicio orders
orderId: string id de order enviado por el cliente
authKey: string El header Authorization enviado por el cliente
return dict<property, value> Order
"""
headers = {"Authorization".encode("utf-8"): authKey.encode("utf-8")}
conn = http.client.HTTPConnection(
socket.gethostbyname(config.get_orders_server_url()),
config.get_orders_server_port(),
)
conn.request("GET", "/v1/orders/"+orderId,{}, headers)
response = conn.getresponse()
if (response.status != 200):
raise errors.InvalidAuth()
result = json.body_to_dic(response.read().decode('utf-8'))
if result == None:
raise errors.InvalidArgument('orderId', 'No order with that id')
# for res in result:
# if orderId == res['id']:
return result
def callback(ch, method, properties, body):
params = json.body_to_dic(body.decode('utf-8'))
transactions_service.process_transaction(params)
ch.basic_ack(delivery_tag=method.delivery_tag)
def callback(ch, method, properties, body):
event = json.body_to_dic(body.decode('utf-8'))
resp = service.saveOrders(event) ## Se recibe una orden y se calcula la estadistica y se guarda los articulos en la base de datos.
statsService.sendStats()## Se envia a la cola de rabbit , luego de que se haya calculado la estadistica al recibir una orden.
def callback(ch, method, properties, body):
event = json.body_to_dic(body.decode('utf-8'))
print("Payment Failed!")
print(event)
