class Order(db.Document):
user_id = db.StringField()
status = db.StringField(choices=tuple(
types.get_events(types.EventType.Order())),
default=types.EventType.Order.CREATED)
expires_at = db.DateTimeField(
default=datetime.datetime.now() +
datetime.timedelta(minutes=Config.ORDER_EXPIRE_TIME_MIN))
ticket = db.ReferenceField('Ticket')
version = db.IntField(default=0)
def response(self):
return {
"id": str(self.id),
"user_id": self.user_id,
"status": self.status,
"expires_at": str(self.expires_at),
"ticket": self.ticket.response(),
"version": self.version
}
def update_version_if_record_exists(self):
if not self.id:
return
existing_record = Order.objects(id=self.id)
if existing_record:
self.version += 1
def save(self, *args, **kwargs):
self.update_version_if_record_exists()
super().save(*args, **kwargs)
import pika
from src.config import Config
from common.events.utils import bind_q_to_exchange, declare_queue
from common.events.types import ExchangeType, EventType, get_events
expiration_event = EventType.Expiration()
qs = get_events(expiration_event)
broker_connection = pika.BlockingConnection(
pika.ConnectionParameters(host=Config.BROKER_HOST,
port=5672,
credentials=Config.BROKER_CRED,
virtual_host=Config.BROKER_VHOST))
publish_channel = broker_connection.channel()
publish_channel.exchange_declare(exchange=ExchangeType.EXPIRATION,
exchange_type='direct')
declare_queue(publish_channel, qs)
bind_q_to_exchange(publish_channel, qs, ExchangeType.EXPIRATION)
import pika
from src.config import Config
from src.events.listeners.callbacks import ticket_created_callback, ticket_updated_callback, expiration_complete_callback
from common.events.types import EventType, ExchangeType, get_events
from common.events.utils import declare_queue, bind_q_to_exchange
from threading import Thread
ticket_event = EventType.Ticket()
qs = get_events(ticket_event)
broker_connection = pika.BlockingConnection(
pika.ConnectionParameters(host=Config.BROKER_HOST,
port=5672,
credentials=Config.BROKER_CRED,
virtual_host=Config.BROKER_VHOST))
consume_channel = broker_connection.channel()
consume_channel.exchange_declare(exchange=ExchangeType.TICKET,
exchange_type='direct')
declare_queue(consume_channel, qs)
bind_q_to_exchange(consume_channel, qs, ExchangeType.TICKET)
consume_channel.basic_consume(queue=EventType.Ticket.CREATED,
on_message_callback=ticket_created_callback)
consume_channel.basic_consume(queue=EventType.Ticket.UPDATED,
on_message_callback=ticket_updated_callback)
# consume_channel.start_consuming()
thread = Thread(target=consume_channel.start_consuming)
thread.start()
import pika
from src.config import Config
from common.events.utils import bind_q_to_exchange, declare_queue
from common.events.types import ExchangeType, EventType, get_events
order_event = EventType.Order()
qs = get_events(order_event)
broker_connection = pika.BlockingConnection(
pika.ConnectionParameters(host=Config.BROKER_HOST,
port=5672,
credentials=Config.BROKER_CRED,
virtual_host=Config.BROKER_VHOST))
publish_channel = broker_connection.channel()
publish_channel.exchange_declare(exchange=ExchangeType.ORDER,
exchange_type='direct')
declare_queue(publish_channel, qs)
bind_q_to_exchange(publish_channel, qs, ExchangeType.ORDER)
import pika
from src.config import Config
from common.events.utils import bind_q_to_exchange, declare_queue
from common.events.types import ExchangeType, EventType, get_events
ticket_event = EventType.Ticket()
qs = get_events(ticket_event)
broker_connection = pika.BlockingConnection(pika.ConnectionParameters(
host=Config.BROKER_HOST, port=5672, credentials=Config.BROKER_CRED, virtual_host=Config.BROKER_VHOST))
publish_channel = broker_connection.channel()
publish_channel.exchange_declare(
exchange=ExchangeType.TICKET, exchange_type='direct')
declare_queue(publish_channel, qs)
bind_q_to_exchange(publish_channel, qs, ExchangeType.TICKET)