class ControlAction(Model):
date = columns.Date(required = True, partition_key = True)
time = columns.Time(required = True, primary_key = True)
mac_address = columns.Bytes(required = True, primary_key = True)
user_id = columns.Bytes(required = True, primary_key = True)
command = columns.Text(required = True)
params = columns.Text()
result = columns.Text()
def validate(self):
super(ControlAction, self).validate()
validate_mac_address(self.mac_address)
validate_user_id(self.user_id)
@staticmethod
def validate_mac_address(id):
if len(id) != 6:
raise ValidationError('not a valid mac address')
return id
@staticmethod
def validate_user_id(id):
if len(id) != 12 or not mongo_adapter.is_valid_foreign_id(PEOPLE_COLLECTION_NAME, id.hex()):
raise ValidationError('not a valid user id')
return id
class HarvesterResponse(models.Model):
"""A parody of requests.response but stored in cassandra
Should reflect all methods of a response object
Contains an additional field time_made, self-explanitory
"""
__table_name__ = 'responses'
method = columns.Text(primary_key=True)
url = columns.Text(primary_key=True, required=True)
# Raw request data
ok = columns.Boolean()
content = columns.Bytes()
encoding = columns.Text()
headers_str = columns.Text()
status_code = columns.Integer()
time_made = columns.DateTime(default=datetime.now)
def json(self):
return json.loads(self.content)
@property
def headers(self):
return CaseInsensitiveDict(json.loads(self.headers_str))
@property
def text(self):
return six.u(self.content)
class user(Model, UserMixin):
hidden = ['password', 'google_id', 'facebook_id']
id = columns.UUID(required=True, partition_key=True)
password = columns.Bytes(required=False, )
privacy = columns.Text(required=False, )
email = columns.Text(
required=False,
index=True,
)
user_type = columns.Text(required=False, )
email_confirmed = columns.Boolean(required=False, default=False)
profile_completed = columns.Boolean(required=False, )
google_id = columns.Text(
required=False,
index=True,
)
facebook_id = columns.Text(
required=False,
index=True,
)
created_at = columns.DateTime()
updated_at = columns.DateTime()
class Activity(BaseActivity):
actor = columns.Integer(required=False)
extra_context = columns.Bytes(required=False)
object = columns.Integer(required=False)
target = columns.Integer(required=False)
time = columns.DateTime(required=False)
verb = columns.Integer(required=False)
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 Account(AioModel):
__table_name__ = 'account'
account_id = columns.Text(primary_key=True)
user_id = columns.UUID(required=True, index=True)
password = columns.Bytes(required=True)
salt = columns.Bytes(required=True)
# 默认没有身份
role_id = columns.Text()
created_at = columns.DateTime(default=datetime.utcnow)
updated_at = columns.DateTime(default=datetime.utcnow)
@classmethod
async def new(cls, account_id, role_id, password: str):
# 生成盐
salt = bcrypt.gensalt()
# 密码加密
encrypted_password = bcrypt.hashpw(password.encode('utf-8'), salt)
user_id = str(uuid.uuid4())
account = await Account.async_create(account_id=account_id,
user_id=user_id,
role_id=role_id,
password=encrypted_password,
salt=salt)
# 发送创建 profile 的信息
await app.exchange.publish(
Message(ujson.dumps({
'user_id': user_id,
'role_id': role_id,
'event': 'create_profile'
}).encode(),
content_type='application/json'),
app.config.RABBITMQ_ROUTING_KEY)
return account
async def verify_password(self, password):
# 验证密码
encrypted_password = bcrypt.hashpw(password.encode('utf-8'), self.salt)
if encrypted_password != self.password:
return False
else:
return True
class RawMessage(BaseModel):
"""Raw message model."""
raw_msg_id = columns.UUID(primary_key=True, default=uuid.uuid4)
raw_data = columns.Bytes(
) # may be empty if data is too large to fit into cassandra
raw_size = columns.Integer() # number of bytes in 'data' column
uri = columns.Text(
) # where object is stored if it was too large to fit into raw_data column
class HarvesterResponse(models.Model, BaseHarvesterResponse):
__table_name__ = 'responses'
method = columns.Text(primary_key=True)
url = columns.Text(primary_key=True, required=True)
# Raw request data
ok = columns.Boolean()
content = columns.Bytes()
encoding = columns.Text()
headers_str = columns.Text()
status_code = columns.Integer()
time_made = columns.DateTime(default=datetime.now)
class Task(models.Model):
title = columns.Text()
complete = columns.Boolean(default=False)
created = columns.DateTime() # set auto now add = True
description = columns.Text()
author = columns.UUID(
primary_key=True
) # here we are using author id instead of django author
completed_picture = columns.Bytes(required=False)
class Meta:
ordering = ('created', )
def __str__(self) -> str:
return self.title
class BlobPart(Model):
"""Blob Part Model"""
id = columns.Text(primary_key=True, default=default_uuid)
content = columns.Bytes()
compressed = columns.Boolean(default=False)
blob_id = columns.Text(index=True)
@classmethod
def find(cls, id_):
"""Find an object from its id"""
return cls.objects.filter(id=id_).first()
def __unicode__(self):
return unicode(self.id)
def length(self):
"""Return length of the activity"""
return len(self.content)
class ShiftState(Model):
date = columns.Date(required=True, partition_key=True)
time = columns.Time(required=True, primary_key=True)
shift_id = columns.Bytes(required=True)
warning_level = columns.Text(required=True)
remaining_cartridges = columns.TinyInt(required=True)
remaining_air = columns.TinyInt(required=True)
remaining_electricity = columns.TinyInt(required=True)
comment = columns.Text()
def validate(self):
super(ShiftState, self).validate()
ShiftState.validate_shift_id(self.shift_id)
ShiftState.validate_warning_level(self.warning_level)
ShiftState.validate_remaining_quantity(self.remaining_cartridges,
'remaining cartridges')
ShiftState.validate_remaining_quantity(self.remaining_air,
'remaining air')
ShiftState.validate_remaining_quantity(self.remaining_electricity,
'remaining electricity')
@staticmethod
def validate_shift_id(shift_id):
if len(shift_id) != 16 or not neo4j_adapter.is_valid_foreign_id(
'Shift', shift_id.hex()):
raise ValidationError('not a valid shift id')
return shift_id
@staticmethod
def validate_warning_level(warning_level):
if warning_level not in WARNING_LEVELS:
raise ValidationError('not a warning level')
return warning_level
@staticmethod
def validate_remaining_quantity(remaining_quantity, message):
if remaining_quantity < 0 or remaining_quantity > 100:
raise ValidationError('not a valid {0} value'.format(message))
return remaining_quantity
class SystemTest(Model):
date = columns.Date(required=True, partition_key=True)
time = columns.Time(required=True, primary_key=True)
system_id = columns.Bytes(required=True, primary_key=True)
result = columns.TinyInt(required=True)
def validate(self):
super(SystemTest, self).validate()
if self.result < 0 or self.result > 100:
raise ValidationError('not a valid test result value')
SystemTest.validate_system_id(self.system_id)
@staticmethod
def validate_system_id(id):
if len(id) != 12 or not mongo_adapter.is_valid_foreign_id(
SYSTEMS_COLLECTION_NAME, id.hex()):
raise ValidationError('not a valid system id')
class DocumentModel(models.Model):
'''
Defines the schema for a metadata document in cassandra
The schema contains denormalized raw document, denormalized
normalized (so sorry for the terminology clash) document, and
a list of version IDs that refer to previous versions of this
metadata.
'''
__table_name__ = 'documents_source_partitioned'
# 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() # TODO
providerUpdatedDateTime = columns.DateTime()
description = columns.Text()
freeToRead = columns.Text() # TODO
languages = columns.List(columns.Text())
licenses = columns.Text() # TODO
publisher = columns.Text() # TODO
subjects = columns.List(columns.Text())
tags = columns.List(columns.Text())
sponsorships = columns.Text() # TODO
version = columns.Text() # TODO
otherProperties = columns.Text() # TODO
shareProperties = columns.Text() # TODO
# Additional metadata
versions = columns.List(columns.UUID)
class VersionModel(models.Model):
'''
Defines the schema for a version of a metadata document in Cassandra
See the DocumentModel class. This schema is very similar, except it is
keyed on a UUID that is generated by us, rather than it's own metadata
'''
__table_name__ = 'versions'
key = columns.UUID(primary_key=True, required=True)
# Raw
doc = columns.Bytes()
docID = columns.Text()
filetype = columns.Text()
source = columns.Text()
timestamps = columns.Map(columns.Text, columns.Text)
# Normalized
uris = columns.Text()
title = columns.Text()
contributors = columns.Text() # TODO
providerUpdatedDateTime = columns.DateTime()
description = columns.Text()
freeToRead = columns.Text() # TODO
languages = columns.List(columns.Text())
licenses = columns.Text() # TODO
publisher = columns.Text() # TODO
subjects = columns.List(columns.Text())
tags = columns.List(columns.Text())
sponsorships = columns.Text() # TODO
version = columns.Text() # TODO
otherProperties = columns.Text() # TODO
shareProperties = columns.Text() # TODO
# Additional metadata
versions = columns.List(columns.UUID)
class SensorData(Model):
date = columns.Date(required = True, partition_key = True)
time = columns.Time(required = True, primary_key = True)
source_id = columns.Bytes(required = True)
event = columns.Text(required = True)
value_name = columns.Text(required = True)
value = columns.Double(required = True)
units = columns.Text(required = True)
def validate(self):
super(SensorData, self).validate()
SensorData.validate_source_id(self.source_id)
SensorData.validate_event(self.event)
SensorData.validate_value_name(self.value_name)
SensorData.validate_units(self.units)
@staticmethod
def validate_source_id(id):
if len(source_id) != 12 or not mongo_adapter.is_valid_foreign_id(SENSORS_COLLECTION_NAME, source_id.hex()):
raise ValidationError('not a valid source id')
return id
@staticmethod
def validate_event(event):
if event not in EVENTS:
raise ValidationError('not a valid event')
@staticmethod
def validate_value_name(value_name):
if value_name not in VALUE_TYPES:
raise ValidationError('not a valid value type')
@staticmethod
def validate_units(units):
if units not in VALUE_UNITS:
raise ValidationError('not a valid value units')
class RawMessage(BaseModel):
"""Raw message model."""
user_id = columns.UUID(primary_key=True)
raw_id = columns.Text(primary_key=True)
data = columns.Bytes()
class OperationState(Model):
date = columns.Date(required=True, partition_key=True)
time = columns.Time(required=True, primary_key=True)
boat_id = columns.Bytes()
operation_id = columns.Bytes(required=True)
operation_status = columns.Text(required=True)
distance_to_the_ship = columns.Double(required=True)
zenith = columns.Double(required=True)
azimuth = columns.Double(required=True)
hydrogenium = columns.Double(required=True)
helium = columns.Double(required=True)
lithium = columns.Double(required=True)
beryllium = columns.Double(required=True)
borum = columns.Double(required=True)
carboneum = columns.Double(required=True)
nitrogenium = columns.Double(required=True)
oxygenium = columns.Double(required=True)
fluorum = columns.Double(required=True)
neon = columns.Double(required=True)
natrium = columns.Double(required=True)
magnesium = columns.Double(required=True)
aluminium = columns.Double(required=True)
silicium = columns.Double(required=True)
phosphorus = columns.Double(required=True)
sulfur = columns.Double(required=True)
chlorum = columns.Double(required=True)
argon = columns.Double(required=True)
kalium = columns.Double(required=True)
calcium = columns.Double(required=True)
scandium = columns.Double(required=True)
titanium = columns.Double(required=True)
vanadium = columns.Double(required=True)
chromium = columns.Double(required=True)
manganum = columns.Double(required=True)
ferrum = columns.Double(required=True)
cobaltum = columns.Double(required=True)
niccolum = columns.Double(required=True)
cuprum = columns.Double(required=True)
zincum = columns.Double(required=True)
gallium = columns.Double(required=True)
germanium = columns.Double(required=True)
arsenicum = columns.Double(required=True)
selenium = columns.Double(required=True)
bromum = columns.Double(required=True)
crypton = columns.Double(required=True)
rubidium = columns.Double(required=True)
strontium = columns.Double(required=True)
yttrium = columns.Double(required=True)
zirconium = columns.Double(required=True)
niobium = columns.Double(required=True)
molybdaenum = columns.Double(required=True)
technetium = columns.Double(required=True)
ruthenium = columns.Double(required=True)
rhodium = columns.Double(required=True)
palladium = columns.Double(required=True)
argentum = columns.Double(required=True)
cadmium = columns.Double(required=True)
indium = columns.Double(required=True)
stannum = columns.Double(required=True)
stibium = columns.Double(required=True)
tellurium = columns.Double(required=True)
iodium = columns.Double(required=True)
xenon = columns.Double(required=True)
caesium = columns.Double(required=True)
barium = columns.Double(required=True)
lanthanum = columns.Double(required=True)
cerium = columns.Double(required=True)
praseodymium = columns.Double(required=True)
neodymium = columns.Double(required=True)
promethium = columns.Double(required=True)
samarium = columns.Double(required=True)
europium = columns.Double(required=True)
gadolinium = columns.Double(required=True)
terbium = columns.Double(required=True)
dysprosium = columns.Double(required=True)
holmium = columns.Double(required=True)
erbium = columns.Double(required=True)
thulium = columns.Double(required=True)
ytterbium = columns.Double(required=True)
lutetium = columns.Double(required=True)
hafnium = columns.Double(required=True)
tantalum = columns.Double(required=True)
wolframium = columns.Double(required=True)
rhenium = columns.Double(required=True)
osmium = columns.Double(required=True)
iridium = columns.Double(required=True)
platinum = columns.Double(required=True)
aurum = columns.Double(required=True)
hydrargyrum = columns.Double(required=True)
thallium = columns.Double(required=True)
plumbum = columns.Double(required=True)
bismuthum = columns.Double(required=True)
polonium = columns.Double(required=True)
astatum = columns.Double(required=True)
radon = columns.Double(required=True)
francium = columns.Double(required=True)
radium = columns.Double(required=True)
actinium = columns.Double(required=True)
thorium = columns.Double(required=True)
protactinium = columns.Double(required=True)
uranium = columns.Double(required=True)
neptunium = columns.Double(required=True)
plutonium = columns.Double(required=True)
americium = columns.Double(required=True)
curium = columns.Double(required=True)
berkelium = columns.Double(required=True)
californium = columns.Double(required=True)
einsteinium = columns.Double(required=True)
fermium = columns.Double(required=True)
mendelevium = columns.Double(required=True)
nobelium = columns.Double(required=True)
lawrencium = columns.Double(required=True)
rutherfordium = columns.Double(required=True)
dubnium = columns.Double(required=True)
seaborgium = columns.Double(required=True)
bohrium = columns.Double(required=True)
hassium = columns.Double(required=True)
meitnerium = columns.Double(required=True)
darmstadtium = columns.Double(required=True)
roentgenium = columns.Double(required=True)
copernicium = columns.Double(required=True)
nihonium = columns.Double(required=True)
flerovium = columns.Double(required=True)
moscovium = columns.Double(required=True)
livermorium = columns.Double(required=True)
tennessium = columns.Double(required=True)
oganesson = columns.Double(required=True)
comment = columns.Text()
def validate(self):
super(OperationState, self).validate()
OperationState.validate_boat_id(self.boat_id)
OperationState.validate_operation_id(self.operation_id)
OperationState.validate_operation_status(self.operation_status)
OperationState.validate_angle(self.zenith)
OperationState.validate_angle(self.azimuth)
OperationState.validate_elements_quantities(
[self[element] for element in CHEMICAL_ELEMENTS])
OperationState.validate_comment(self.comment)
@staticmethod
def validate_boat_id(boat_id):
if boat_id and (len(boat_id) != 12
or not mongo_adapter.is_valid_foreign_id(
BOATS_COLLECTION_NAME, boat_id.hex())):
raise ValidationError('not a valid boat id')
return boat_id
@staticmethod
def validate_operation_id(operation_id):
if len(operation_id) != 16 or not neo4j_adapter.is_valid_foreign_id(
'Operation', operation_id.hex()):
raise ValidationError('not a valid operation id')
return operation_id
@staticmethod
def validate_operation_status(operation_status):
if operation_status not in OPERATION_STATUSES:
raise ValidationError('not an operation status')
return operation_status
@staticmethod
def validate_angle(angle):
angle -= math.floor(angle / (2 * math.pi)) * 2 * math.pi
return angle
@staticmethod
def validate_elements_quantities(elements_quantities):
elements_quantity_sum = 0
for element in elements_quantities:
if element < 0:
raise ValidationError('invalid element quantity')
elements_quantity_sum += element
if abs(elements_quantity_sum - 100) > 0.1:
raise ValidationError('invalid elements quantity')
return elements_quantities
class TileModel(Model):
__keyspace__ = "nexustiles"
__table_name__ = "sea_surface_temp"
tile_id = columns.UUID(primary_key=True)
tile_blob = columns.Bytes(index=True)
class Record(Model):
key = columns.Bytes(primary_key=True)
enc_values = columns.List(columns.Blob())
class AggregatedActivity(BaseActivity):
activities = columns.Bytes(required=False)
created_at = columns.DateTime(required=False)
group = columns.Ascii(required=False)
updated_at = columns.DateTime(required=False)
