class Event(Model):
"""
Event
"""
__table_name__ = 'event'
parent_id = columns.UUID(primary_key=True)
id = columns.TimeUUID(primary_key=True,
clustering_order='DESC',
default=uuid.uuid1)
source_type = columns.Text(discriminator_column=True)
action = columns.TinyInt()
data = columns.Text(required=True)
created_on = columns.DateTime(default=datetime.utcnow)
@classmethod
def create(cls, **kwargs):
parent = kwargs.get('parent')
if parent is None:
raise ValidationError('parent - None values are not allowed.')
kwargs['parent_id'] = parent.id
kwargs['data'] = parent.to_json()
del kwargs['parent']
event = super(Event, cls).create(**kwargs)
sender = 'event.{}'.format(event.type)
signal('on_event').send(sender, instance=event, parent=parent)
return event
@property
def type(self):
data = json.loads(self.data)
return '{}.{}'.format(data.get('object', 'object'),
ACTIONS_MAP[self.action])
class InboxEntryBase(DjangoCassandraModel):
__table_name__ = 'inbox_entries'
class Meta:
get_pk_field = 'id'
userid = columns.UUID(primary_key=True)
id = columns.TimeUUID(primary_key=True,
default=timeuuid_now,
clustering_order="DESC")
inbox_type = columns.Text(discriminator_column=True)
@property
def published(self):
return datetime_from_uuid1(self.id)
json_fields = {}
@property
def json_data(self):
data = {
'pk': str(self.id),
'type': self.type.value,
'published': str(self.published),
}
for key, colname in self.json_fields.items():
data[key] = getattr(self, colname)
return data
class LikeInboxEntryModel(InboxEntryBase):
type = InboxTypes.LIKE
__discriminator_value__ = type.value
feedentryid = columns.TimeUUID()
likerid = columns.UUID()
json_fields = {'feedentryid': 'feedentryid', 'likerid': 'likerid'}
class CommentedInboxEntryModel(InboxEntryBase):
type = InboxTypes.COMMENT
__discriminator_value__ = type.value
feedentryid = columns.TimeUUID()
comment_text = columns.Text()
json_fields = {'text': 'comment_text'}
class PositionLatent(Model):
__table_name__ = 'users_position_latent'
__keyspace__ = 'unixerr'
__connection__ = 'DML'
user_id = columns.BigInt(partition_key=True)
time = columns.TimeUUID(partition_key=True)
position_latent = columns.Text()
class Ticket(models.Model):
__table_name__ = 'tickets'
ticket_id = columns.TimeUUID(primary_key=True, default=uuid1())
status = columns.Integer(default=1, index=True)
priority = columns.Integer(default=2, index=True)
subject = columns.Text(required=True)
content = columns.Text(required=True)
created_at = columns.DateTime(default=datetime.now, index=True)
class User(Model):
__table_name__ = 'users_info'
__keyspace__ = 'unixerr'
__connection__ = 'DML'
id = columns.BigInt(partition_key=True)
time = columns.TimeUUID(partition_key=True)
rollcall_score = columns.Integer()
class_activity = columns.Float()
discipline = columns.Float()
total_quizzes_avg = columns.Float(primary_key=True,
clustering_order='DESC')
class BundleSeenModel(DjangoCassandraModel):
class Meta:
# required but meaningless in this context
get_pk_field = 'userid'
userid = columns.UUID(primary_key=True)
bundleid = columns.UUID(primary_key=True)
ts = columns.TimeUUID(primary_key=True,
default=timeuuid_now,
clustering_order="DESC")
entryid = columns.UUID()
class FeedEntryModel(DjangoCassandraModel):
class Meta:
get_pk_field = 'id'
userid = columns.UUID(primary_key=True)
id = columns.TimeUUID(primary_key=True,
default=timeuuid_now,
clustering_order="DESC")
comment_count = columns.SmallInt(default=0)
@property
def published(self):
return datetime_from_uuid1(self.id)
class TripEventByUser(BaseTripEventModel):
"""
ORM class for retrieving and saving trip events
"""
__table_name__ = "trip_events_by_user"
user_id = columns.UUID(primary_key=True, required=True)
event_time = columns.TimeUUID(primary_key=True,
clustering_order="DESC",
required=True)
trip_id = columns.UUID(primary_key=True,
clustering_order="DESC",
required=True)
foo = columns.Text()
class AllDatatypes(UserType):
a = columns.Ascii()
b = columns.BigInt()
c = columns.Blob()
d = columns.Boolean()
e = columns.DateTime()
f = columns.Decimal()
g = columns.Double()
h = columns.Float()
i = columns.Inet()
j = columns.Integer()
k = columns.Text()
l = columns.TimeUUID()
m = columns.UUID()
n = columns.VarInt()
class AllDatatypesModel(Model):
id = columns.Integer(primary_key=True)
a = columns.Ascii()
b = columns.BigInt()
c = columns.Blob()
d = columns.Boolean()
e = columns.DateTime()
f = columns.Decimal()
g = columns.Double()
h = columns.Float()
i = columns.Inet()
j = columns.Integer()
k = columns.Text()
l = columns.TimeUUID()
m = columns.UUID()
n = columns.VarInt()
class Notification(BaseModel):
"""
Table to store notifications queues in cassandra
user_id: user's id to which notification belongs to.
notif_id: time UUID V1 (en.wikipedia.org/wiki/Universally_unique_identifier)
emitter : backend entity that's emitting the message.
type: a single word to describe notification's type: event, info, feedback..
reference: (optional) a reference number previously sent by frontend.
body: could be a simple word or a more complex structure like a json.
"""
user_id = columns.UUID(primary_key=True)
notif_id = columns.TimeUUID(primary_key=True)
emitter = columns.Text()
type = columns.Ascii()
reference = columns.Text()
body = columns.Blob()
class Activity(Model):
"""Activity Model"""
id = columns.Text(default=default_date, primary_key=True)
html = columns.Text()
when = columns.TimeUUID(primary_key=True,
default=default_time,
clustering_order="DESC")
@classmethod
def new(cls, content):
""""Create a new Activity"""
return cls.create(html=content)
@classmethod
def recent(cls, count=20):
"""Return the last activities"""
return Activity.objects.filter(id__in=last_x_days())\
.order_by("-when").all().limit(count)
def __unicode__(self):
return unicode(self.html)
class ChatMessageByChatId(Model):
chat_id = columns.Text(primary_key=True)
message_id = columns.TimeUUID()
author_id = columns.Text()
text = columns.Text()
asset_name = columns.Text()
type = columns.Text()
meta_data = columns.Text()
allowed_type = ['text', 'glimpse', 'glimpse_narrative', 'image']
def to_object(self):
return {
'chat_id': self.chat_id,
'message_id': str(self.message_id),
'author_id': self.author_id,
'time': datetime_from_uuid1(self.message_id).isoformat(),
'type': self.type,
'text': self.text,
'asset_name': self.asset_name,
'meta_data': self.meta_data
}
class Transaction(Model):
__keyspace__ = os.environ['CASSANDRA_KEYSPACE']
id = columns.TimeUUID(primary_key=True, default=uuid1)
sender_account_number = columns.Text()
receiver_account_number = columns.Text()
class DerivedTimeModel(TimeModelBase):
__table_name__ = 'derived_time'
uuid = columns.TimeUUID(primary_key=True, partition_key=True)
value = columns.Text(required=False)
class TimeModelBase(Model):
uuid = columns.TimeUUID(primary_key=True)
class AccountTransaction(AbstractBaseModel):
"""
AccountTransaction
"""
__table_name__ = 'account_transaction'
account_id = columns.UUID(primary_key=True)
id = columns.TimeUUID(primary_key=True,
clustering_order='DESC',
default=uuid.uuid1)
description = columns.Text()
value = columns.UserDefinedType(Amount)
source_id = columns.UUID()
signature = columns.Text()
type = columns.Text(discriminator_column=True)
status = columns.TinyInt(default=TRANSACTION_PENDING[0], index=True)
# failure code
failure_code = columns.SmallInt()
def __init__(self, *args, **kwargs):
super(AccountTransaction, self).__init__(*args, **kwargs)
self._init_machine()
# ---------------
# Machine Methods
# ---------------
def _init_machine(self, transitions=TRANSACTION_STATE_TRANSITIONS):
"""
Method to hook a state machine to the instance
"""
states = list(TRANSACTION_STATUS_STRING_CHOICES)
self.machine = Machine(model=self,
states=states,
transitions=transitions,
auto_transitions=False,
send_event=True,
initial=TRANSACTION_STATUS_MAP[self.status],
after_state_change='_state_changed')
def _state_changed(self, event):
"""
callback from state machine to change status on instance and persist
:param event: EventData
:return:
"""
self.status = TRANSACTION_STATUS_STRING_MAP[event.state.name]
persist = event.kwargs.get('persist', False)
if persist:
self.save()
def execute_operation(self, event, **kwargs):
"""
:param event: EventData
:return:
"""
transfer = event.kwargs.get('transfer')
if transfer is None:
raise TransferNotAvailable
if transfer.is_sealed():
account = CurrentAccount.objects(id=self.account_id).get()
response = account.execute_pending(self.id)
event.kwargs.update({'operation_response': response})
account.save()
else:
event.kwargs.update({
'operation_response':
Response(error=FAILURE_TRANSFER_IS_NOT_SEALED)
})
def execute_cancel(self, event, **kwargs):
"""
:param event: EventData
:return:
"""
transfer = event.kwargs.get('transfer')
if transfer is None:
raise TransferNotAvailable
if transfer.is_created():
account = CurrentAccount.objects(id=self.account_id).get()
response = account.cancel_pending(self.id)
event.kwargs.update({'operation_response': response})
account.save()
def has_execute_succeed(self, event, **kwargs):
"""
:param event: EventData
:return:
"""
response = event.kwargs.get('operation_response')
if not response.is_success:
self.failure_code = response.error_code
return False
return True
def has_failure_code(self, event, **kwargs):
"""
:param event: EventData
:return:
"""
return self.failure_code is not None
class Hero(models.Model):
hero_id = columns.TimeUUID(primary_key=True, default=uuid1())
name = columns.Text(required=True, max_length=60)
alias = columns.Text(required=True, max_length=60)
email = columns.Text(required=True, max_length=60)
class TimeUUIDQueryModel(Model):
partition = columns.UUID(primary_key=True)
time = columns.TimeUUID(primary_key=True)
data = columns.Text(required=False)
