class Contact(BaseModel, IndexedModelMixin):
"""Contact model."""
_index_class = IndexedContact
user_id = columns.UUID(primary_key=True)
contact_id = columns.UUID(primary_key=True) # clustering key
additional_name = columns.Text()
addresses = columns.List(columns.UserDefinedType(PostalAddress))
avatar = columns.Text()
date_insert = columns.DateTime()
date_update = columns.DateTime()
deleted = columns.DateTime()
emails = columns.List(columns.UserDefinedType(Email))
family_name = columns.Text()
given_name = columns.Text()
groups = columns.List(columns.Text())
identities = columns.List(columns.UserDefinedType(SocialIdentity))
ims = columns.List(columns.UserDefinedType(IM))
infos = columns.Map(columns.Text, columns.Text)
name_prefix = columns.Text()
name_suffix = columns.Text()
organizations = columns.List(columns.UserDefinedType(Organization))
phones = columns.List(columns.UserDefinedType(Phone))
pi = columns.UserDefinedType(PIModel)
privacy_features = columns.Map(columns.Text(), columns.Text())
tags = columns.List(columns.Text(), db_field="tagnames")
title = columns.Text() # computed value, read only
class main(Model):
product_type = columns.Ascii(primary_key=True)
date = columns.Date(primary_key=True)
product_id = columns.Ascii(primary_key=True)
parameters = columns.Map(columns.Ascii(),
columns.Map(columns.Ascii(),
columns.Ascii()))
class BaseTripEventModel(Model):
"""
Base class so we can define the primary keys of each table separately.
For this class to make sense, you'll have to define the properties
`user_id` (columns.UUID)
`event_time` (columns.TimeUUID)
`trip_id` (columns.UUID)
"""
__abstract__ = True
event_id = columns.UUID(required=True)
event_type = columns.Text(required=True)
lat = columns.Float(required=True)
lng = columns.Float(required=True)
accuracy = columns.Float(required=True)
speed = columns.Float(required=True)
meta = columns.Map(columns.Text, columns.Float)
sdk = columns.Map(columns.Text, columns.Text)
# these properties are not persisted; they are used as a transfer mechanism when
# writing trip events and trips
score = None
waypoints = []
def to_json(self):
"""
Builds a json-serialized string for this object
:return: json-encoded string
"""
return json.dumps(self.get_serializable_dict())
def get_serializable_dict(self):
"""
Build a dictionary suitable for serialization from this object. This data structure will match that which
the client sends to us
:return: dict representation of this object
"""
user_dict = {
"userId": str(self.user_id),
"eventTime": int(unix_time_from_uuid1(self.event_time)),
"tripId": str(self.trip_id),
"eventId": str(self.event_id),
"eventType": self.event_type,
"location": {
"lat": self.lat,
"lon": self.lng,
"accuracy": self.accuracy
},
"speed": self.speed
}
if self.sdk != {}:
user_dict.update({"sdk": self.sdk})
if self.meta != None:
user_dict.update(self.meta)
return user_dict
class SNASlackMetrics(Model): __key_space__ = 'sna4slack_metrics' # Not Required __table_name__ = 'nodes_relationships' id = columns.UUID(primary_key = True) node_name = columns.Text(index=True) weight = columns.Integer() mentions = columns.Map(columns.Text(), columns.Integer()) distances = columns.Map(columns.Text(), columns.Integer()) centrality_metrices = columns.Map(columns.Text(), columns.Integer()) team_name = columns.Text(index=True)
class AccountModel(Model):
__table_name__ = "account2"
tp = columns.Text(required=True)
name = columns.Text(required=True, primary_key=True)
cash = columns.Float(required=True)
initial_cash = columns.Float(required=True)
positions = columns.Map(key_type=columns.Text,
value_type=columns.Float,
default={})
account_id = columns.Text()
history_net_value = columns.Map(key_type=columns.DateTime(),
value_type=columns.Float(),
default={})
class UserIdentity(BaseModel):
"""User's identities model."""
user_id = columns.UUID(primary_key=True)
identity_id = columns.UUID(primary_key=True)
credentials = columns.Map(columns.Text, columns.Text)
display_name = columns.Text()
identifier = columns.Text()
infos = columns.Map(columns.Text, columns.Text)
last_check = columns.DateTime()
protocol = columns.Text()
status = columns.Text()
type = columns.Text()
class AccountModel(Model):
__table_name__ = "account"
tp = columns.Text(required=True)
name = columns.Text(required=True, primary_key=True)
cash = columns.Float(required=True)
initial_cash = columns.Float(required=True)
positions = columns.Map(key_type=columns.Text,
value_type=columns.Float,
default={})
history_net_value = columns.Map(key_type=columns.DateTime(),
value_type=columns.Float(),
default={})
orders = columns.List(value_type=UserDefinedType(UserOrderModel))
class IndexedCollectionsTestModel(Model):
test_id = columns.Integer(primary_key=True)
attempt_id = columns.Integer(index=True)
description = columns.Text()
expected_result = columns.Integer()
test_result = columns.Integer(index=True)
test_list = columns.List(columns.Integer, index=True)
test_set = columns.Set(columns.Integer, index=True)
test_map = columns.Map(columns.Text, columns.Integer, index=True)
test_list_no_index = columns.List(columns.Integer, index=False)
test_set_no_index = columns.Set(columns.Integer, index=False)
test_map_no_index = columns.Map(columns.Text, columns.Integer, index=False)
class BeaconLogs(DjangoCassandraModel):
id = columns.UUID(primary_key=True, default=uuid.uuid4)
beaconId = columns.Integer(primary_key=True)
interaccionUser = columns.Map(columns.Integer(), columns.Text())
interaccionProducto = columns.Map(columns.Integer(), columns.Text())
geolocalizacion = columns.Text()
bluetoothName = columns.Text(index=True)
mensaje = columns.Text()
UUID = columns.UUID(default=uuid.uuid4)
bateria = columns.Integer(index=True)
interval = columns.Integer()
class Meta:
get_pk_field = 'id'
class CronTraceByCron(BaseModel):
command_name = columns.Text(partition_key=True)
log_timestamp = columns.DateTime(primary_key=True)
state = columns.Integer(primary_key=True)
state_verbose = columns.Text()
context = columns.Map(columns.Text(), columns.Text())
hostname = columns.Text()
class SubmissionTraceByTimestamp(BaseModel):
log_timestamp_3 = columns.DateTime(partition_key=True)
submission_id = columns.Integer(primary_key=True, clustering_order="DESC")
log_timestamp = columns.DateTime()
state = columns.Integer(primary_key=True)
state_verbose = columns.Text()
user_id = columns.Integer()
run_id = columns.Integer()
context = columns.Map(columns.Text(), columns.Text())
@staticmethod
def get_partition_key(datetime_obj):
dt = datetime_obj.replace(minute=0,
second=0,
microsecond=0,
hour=datetime_obj.hour / 3)
return dt
@classmethod
def log(cls, **kwargs):
log_timestamp = kwargs.get('log_timestamp')
if not log_timestamp:
raise Exception('Timestamp should be provided.')
log_timestamp_3 = cls.get_partition_key(log_timestamp)
obj = cls.create(log_timestamp_3=log_timestamp_3, **kwargs)
return obj
class page_meta_type(usertype.UserType):
meta_title = columns.Text(required=False)
full_title = columns.Text(required=False)
meta_dscr = columns.Text(required=False)
meta_keywords = columns.Set(columns.Text(required=False))
other_languages = columns.Map(columns.Text(required=False), columns.Text(required=False))
other_html = columns.Text(required=False)
class UserOrderModel(Model):
__table_name__ = "user_order5"
account_name = columns.Text(required=True, primary_key=True)
place_time = columns.DateTime(required=True,
primary_key=True,
clustering_order='ASC')
type = columns.Text(required=True)
code = columns.Text(required=True)
direction = columns.Text(required=True)
quantity = columns.Float(required=True)
status = columns.Text(required=True)
reason = columns.Text(required=True)
remark = columns.Text()
real_order_id = columns.Text()
failed_reason = columns.Text()
cancel_reason = columns.Text()
ideal_price = columns.Float()
filled_start_time = columns.DateTime()
filled_end_time = columns.DateTime()
filled_quantity = columns.Float()
filled_avg_price = columns.Float()
fee = columns.Float()
limit_price = columns.Float()
stop_price = columns.Float()
execution_map = columns.Map(
key_type=columns.Text,
value_type=UserDefinedType(UserOrderExecutionModel),
default={})
# price_change_history = columns.List(value_type=UserDefinedType(PriceChangeModel), default=[])
bargainer = columns.UserDefinedType(BargainerModel)
class TimeSeriesModel(Model):
__table_name__ = "time_series2"
name = columns.Text(primary_key=True, required=True)
data_record = columns.Map(
key_type=columns.Text(),
value_type=columns.UserDefinedType(DataRecordModel),
default={})
class DeviceLocation(BaseUserType):
"""Device known location, base on IP."""
address = columns.Text(primary_key=True) # IP address with CIDR
type = columns.Text() # home/work/etc
country = columns.Text()
privacy_features = columns.Map(columns.Text, columns.Text)
class DocumentModel(models.Model):
__table_name__ = 'documents'
# Raw
source = columns.Text(primary_key=True, partition_key=True)
docID = columns.Text(primary_key=True, index=True, clustering_order='ASC')
doc = columns.Bytes()
filetype = columns.Text()
timestamps = columns.Map(columns.Text, columns.Text)
# Normalized
uris = columns.Text()
title = columns.Text()
contributors = columns.Text()
providerUpdatedDateTime = columns.DateTime()
description = columns.Text()
freeToRead = columns.Text()
languages = columns.List(columns.Text())
licenses = columns.Text()
publisher = columns.Text()
subjects = columns.List(columns.Text())
tags = columns.List(columns.Text())
sponsorships = columns.Text()
version = columns.Text()
otherProperties = columns.Text()
shareProperties = columns.Text()
# Additional metadata
versions = columns.List(columns.UUID)
class Message(BaseModel, IndexedModelMixin):
"""Message model."""
_index_class = IndexedMessage
attachments = columns.List(columns.UserDefinedType(MessageAttachment))
body_html = columns.Text()
body_plain = columns.Text()
date = columns.DateTime()
date_delete = columns.DateTime()
date_insert = columns.DateTime()
discussion_id = columns.UUID()
external_references = columns.UserDefinedType(ExternalReferences)
identities = columns.List(columns.UserDefinedType(Identity))
importance_level = columns.Integer()
is_answered = columns.Boolean()
is_draft = columns.Boolean()
is_unread = columns.Boolean()
is_received = columns.Boolean(default=False)
message_id = columns.UUID(primary_key=True, default=uuid.uuid4)
parent_id = columns.UUID()
participants = columns.List(columns.UserDefinedType(Participant))
privacy_features = columns.Map(columns.Text(), columns.Text())
pi = columns.UserDefinedType(PIModel)
raw_msg_id = columns.UUID()
subject = columns.Text() # Subject of email, the message for short
tags = columns.List(columns.Text(), db_field="tagnames")
type = columns.Text()
user_id = columns.UUID(primary_key=True)
def test_instantiation_with_column_instance(self):
"""
Tests that columns instantiated with a column instance work properly
"""
column = columns.Map(columns.Text(min_length=100), columns.Integer())
assert isinstance(column.key_col, columns.Text)
assert isinstance(column.value_col, columns.Integer)
class Provider(BaseModel):
"""model to store data related to external protocol endpoints"""
name = columns.Text(primary_key=True)
instance = columns.Text(primary_key=True)
infos = columns.Map(columns.Text, columns.Text)
date_insert = columns.DateTime()
def test_instantiation_with_column_class(self):
"""
Tests that columns instantiated with a column class work properly
and that the class is instantiated in the constructor
"""
column = columns.Map(columns.Text, columns.Integer)
assert isinstance(column.key_col, columns.Text)
assert isinstance(column.value_col, columns.Integer)
class SubmissionTraceBySubmission(BaseModel):
submission_id = columns.Integer(partition_key=True)
log_timestamp = columns.DateTime(primary_key=True)
state = columns.Integer(primary_key=True)
state_verbose = columns.Text()
user_id = columns.Integer()
run_id = columns.Integer()
context = columns.Map(columns.Text(), columns.Text())
class SocialIdentity(BaseContactModel):
"""Any contact social identity (facebook, twitter, linkedin, etc)."""
name = columns.Text(primary_key=True)
type = columns.Text()
# Abstract everything else in a map
infos = columns.Map(columns.Text, columns.Text)
class User(BaseModel):
"""User main model."""
user_id = columns.UUID(primary_key=True, default=uuid.uuid4)
name = columns.Text(required=True)
password = columns.Text(required=True)
date_insert = columns.DateTime()
given_name = columns.Text()
family_name = columns.Text()
params = columns.Map(columns.Text, columns.Text)
contact_id = columns.UUID()
main_user_id = columns.UUID()
recovery_email = columns.Text(required=True)
local_identities = columns.List(columns.Text())
privacy_features = columns.Map(columns.Text(), columns.Text())
pi = columns.UserDefinedType(PIModel)
class FourthModel(Model):
__table_name__ = 'first_model'
first_key = columns.UUID(primary_key=True)
second_key = columns.UUID()
third_key = columns.Text()
# removed fourth key, but it should stay in the DB
renamed = columns.Map(columns.Text, columns.Text, db_field='blah')
class ThirdModel(Model):
__table_name__ = 'first_model'
first_key = columns.UUID(primary_key=True)
second_key = columns.UUID()
third_key = columns.Text()
# removed fourth key, but it should stay in the DB
blah = columns.Map(columns.Text, columns.Text)
class FourthModel(Model):
__table_name__ = 'first_model'
first_key = columns.UUID(primary_key=True)
second_key = columns.UUID()
third_key = columns.Text()
# renamed model field, but map to existing column
renamed = columns.Map(columns.Text, columns.Text, db_field='blah')
def test_to_python(self):
""" Tests that to_python of value column is called """
column = columns.Map(JsonTestColumn, JsonTestColumn)
val = {1: 2, 3: 4, 5: 6}
db_val = column.to_database(val)
self.assertEqual(db_val, dict((json.dumps(k), json.dumps(v)) for k, v in val.items()))
py_val = column.to_python(db_val)
self.assertEqual(py_val, val)
class TestModelSave(Model):
partition = columns.UUID(primary_key=True, default=uuid4)
cluster = columns.Integer(primary_key=True)
count = columns.Integer(required=False)
text = columns.Text(required=False, index=True)
text_set = columns.Set(columns.Text, required=False)
text_list = columns.List(columns.Text, required=False)
text_map = columns.Map(columns.Text, columns.Text, required=False)
def test_to_python(self):
""" Tests that to_python of value column is called """
column = columns.Map(JsonTestColumn, JsonTestColumn)
val = {1: 2, 3: 4, 5: 6}
db_val = column.to_database(val)
assert db_val.value == {json.dumps(k):json.dumps(v) for k,v in val.items()}
py_val = column.to_python(db_val.value)
assert py_val == val
class Worker(UserType, JsonMixin):
"""
Worker
"""
tasks = columns.Map(columns.Text, columns.Text)
def add_task(self, obj=None):
self.tasks.update(obj)
