def update_product(self, _req):
try:
product_id = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
rsp = send_message('read-model', 'get_entity', {
'name': 'product',
'id': product_id
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
product = rsp['result']
if not product:
return {"error": "could not find product"}
# set new props
product['entity_id'] = product_id
try:
product['name'] = _req['name']
product['price'] = _req['price']
except KeyError:
return {
"result": "missing mandatory parameter 'name' and/or 'price"
}
# trigger event
self.event_store.publish('product',
create_event('entity_updated', product))
return {"result": True}
def create_carts(self, _req):
carts = _req if isinstance(_req, list) else [_req]
cart_ids = []
for cart in carts:
res, product_id = self._check_inventory(cart['product_ids'])
if not res:
return {
'error': 'product {} is out of stock'.format(product_id)
}
try:
new_cart = CartService._create_entity(cart['customer_id'],
cart['product_ids'])
except KeyError:
return {
"error":
"missing mandatory parameter 'customer_id' and/or 'product_ids'"
}
# trigger event
self.event_store.publish('cart',
create_event('entity_created', new_cart))
cart_ids.append(new_cart['entity_id'])
return {"result": cart_ids}
def delete_billing(self, _req):
try:
billing_id = _req['entity_id']
except KeyError:
return {
"error": "missing mandatory parameter 'entity_id'"
}
rsp = send_message('read-model', 'get_entitiy', {'name': 'billing', 'id': billing_id})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
billing = rsp['result']
if not billing:
return {
"error": "could not find billing"
}
# trigger event
self.event_store.publish('billing', create_event('entity_deleted', billing))
return {
"result": True
}
def update_shipping(self, _req):
try:
shipping_id = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
rsp = send_message('read-model', 'get_entity', {
'name': 'shipping',
'id': shipping_id
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
shipping = rsp['result']
if not shipping:
return {"error": "could not find shipping"}
# set new props
shipping['entity_id'] = shipping_id
try:
shipping['order_id'] = _req['order_id']
shipping['delivered'] = _req['delivered']
except KeyError:
return {
"result":
"missing mandatory parameter 'order_id' and/or 'delivered"
}
# trigger event
self.event_store.publish('shipping',
create_event('entity_updated', shipping))
return {"result": True}
def create_billings(self, _req):
billings = _req if isinstance(_req, list) else [_req]
billing_ids = []
for billing in billings:
res = self._check_amount(billing)
if not res:
return {
'error': 'amount is not accurate'
}
try:
new_billing = BillingService._create_entity(billing['order_id'], billing['amount'])
except KeyError:
return {
"error": "missing mandatory parameter 'order_id' and/or 'amount'"
}
# trigger event
self.event_store.publish('billing', create_event('entity_created', new_billing))
billing_ids.append(new_billing['entity_id'])
return {
"result": billing_ids
}
def update_inventory(self, _req):
try:
inventory_id = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
rsp = send_message('read-model', 'get_entity', {
'name': 'inventory',
'id': inventory_id
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
inventory = rsp['result']
if not inventory:
return {"error": "could not find inventory"}
# set new props
inventory['entity_id'] = inventory_id
try:
inventory['product_id'] = _req['product_id']
inventory['amount'] = _req['amount']
except KeyError:
return {
"result":
"missing mandatory parameter 'product_id' and/or 'amount"
}
# trigger event
self.event_store.publish('inventory',
create_event('entity_updated', inventory))
return {"result": True}
def _decr_inventory(self, _product_id, _value=1):
rsp = send_message('read-model', 'get_entity', {
'name': 'inventory',
'props': {
'product_id': _product_id
}
})
if 'error' in rsp:
raise Exception(rsp['error'] + ' (from read-model)')
inventory = rsp['result']
if not inventory:
logging.warning(
"could not find inventory for product {}".format(_product_id))
return False
if int(inventory['amount']) - (_value if _value else 1) < 0:
logging.info("product {} is out of stock".format(_product_id))
return False
inventory['amount'] = int(
inventory['amount']) - (_value if _value else 1)
# trigger event
self.event_store.publish('inventory',
create_event('entity_updated', inventory))
return True
def update_order(self, _req):
try:
order_id = _req['entity_id']
except KeyError:
return {
"error": "missing mandatory parameter 'entity_id'"
}
rsp = send_message('read-model', 'get_entity', {'name': 'order', 'id': order_id})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
order = rsp['result']
if not order:
return {
"error": "could not find order"
}
# set new props
order['entity_id'] = order_id
try:
order['cart_id'] = _req['cart_id']
order['status'] = _req['status']
except KeyError:
return {
"result": "missing mandatory parameter 'cart_id' and/or 'status"
}
# trigger event
self.event_store.publish('order', create_event('entity_updated', order))
return {
"result": True
}
def billing_created(self, _item):
if _item.event_action != 'entity_created':
return
billing = json.loads(_item.event_data)
shipping = ShippingService._create_entity(billing['order_id'])
self.event_store.publish('shipping',
create_event('entity_created', shipping))
def send(self, _req):
if not _req['to'] or not _req['msg']:
return {"error": "missing mandatory parameter 'to' and/or 'msg'"}
# trigger event
self.event_store.publish(
'mail',
create_event('mail_sent', {
"recipient": _req['to'],
"message": _req['msg']
}))
def shipping_updated(self, _item):
if _item.event_action != 'entity_updated':
return
shipping = json.loads(_item.event_data)
if not shipping['delivered']:
return
rsp = send_message('read-model', 'get_entity', {'name': 'order', 'id': shipping['order_id']})
order = rsp['result']
order['status'] = 'DELIVERED'
self.event_store.publish('order', create_event('entity_updated', order))
def billing_deleted(self, _item):
if _item.event_action != 'entity_delted':
return
billing = json.loads(_item.event_data)
rsp = send_message('read-model', 'get_entity', {'name': 'order', 'id': billing['order_id']})
order = rsp['result']
if not order['status'] == 'CLEARED':
return
order['status'] = 'UNCLEARED'
self.event_store.publish('order', create_event('entity_updated', order))
def update_cart(self, _req):
try:
cart_id = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
rsp = send_message('read-model', 'get_entity', {
'name': 'order',
'props': {
'cart_id': cart_id
}
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
order = rsp['result']
if order and not order['status'] == 'CREATED':
return {"error": "order {} in progress".format(order['entity_id'])}
rsp = send_message('read-model', 'get_entity', {
'name': 'cart',
'id': cart_id
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
cart = rsp['result']
if not cart:
return {"error": "could not find cart {}".format(cart_id)}
# set new props
cart['entity_id'] = cart_id
try:
cart['customer_id'] = _req['customer_id']
cart['product_ids'] = _req['product_ids']
except KeyError:
return {
"result":
"missing mandatory parameter 'customer_id' and/or 'product_ids"
}
res, product_id = self._check_inventory(cart['product_ids'])
if not res:
return {'error': 'product {} is out of stock'.format(product_id)}
# trigger event
self.event_store.publish('cart', create_event('entity_updated', cart))
return {"result": True}
def order_created(self, _item):
if _item.event_action != 'entity_created':
return
order = json.loads(_item.event_data)
rsp = send_message('read-model', 'get_entity', {
'name': 'cart',
'id': order['cart_id']
})
cart = rsp['result']
result = self._decr_from_cart(cart)
order['status'] = 'IN_STOCK' if result else 'OUT_OF_STOCK'
self.event_store.publish('order', create_event('entity_updated',
order))
def update_customer(self, _req):
try:
customer = CustomerService._create_entity(_req['name'],
_req['email'])
except KeyError:
return {
"error": "missing mandatory parameter 'name' and/or 'email'"
}
try:
customer['entity_id'] = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
# trigger event
self.event_store.publish('customer',
create_event('entity_updated', customer))
return {"result": True}
def create_orders(self, _req):
orders = _req if isinstance(_req, list) else [_req]
order_ids = []
for order in orders:
try:
new_order = OrderService._create_entity(order['cart_id'])
except KeyError:
return {
"error": "missing mandatory parameter 'cart_id'"
}
# trigger event
self.event_store.publish('order', create_event('entity_created', new_order))
order_ids.append(new_order['entity_id'])
return {
"result": order_ids
}
def update_billing(self, _req):
try:
billing_id = _req['entity_id']
except KeyError:
return {
"error": "missing mandatory parameter 'entity_id'"
}
rsp = send_message('read-model', 'get_entitiy', {'name': 'billing', 'id': billing_id})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
billing = rsp['result']
if not billing:
return {
"error": "could not find billing"
}
# set new props
billing['entity_id'] = billing_id
try:
billing['order_id'] = _req['order_id']
billing['amount'] = _req['amount']
except KeyError:
return {
"result": "missing mandatory parameter 'order_id' and/or 'amount"
}
res = self._check_amount(billing)
if not res:
return {
'error': 'amount is not accurate'
}
# trigger event
self.event_store.publish('billing', create_event('entity_updated', billing))
return {
"result": True
}
def create_customers(self, _req):
customers = _req if isinstance(_req, list) else [_req]
customer_ids = []
for customer in customers:
try:
new_customer = CustomerService._create_entity(
customer['name'], customer['email'])
except KeyError:
return {
"error":
"missing mandatory parameter 'name' and/or 'email'"
}
# trigger event
self.event_store.publish(
'customer', create_event('entity_created', new_customer))
customer_ids.append(new_customer['entity_id'])
return {"result": customer_ids}
def create_inventories(self, _req):
inventory = _req if isinstance(_req, list) else [_req]
inventory_ids = []
for inventory in inventory:
try:
new_inventory = InventoryService._create_entity(
inventory['product_id'], inventory['amount'])
except KeyError:
return {
"error":
"missing mandatory parameter 'product_id' and/or 'amount'"
}
# trigger event
self.event_store.publish(
'inventory', create_event('entity_created', new_inventory))
inventory_ids.append(new_inventory['entity_id'])
return {"result": inventory_ids}
def create_shippings(self, _req):
shippings = _req if isinstance(_req, list) else [_req]
shipping_ids = []
for shipping in shippings:
try:
new_shipping = ShippingService._create_entity(
shipping['order_id'])
except KeyError:
return {
"error":
"missing mandatory parameter 'order_id' and/or 'delivered'"
}
# trigger event
self.event_store.publish(
'shipping', create_event('entity_created', new_shipping))
shipping_ids.append(new_shipping['entity_id'])
return {"result": shipping_ids}
def create_products(self, _req):
products = _req if isinstance(_req, list) else [_req]
product_ids = []
for product in products:
try:
new_product = ProductService._create_entity(
product['name'], product['price'])
except KeyError:
return {
"error":
"missing mandatory parameter 'name' and/or 'price'"
}
# trigger event
self.event_store.publish(
'product', create_event('entity_created', new_product))
product_ids.append(new_product['entity_id'])
return {"result": product_ids}
def delete_cart(self, _req):
try:
cart_id = _req['entity_id']
except KeyError:
return {"error": "missing mandatory parameter 'entity_id'"}
rsp = send_message('read-model', 'get_entity', {
'name': 'cart',
'id': cart_id
})
if 'error' in rsp:
rsp['error'] += ' (from read-model)'
return rsp
cart = rsp['result']
if not cart:
return {"error": "could not find cart"}
# trigger event
self.event_store.publish('cart', create_event('entity_deleted', cart))
return {"result": True}
def _decr_from_cart(self, _cart):
try:
product_ids = _cart['product_ids']
except KeyError:
raise Exception("missing mandatory parameter 'product_ids'")
rsp = send_message('read-model', 'get_entities', {
'name': 'inventory',
'props': {
'product_id': product_ids
}
})
if 'error' in rsp:
raise Exception(rsp['error'] + ' (from read-model)')
inventories = rsp['result']
# count products
product_counts = []
for inventory in inventories:
found = product_ids.count(inventory['product_id'])
# check amount
if found > int(inventory['amount']):
logging.info("product {} is out of stock".format(
inventory['product_id']))
return False
product_counts.append((inventory, found))
# decrement inventory
for inventory, count in product_counts:
inventory['amount'] = int(inventory['amount']) - count
# trigger event
self.event_store.publish('inventory',
create_event('entity_updated', inventory))
return True
