class OrderRefundSqsHandler(SqsHandlerInterface): def __init__(self) -> None: self.__messages_storage = MessageStorageImplementation() self.__order_storage = OrderStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__product_storage = ProductStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : SQS Message #{} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start - {}'.format(sqs_message.message_data)) order_number = Order.Number(sqs_message.message_data['order_number']) simple_sku = SimpleSku(sqs_message.message_data['simple_sku']) qty = Qty(sqs_message.message_data['qty']) __log_flow('Order Updating...') order = self.__order_storage.load(order_number) order.refund(simple_sku, qty) __log_flow('Order Updated!') __log_flow('Order Saving...') self.__order_storage.save(order) __log_flow('Order Saved!') __log_flow('Order SQS Sending...') self.__sqs_sender.send(OrderChangeSqsSenderEvent(order)) __log_flow('Order SQS Sent!') # add message (silently) try: __log_flow('Notification popup: Adding...') customer = self.__customer_storage.get_by_id(order.customer_id) product = self.__product_storage.load(simple_sku) message = Message( str(uuid.uuid4()), customer.email.value, 'Refund for Order #{}'.format(order.number.value), '"{}" has been Refunded in Qty {} for Order #{}'.format( product.name.value, qty.value, order.number.value ), ) self.__messages_storage.save(message) __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('End')
class WebhooksFlowLog(object): def __init__(self, flow_id: str): if not isinstance(flow_id, str): raise ArgumentTypeException(self.__init__, 'flow_id', flow_id) elif not flow_id.strip(): raise ArgumentCannotBeEmptyException(self.__init__, 'flow_id') self.__flow_id = flow_id self.__logger = Logger() def write(self, message: str) -> None: self.__logger.log_simple('Peach Payment Webhooks Log #{}: {}'.format( self.__flow_id, message))
class _SqsSenderSqs(SqsSenderInterface): def __init__(self): self.__sqs_client = boto3.client('sqs') self.__logger = Logger() def send_batch(self, events: List[SqsSenderEventInterface]) -> None: # Group by event_type grouped = dict() for event in events: if not grouped.get(event.event_type): grouped[event.event_type] = list() grouped[event.event_type].append(event.event_data) CHUNK_SIZE = settings.CALCULATE_SCORE_CHUNK_SIZE for event_type, event_data in grouped.items(): events_map = settings.SQS_SENDER_CONFIG.get('params').get('events') queue_data = events_map.get(event_type) or None if not queue_data: raise ArgumentValueException( '{} does not know, how to send event!'.format( self.send_batch.__qualname__)) queue_url = queue_data.get('queue_url') # queue = boto3.resource('sqs').get_queue_by_name(QueueName=queue_url.split('/')[-1]) for idx in range(0, len(event_data), CHUNK_SIZE): batch = event_data[idx:idx + CHUNK_SIZE] def __log_flow(msg: str, event_type: str = event_type, data: list = batch): self.__logger.log_simple( '{} : Sending SQS "{}" : {} : {}'.format( self.__class__.__qualname__, event_type, data, msg)) __log_flow('Start') __log_flow('SQS Point: {} -> {}'.format(event_type, queue_url)) send_method = self.__send_fifo if str( queue_url)[-5:] == '.fifo' else self.__send_standard send_method(queue_url, event_type, batch, __log_flow) __log_flow('End') def send(self, event: SqsSenderEventInterface) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : Sending SQS "{}" : {} : {}'.format( self.__class__.__qualname__, event.event_type, event.event_data, text)) __log_flow('Start') events_map = settings.SQS_SENDER_CONFIG.get('params').get('events') queue_data = events_map.get(event.event_type) or None if not queue_data: raise ArgumentValueException( '{} does not know, how to send "{}" event!'.format( self.send.__qualname__, event.event_type)) queue_url = queue_data.get('queue_url') object_type = queue_data.get('object_type') send_method = self.__send_fifo if str( queue_url)[-5:] == '.fifo' else self.__send_standard __log_flow('SQS Point: {} -> {}'.format(object_type, queue_url)) send_method(queue_url, object_type, event.event_data, __log_flow) __log_flow('End') def __send_standard(self, queue_url: str, object_type: str, data: dict, __log_flow): __log_flow('Standard - Start') response = self.__sqs_client.send_message(QueueUrl=queue_url, MessageBody=json.dumps(data), DelaySeconds=45, MessageAttributes={ 'object_type': { 'StringValue': object_type, 'DataType': 'String', } }) __log_flow('Standard - End: {}'.format(response)) def __send_fifo(self, queue_url: str, object_type: str, data: dict, __log_flow): __log_flow('Fifo - Start') response = self.__sqs_client.send_message( QueueUrl=queue_url, MessageGroupId=object_type, MessageDeduplicationId=hashlib.md5( (object_type + json.dumps(data) + datetime.datetime.now().strftime('%Y%m%d%H%M%S') ).encode('utf-8')).hexdigest(), MessageBody=json.dumps(data), MessageAttributes={ 'object_type': { 'StringValue': object_type, 'DataType': 'String', } }) __log_flow('Fifo - End: {}'.format(response))
class RegularEftPaymentSqsHandler(SqsHandlerInterface): def __init__(self): # Need to be imported here, because orders storage depends from payment method class in this file. from chalicelib.libs.purchase.order.storage import OrderStorageImplementation from chalicelib.libs.purchase.product.storage import ProductStorageImplementation self.__order_storage = OrderStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() self.__message_storage = MessageStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__products_storage = ProductStorageImplementation() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : SQS Message #{} : {}'.format( self.__class__.__qualname__, sqs_message.id, text)) __log_flow('Start') if sqs_message.message_type != 'regular_eft_proof_check_result': raise ValueError( '{} does not know how to handle {} sqs message! Message data: {}' .format(self.__class__.__qualname__, sqs_message.message_type, sqs_message.message_data)) order_number_value = sqs_message.message_data.get('order_number') is_proof_accepted = sqs_message.message_data.get('is_proof_accepted') __log_flow('Order #{} - Payment - {}'.format( order_number_value, 'Accepted' if is_proof_accepted else 'Declined')) __log_flow('Updating...') order_number = Order.Number(order_number_value) order = self.__order_storage.load(order_number) if not order: raise ValueError( 'Unable to handle {} sqs-message #{}: order does not exist. Message data: {}' .format(sqs_message.message_type, sqs_message.id, sqs_message.message_data)) if not isinstance(order.payment_method, RegularEftOrderPaymentMethod): raise ValueError( 'Order #{} is not a Regular EFT payment order!'.format( order.number.value)) if is_proof_accepted: # accept order payment __log_flow('Order Updating...') order.status = Order.Status(Order.Status.PAYMENT_RECEIVED) self.__order_storage.save(order) __log_flow('Order Updated!') else: # Attention! # Order must be closed first to avoid multiple "restore-qty" actions! # @todo : refactoring ? # close order __log_flow('Order Closing...') order.status = Order.Status(Order.Status.CLOSED) self.__order_storage.save(order) __log_flow('Order Closed!') # restore products qty __log_flow('Product Qty Restoring - Start') for order_item in order.items: if order_item.qty_processable.value == 0: __log_flow( 'Product Qty Restoring: {} skipped because of 0 qty'. format(order_item.simple_sku.value)) continue try: __log_flow('Product Qty Restoring {} / {} ...'.format( order_item.simple_sku.value, order_item.qty_processable.value)) product = self.__products_storage.load( order_item.simple_sku) product.restore_qty(order_item.qty_processable) self.__products_storage.update(product) __log_flow('Product Qty Restored {} / {}!'.format( order_item.simple_sku.value, order_item.qty_processable.value)) except BaseException as e: self.__logger.log_exception(e) __log_flow( 'Product Qty NOT Restored {} / {} because of Error: '. format(order_item.simple_sku.value, order_item.qty_processable.value, str(e))) __log_flow('Product Qty Restoring - End') __log_flow('Updated!') # send to portal __log_flow('Order SQS: Sending...') self.__sqs_sender.send(OrderChangeSqsSenderEvent(order)) __log_flow('Order SQS: Sent!') # silently add notification (silently) try: __log_flow('Notification popup: Adding...') customer = self.__customer_storage.get_by_id(order.customer_id) if not customer: raise ValueError( '{} cant notify customer #{} about Regular-EFT payment updates for Order #{}' .format(self.handle.__qualname__, order.customer_id.value, order.number.value)) self.__message_storage.save( Message( str(uuid.uuid4()), customer.email.value, 'Regular EFT Payment has been checked!', 'Regular EFT Payment for Order #{} has been checked and {}!' .format(order.number.value, 'Accepted' if is_proof_accepted else 'Declined'))) __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow( 'Notification popup: Not Added because of Error : {}'.format( str(e))) __log_flow('End')
class OrderChangeSqsHandler(SqsHandlerInterface): def __init__(self): self.__messages_storage = MessageStorageImplementation() self.__order_storage = OrderStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : SQS Message #{} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start - {}'.format(sqs_message.message_data)) data = { 'order_number': sqs_message.message_data.get('order_number', '') or '', 'order_status_mpc': sqs_message.message_data.get('order_status_mpc', '') or '', 'popup_message': { 'customer_email': sqs_message.message_data.get('popup_message').get('customer_email'), 'message_title': sqs_message.message_data.get('popup_message').get('message_title'), 'message_text': sqs_message.message_data.get('popup_message').get('message_text'), } if sqs_message.message_data.get('popup_message', None) or None else None, } __log_flow('Order: Updating...') order_number = Order.Number(data.get('order_number')) order = self.__order_storage.load(order_number) if not order: raise ValueError('Order "{}" does not exist in the MPC!') mpc_order_status = str(data.get('order_status_mpc')) order.status = Order.Status(mpc_order_status) __log_flow('Order: Updated!') __log_flow('Order: Saving...') self.__order_storage.save(order) __log_flow('Order: Saved!') # Attention! # We need to send-back order changes because of compatibility reason. __log_flow('Order: SQS Sending-Back...') self.__sqs_sender.send(OrderChangeSqsSenderEvent(order)) __log_flow('Order: SQS Sent-Back!') # add message, if is needed (silently) try: message_data = data.get('popup_message') or None if message_data: __log_flow('Notification popup: Adding...') message = Message( str(uuid.uuid4()), message_data.get('customer_id'), message_data.get('message_title'), message_data.get('message_text'), ) self.__messages_storage.save(message) __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('End')
class OrderPaymentOhHoldHandler(SqsHandlerInterface): def __init__(self): self.__order_storage = OrderStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() self.__message_storage = MessageStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__products_storage = ProductStorageImplementation() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : SQS Message #{} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start : {}'.format(sqs_message.message_data)) if sqs_message.message_type != 'fixel_order_on_hold_by_portal': raise ValueError('{} does not know how to handle {} sqs message! Message data: {}'.format( self.__class__.__qualname__, sqs_message.message_type, sqs_message.message_data )) order_number_value = sqs_message.message_data.get('order_number') on_hold_status = sqs_message.message_data.get('status') order_number = Order.Number(order_number_value) order = self.__order_storage.load(order_number) if on_hold_status == Order.Status.CLOSED: self.__close_order_on_hold(order, __log_flow) else: self.__on_hold_not_closed_status(order, on_hold_status, __log_flow) self.__send_order_change_to_portal(order, __log_flow) self.__notify_about_order_status_change_silently(order, __log_flow) __log_flow('End') def __on_hold_not_closed_status(self, order: Order, on_hold_status: str, __log_flow) -> None: __log_flow('Order Updating...') order.status = Order.Status(on_hold_status) __log_flow('Order Updated!') __log_flow('Order Saving...') self.__order_storage.save(order) __log_flow('Order Saved!') def __close_order_on_hold(self, order: Order, __log_flow) -> None: __log_flow('Updating...') # close order __log_flow('Order Updating...') order.status = Order.Status(Order.Status.CLOSED) __log_flow('Order Updated!') # restore products qty __log_flow('Product Qty Updating - Start') products_to_save = [] for order_item in order.items: if order_item.qty_processable.value == 0: __log_flow('Product Qty Updating: {} skipped because of 0 qty'.format(order_item.simple_sku.value)) continue __log_flow('Product Qty Updating {} / {} ...'.format( order_item.simple_sku.value, order_item.qty_processable.value )) product = self.__products_storage.load(order_item.simple_sku) product.restore_qty(order_item.qty_processable) products_to_save.append(product) __log_flow('Product Qty Updated {} / {}!'.format( order_item.simple_sku.value, order_item.qty_processable.value )) __log_flow('Product Qty Updating - End') __log_flow('Updated!') __log_flow('Saving...') __log_flow('Order Saving...') self.__order_storage.save(order) __log_flow('Order Saved!') __log_flow('Products Saving...') for product in products_to_save: __log_flow('Product {} Saving...'.format(product.simple_sku.value)) self.__products_storage.update(product) __log_flow('Product {} Saved!'.format(product.simple_sku.value)) __log_flow('Products Saved!') __log_flow('Saved!') def __send_order_change_to_portal(self, order: Order, __log_flow) -> None: __log_flow('Order SQS: Sending...') self.__sqs_sender.send(OrderChangeSqsSenderEvent(order)) __log_flow('Order SQS: Sent!') def __notify_about_order_status_change_silently(self, order: Order, __log_flow) -> None: try: __log_flow('Notification popup: Adding...') customer = self.__customer_storage.get_by_id(order.customer_id) self.__message_storage.save(Message( str(uuid.uuid4()), customer.email.value, 'Order #{} status is changed!', 'Order #{} has been turned to "{}" status!'.format(order.number.value, order.status.label) )) __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e)))
class ReturnRequestChangeSqsHandler(SqsHandlerInterface): def __init__(self): self.__returns_storage = ReturnRequestStorageImplementation() self.__order_storage = OrderStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__product_storage = ProductStorageImplementation() self.__messages_storage = MessageStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : {} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start - {}'.format(sqs_message.message_data)) request_number = sqs_message.message_data.get('return_request_number') order_number = sqs_message.message_data.get('order_number') simple_sku = sqs_message.message_data.get('simple_sku') status = sqs_message.message_data.get('status') __log_flow('Updating...') return_request = self.__returns_storage.load(ReturnRequest.Number(request_number)) if not return_request: raise ValueError('{} can\'t handle SQS message {}:{}! Return Request does not exist!'.format( self.handle.__qualname__, sqs_message.message_type, sqs_message.message_data )) actions_map = { 'approved': self.__approve, 'cancelled': self.__decline, 'closed': self.__close, } action = actions_map.get(status) if not action: raise Exception('{} can\'t handle SQS message {}:{}! Status is unknown!'.format( self.handle.__qualname__, sqs_message.message_type, sqs_message.message_data )) action(return_request, OrderNumber(order_number), SimpleSku(simple_sku), __log_flow) __log_flow('Updated!') __log_flow('End') def __approve( self, return_request: ReturnRequest, order_number: OrderNumber, simple_sku: SimpleSku, __log_flow ) -> None: __log_flow('Approving...') return_request.make_item_approved(order_number, simple_sku) __log_flow('Return Request Saving...') self.__returns_storage.save(return_request) __log_flow('Return Request Saved!') try: __log_flow('Notification popup: Adding...') self.__add_notification_message(return_request, order_number, simple_sku, 'Approved') __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('Approved!') def __decline( self, return_request: ReturnRequest, order_number: OrderNumber, simple_sku: SimpleSku, __log_flow ) -> None: __log_flow('Declining...') qty = return_request.get_item_qty(order_number, simple_sku) order = self.__order_storage.load(order_number) # updating return_request.make_item_declined(order_number, simple_sku) order.decline_return(simple_sku, qty) # saving __log_flow('Declining: Return Request Saving...') self.__returns_storage.save(return_request) __log_flow('Declining: Return Request Saved!') __log_flow('Declining: Order Saving...') self.__order_storage.save(order) __log_flow('Declining: Order Saved!') # add notification silently try: __log_flow('Notification popup: Adding...') self.__add_notification_message(return_request, order_number, simple_sku, 'Declined') __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('Declined!') def __close( self, return_request: ReturnRequest, order_number: OrderNumber, simple_sku: SimpleSku, __log_flow ) -> None: __log_flow('Closing...') qty = return_request.get_item_qty(order_number, simple_sku) product = self.__product_storage.load(simple_sku) order = self.__order_storage.load(order_number) product.restore_qty(qty) order.close_return(simple_sku, qty) return_request.make_item_closed(order_number, simple_sku) # update product __log_flow('Closing: Product Qty: Restoring...') self.__product_storage.update(product) __log_flow('Closing: Product Qty: Restored!') # update order __log_flow('Closing: Order Qty: Returning...') self.__order_storage.save(order) __log_flow('Closing: Order Qty: Returned!') # update request __log_flow('Closing: Return Request: Updating...') self.__returns_storage.save(return_request) __log_flow('Closing: Return Request: Updated!') __log_flow('Closing: Order SQS: Sending...') self.__sqs_sender.send(OrderChangeSqsSenderEvent(order)) __log_flow('Closing: Order SQS: Sent!') # add notification silently try: __log_flow('Notification popup: Adding...') self.__add_notification_message(return_request, order_number, simple_sku, 'Closed') __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('Closed!') def __add_notification_message( self, return_request: ReturnRequest, order_number: OrderNumber, simple_sku: SimpleSku, status_label: str ) -> None: order = self.__order_storage.load(order_number) customer = self.__customer_storage.get_by_id(order.customer_id) product = self.__product_storage.load(simple_sku) message = Message( str(uuid.uuid4()), customer.email.value, 'Return Request #{} has been Updated!'.format(return_request.number.value), 'Return Request for Product "{}" for Order #{} has been {}!'.format( product.name.value, order_number.value, status_label ), ) self.__messages_storage.save(message)
def __handle_sqs_message(event): import json logger = Logger() for record in event: data = record.to_dict() object_type = data['messageAttributes']['object_type']['stringValue'] sqs_message_data = record.body if type( record.body) is dict else json.loads(record.body) sqs_message = SqsMessage(data['messageId'], object_type, sqs_message_data) logger.log_simple( 'SQS Event Handling - Handle message "{}" #{} - Start'.format( sqs_message.message_type, sqs_message.id)) handlers_map = { 'chalicelib.utils.sqs_handlers.product.ProductSqsHandler': ('mpc_assets_product_config', ), 'chalicelib.utils.sqs_handlers.static_page.StaticPageSqsHandler': ('static_page_publish', 'static_page_unpublish'), 'chalicelib.utils.sqs_handlers.sticker.StickerSqsHandler': ('product_sticker', 'product_sticker_delete'), 'chalicelib.utils.sqs_handlers.user_question.UserQuestionSqsHandler': ('user_question', ), 'chalicelib.utils.sqs_handlers.banner.BannerSqsHandler': ('mpc_banner', 'mpc_banner_delete'), 'chalicelib.utils.sqs_handlers.product_type.ProductTypeSqsHandler': ( 'mpc_assets_product_type', 'mpc_assets_product_type_delete', ), 'chalicelib.utils.sqs_handlers.category.CategorySqsHandler': ('mpc_assets_category_delete', ), 'chalicelib.utils.sqs_handlers.brand.BrandSqsHandler': ('mpc_assets_brands', 'mpc_assets_brands_delete'), 'chalicelib.utils.sqs_handlers.personalization.OrderHandler': ('personalization_order', ), # @todo : merge into products queue handler ??? 'chalicelib.utils.sqs_handlers.product.EventProductSqsHandler': ('event_products', ), 'chalicelib.utils.sqs_handlers.product.StockSqsHandler': ('stock_update', ), 'chalicelib.utils.sqs_handlers.product.SingleProductSqsHandler': ('single_product', 'image_update'), 'chalicelib.utils.sqs_handlers.scored_product.ScoredProductSqsHandler': (SCORED_PRODUCT_MESSAGE_TYPE.CALCULATE_FOR_A_CUSTOMER, SCORED_PRODUCT_MESSAGE_TYPE.SECRET_KEY), 'chalicelib.libs.purchase.order.sqs.OrderChangeSqsHandler': ('order_change', ), 'chalicelib.libs.purchase.order.sqs.OrderRefundSqsHandler': ('fixel_order_refund', ), 'chalicelib.libs.purchase.order.sqs.OrderPaymentOhHoldHandler': ('fixel_order_on_hold_by_portal', ), 'chalicelib.libs.purchase.payment_methods.regular_eft.sqs.RegularEftPaymentSqsHandler': ('regular_eft_proof_check_result', ), 'chalicelib.libs.purchase.cancellations.sqs.CancelRequestPaidOrderAnswerSqsHandler': ('fixel_paid_order_cancellation_request_answer', ), 'chalicelib.libs.purchase.cancellations.sqs.CancelledOrderOnPortalSideSqsHandle': ('fixel_order_cancellation_by_portal', ), 'chalicelib.libs.purchase.returns.sqs.ReturnRequestChangeSqsHandler': ('return_request_answer', ), 'chalicelib.libs.purchase.settings.PurchaseSettingsSqsHandler': ('dynamic_delivery_fees', 'parameters'), 'chalicelib.libs.purchase.customer.sqs.CustomerTiersTiersSqsHandler': ('customer_tiers_set', ), 'chalicelib.libs.purchase.customer.sqs.CustomerTiersCustomersSqsHandler': ('customer_tiers_customers', ), 'chalicelib.libs.purchase.customer.sqs.FbucksChargeSqsHandler': ('fbucks_charge', ), 'chalicelib.libs.purchase.customer.sqs.CrutchCustomerSpentAmountSqsHandler': ('customer_info_spent_amount', ), 'chalicelib.libs.purchase.customer.sqs.CrutchCustomerInfoRequestAnswerSqsHandler': ('customer_info_request_answer', ), 'chalicelib.libs.credit.sqs.UserCreditBalanceSqsHandler': ('user_credit_balance', ), 'chalicelib.libs.informations.sqs.InformationsSqsHandler': ('customer_info', ), } try: for class_name in handlers_map: if object_type in handlers_map[class_name]: sqs_handler: SqsHandlerInterface = create_object( class_name) sqs_handler.handle(sqs_message) logger.log_simple( 'SQS Event Handling - Handle message "{}" #{} - Done!'. format(sqs_message.message_type, sqs_message.id)) return else: raise ValueError('SQS Handler was not found!') except BaseException as e: app.log.exception('Error SQS "{}" {} - {}'.format( object_type, data, str(e))) logger.log_simple( 'SQS Event Handling - Handle message "{}" #{} - Error: {}!'. format(sqs_message.message_type, sqs_message.id, str(e)))
class FbucksChargeSqsHandler(SqsHandlerInterface): # @TODO : REFACTORING !!! currently we are working with raw data def __init__(self): self.__orders_storage = OrderStorageImplementation() self.__logger = Logger() # """ # curl -X DELETE localhost:9200/fbucks_handled_orders # curl -X PUT localhost:9200/fbucks_handled_orders -H "Content-Type: application/json" -d'{ # "mappings": { # "fbucks_handled_orders": { # "properties": { # "handled_at": {"type": "date", "format": "yyyy-MM-dd HH:mm:ss"} # } # } # } # }' # """ # self.__fbucks_handled_orders_elastic = Elastic( # settings.AWS_ELASTICSEARCH_FBUCKS_HANDLED_ORDERS, # settings.AWS_ELASTICSEARCH_FBUCKS_HANDLED_ORDERS, # ) self.__fbucks_handled_orders_dynamo_db = DynamoModel( settings.AWS_DYNAMODB_CMS_TABLE_NAME) self.__fbucks_handled_orders_dynamo_db.PARTITION_KEY = 'PURCHASE_FBUCKS_REWARD_HANDLED_ORDERS' # Attention! # We can get current customer's amount as a sum of all changes by customer_id # But theoretically elastic can not be in time with index update (1 second) between requests. # So there is another index to store amount value. """ curl -X DELETE localhost:9200/fbucks_customer_amount curl -X PUT localhost:9200/fbucks_customer_amount -H "Content-Type: application/json" -d'{ "mappings": { "fbucks_customer_amount": { "properties": { "amount": {"type": "integer"} } } } }' curl -X DELETE localhost:9200/fbucks_customer_amount_changes curl -X PUT localhost:9200/fbucks_customer_amount_changes -H "Content-Type: application/json" -d'{ "mappings": { "fbucks_customer_amount_changes": { "properties": { "customer_id": {"type": "keyword"}, "amount": {"type": "integer"}, "changed_at": {"type": "date", "format": "yyyy-MM-dd HH:mm:ss"}, "order_number": {"type": "keyword"} } } } }' """ self.__fbucks_customer_amount_elastic = Elastic( settings.AWS_ELASTICSEARCH_FBUCKS_CUSTOMER_AMOUNT, settings.AWS_ELASTICSEARCH_FBUCKS_CUSTOMER_AMOUNT, ) self.__fbucks_customer_amount_changes_elastic = Elastic( settings.AWS_ELASTICSEARCH_FBUCKS_CUSTOMER_AMOUNT_CHANGES, settings.AWS_ELASTICSEARCH_FBUCKS_CUSTOMER_AMOUNT_CHANGES, ) self.__customer_storage = CustomerStorageImplementation() self.__messages_storage = MessageStorageImplementation() def handle(self, sqs_message: SqsMessage) -> None: import uuid import datetime from chalicelib.libs.purchase.core import Order order_number_values = sqs_message.message_data['order_numbers'] for order_number_value in order_number_values: try: now_string = datetime.datetime.now().strftime( "%Y-%m-%d %H:%M:%S") # skip duplicates # if self.__fbucks_handled_orders_elastic.get_data(order_number_value): if self.__fbucks_handled_orders_dynamo_db.find_item( order_number_value): self.__logger.log_simple( '{}: Fbucks for order #{} already earned!'.format( self.handle.__qualname__, order_number_value)) continue # ignore orders without fbucks amounts order = self.__orders_storage.load( Order.Number(order_number_value)) fbucks_amount = order.total_fbucks_earnings.value if fbucks_amount == 0: # remember order as handled # self.__fbucks_handled_orders_elastic.create(order_number_value, {'handled_at': now_string}) self.__fbucks_handled_orders_dynamo_db.put_item( order_number_value, {'handled_at': now_string}) continue # earn fbucks self.__fbucks_customer_amount_elastic.update_data( order.customer_id.value, { 'script': 'ctx._source.amount += ' + str(fbucks_amount), 'upsert': { 'amount': fbucks_amount, } }) self.__fbucks_customer_amount_changes_elastic.create( str(uuid.uuid4()) + str(order.customer_id.value), { "customer_id": order.customer_id.value, "amount": +fbucks_amount, "changed_at": now_string, "order_number": order_number_value, }) # remember order as handled # self.__fbucks_handled_orders_elastic.create(order_number_value, {'handled_at': now_string}) self.__fbucks_handled_orders_dynamo_db.put_item( order_number_value, {'handled_at': now_string}) # notify (silently) try: customer = self.__customer_storage.get_by_id( order.customer_id) self.__messages_storage.save( Message( str(uuid.uuid4()), customer.email.value, 'F-Bucks has been Earned!', 'You have earned {} F-Bucks by your Order #{}'. format(fbucks_amount, order.number.value))) except BaseException as e: self.__logger.log_exception(e) except BaseException as e: self.__logger.log_exception(e)
class CancelRequestPaidOrderAnswerSqsHandler(SqsHandlerInterface): def __init__(self): self.__orders_storage = OrderStorageImplementation() self.__products_storage = ProductStorageImplementation() self.__cancel_request_storage = CancelRequestStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__messages_storage = MessageStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : {} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start - {}'.format(sqs_message.message_data)) request_number = CancelRequest.Number(sqs_message.message_data['request_number']) order_number = Order.Number(sqs_message.message_data['order_number']) simple_sku = SimpleSku(sqs_message.message_data['simple_sku']) qty = Qty(sqs_message.message_data['qty']) status = sqs_message.message_data['status'] actions_map = { 'approved': self.__approve, 'declined': self.__decline, } action = actions_map.get(status) if not action: raise Exception('{} can\'t handle SQS message {}:{}! Status is unknown!'.format( self.handle.__qualname__, sqs_message.message_type, sqs_message.message_data )) action(request_number, order_number, simple_sku, qty, __log_flow) __log_flow('End') def __approve( self, request_number: CancelRequest.Number, order_number: Order.Number, simple_sku: SimpleSku, qty: Qty, __log_flow ) -> None: __log_flow('Approving...') cancel_request = self.__cancel_request_storage.get_by_number(request_number) order = self.__orders_storage.load(order_number) product = self.__products_storage.load(simple_sku) cancel_request.approve_item(simple_sku) order.approve_cancellation_after_payment(simple_sku, qty) product.restore_qty(qty) order_change_event = OrderChangeSqsSenderEvent(order) __log_flow('Cancel Request Saving...') self.__cancel_request_storage.save(cancel_request) __log_flow('Cancel Request Saved!') __log_flow('Order Saving...') self.__orders_storage.save(order) __log_flow('Order Saved!') __log_flow('Product Saving...') self.__products_storage.update(product) __log_flow('Product Saved!') __log_flow('Order SQS Sending...') self.__sqs_sender.send(order_change_event) __log_flow('Order SQS Sent!') try: __log_flow('Notification popup: Adding...') self.__add_notification_message(cancel_request, order, product, 'Approved') __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('Approved!') def __decline( self, request_number: CancelRequest.Number, order_number: Order.Number, simple_sku: SimpleSku, qty: Qty, __log_flow ) -> None: __log_flow('Declining...') cancel_request = self.__cancel_request_storage.get_by_number(request_number) order = self.__orders_storage.load(order_number) product = self.__products_storage.load(simple_sku) cancel_request.decline_item(simple_sku) order.decline_cancellation_after_payment(simple_sku, qty) order_change_event = OrderChangeSqsSenderEvent(order) __log_flow('Cancel Request Saving...') self.__cancel_request_storage.save(cancel_request) __log_flow('Cancel Request Saved!') __log_flow('Order Saving...') self.__orders_storage.save(order) __log_flow('Order Saved!') __log_flow('Order SQS Sending...') self.__sqs_sender.send(order_change_event) __log_flow('Order SQS Sent!') try: __log_flow('Notification popup: Adding...') self.__add_notification_message(cancel_request, order, product, 'Declined') __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('Declined!') def __add_notification_message( self, cancel_request: CancelRequest, order: Order, product: ProductInterface, status_label: str ) -> None: customer = self.__customer_storage.get_by_id(order.customer_id) message = Message( str(uuid.uuid4()), customer.email.value, 'Cancellation Request #{} has been Updated!'.format(cancel_request.number.value), 'Cancellation Request for Product "{}" for Order #{} has been {}!'.format( product.name.value, order.number.value, status_label ), ) self.__messages_storage.save(message)
class CancelledOrderOnPortalSideSqsHandle(SqsHandlerInterface): def __init__(self): self.__orders_storage = OrderStorageImplementation() self.__products_storage = ProductStorageImplementation() self.__cancel_request_storage = CancelRequestStorageImplementation() self.__customer_storage = CustomerStorageImplementation() self.__messages_storage = MessageStorageImplementation() self.__sqs_sender = SqsSenderImplementation() self.__logger = Logger() def handle(self, sqs_message: SqsMessage) -> None: def __log_flow(text: str) -> None: self.__logger.log_simple('{} : {} : {}'.format( self.__class__.__qualname__, sqs_message.id, text )) __log_flow('Start - {}'.format(sqs_message.message_data)) order_number = Order.Number(sqs_message.message_data['order_number']) simple_sku = SimpleSku(sqs_message.message_data['simple_sku']) qty = Qty(sqs_message.message_data['qty']) order = self.__orders_storage.load(order_number) product = self.__products_storage.load(simple_sku) if order.was_paid: order.request_cancellation_after_payment(simple_sku, qty) order.approve_cancellation_after_payment(simple_sku, qty) else: order.cancel_before_payment(simple_sku, qty) product.restore_qty(qty) order_change_event = OrderChangeSqsSenderEvent(order) __log_flow('Order Saving...') self.__orders_storage.save(order) __log_flow('Order Saved!') __log_flow('Product Saving...') self.__products_storage.update(product) __log_flow('Product Saved!') __log_flow('Order SQS Sending...') self.__sqs_sender.send(order_change_event) __log_flow('Order SQS Sent!') try: __log_flow('Notification popup: Adding...') customer = self.__customer_storage.get_by_id(order.customer_id) message = Message( str(uuid.uuid4()), customer.email.value, 'Order #{} has been Updated!'.format(order.number.value), 'Product "{}" for Order #{} has been Cancelled in Qty {}!'.format( product.name.value, order.number.value, qty.value ), ) self.__messages_storage.save(message) __log_flow('Notification popup: Added!') except BaseException as e: self.__logger.log_exception(e) __log_flow('Notification popup: Not Added because of Error : {}'.format(str(e))) __log_flow('End')