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 Comentario(Base):
id = columns.UUID(primary_key=True, default=uuid.uuid4)
cuerpo = columns.Text()
usuario = columns.Text()
puntuacion = columns.BigInt()
idnoticia = columns.UUID(default=uuid.uuid4)
def __dict__(self):
comentario = {
"Id": str(self.id),
"Cuerpo": self.cuerpo,
"Usuario": self.usuario,
"Puntuacion": str(self.puntuacion),
"Idnoticia": str(self.idnoticia),
}
return comentario
def setCuerpo(self, cuerpo):
self.cuerpo = cuerpo
def setUsuario(self, usuario):
self.usuario = usuario
def setPuntuacion(self, puntuacion):
self.puntuacion = puntuacion
def get_data(self):
return {
'id': str(self.id),
'cuerpo': self.cuerpo,
'usuario': self.usuario,
'puntuacion': str(self.puntuacion),
'idnoticia': str(self.idnoticia)
}
def __eq__(self, other):
if not isinstance(other, Comentario):
return NotImplemented
return self.id == other.id and \
self.cuerpo == other.cuerpo and \
self.usuario == other.usuario and \
self.puntuacion == other.puntuacion and \
self.idnoticia == other.idnoticia
class Vehicles(m.Model):
__keyspace__ = "swapi"
__connection__ = "swapi"
id = col.BigInt(primary_key=True)
cargo_capacity = col.Text(max_length=32)
consumables = col.Text(max_length=96)
cost_in_credits = col.Text(max_length=96)
crew = col.Text(max_length=32)
films = col.Set(col.BigInt)
length = col.Text(max_length=32)
manufacturer = col.Text(max_length=96)
max_atmosphering_speed = col.Text(max_length=32)
model = col.Text(max_length=96)
name = col.Text(max_length=96)
passengers = col.Text(max_length=16)
pilots = col.Set(col.BigInt)
vehicle_class = col.Text(max_length=96)
class Films(m.Model):
__keyspace__ = "swapi"
__connection__ = "swapi"
id = col.BigInt(primary_key=True)
episode_id = col.Integer(index=True)
title = col.Text(index=True)
director = col.Text(max_length=96)
producer = col.Text(max_length=96)
release_date = col.Date()
opening_crawl = col.Text()
species = col.Set(col.BigInt)
starships = col.Set(col.BigInt)
vehicles = col.Set(col.BigInt)
characters = col.Set(col.BigInt)
planets = col.Set(col.BigInt)
created = col.Date()
edited = col.Date()
class Planets(m.Model):
__keyspace__ = "swapi"
__connection__ = "swapi"
id = col.BigInt(primary_key=True)
name = col.Text(max_length=96)
diameter = col.Text(max_length=16)
rotation_period = col.Text(max_length=16)
orbital_period = col.Text(max_length=16)
gravity = col.Text(max_length=96)
population = col.Text(max_length=32)
climate = col.Text(max_length=96)
terrain = col.Text(max_length=96)
surface_water = col.Text(max_length=16)
residents = col.Set(col.BigInt)
films = col.Set(col.BigInt)
created = col.Date()
edited = col.Date()
class UploadsByConfiguration(ClusteredByConfiguration):
__table_name__ = 'uploads_by_configuration_01'
suite = columns.Text(partition_key=True, required=True)
branch = columns.Text(partition_key=True, required=True)
uuid = columns.BigInt(primary_key=True, required=True, clustering_order='DESC')
sdk = columns.Text(primary_key=True, required=True)
commits = columns.Blob(required=True)
test_results = columns.Blob(required=True)
time_uploaded = columns.DateTime(required=True)
upload_version = columns.Integer(required=True)
def unpack(self):
return dict(
commits=[Commit.from_json(element) for element in json.loads(UploadContext.from_zip(bytearray(self.commits)))],
sdk=None if self.sdk == '?' else self.sdk,
test_results=json.loads(UploadContext.from_zip(bytearray(self.test_results))),
timestamp=calendar.timegm(self.time_uploaded.timetuple()),
version=self.upload_version,
)
class Candidate(Model):
__abstract__ = True
candidate = columns.Text(required=True, primary_key=True)
created_at = columns.DateTime(required=True, primary_key=True)
sentiment = columns.Float(required=True, primary_key=True)
tid = columns.BigInt(required=True, primary_key=True)
text = columns.Text(required=True)
user = columns.Text(required=False)
anger = columns.Float(required=False)
disgust = columns.Float(required=False)
fear = columns.Float(required=False)
joy = columns.Float(required=False)
sadness = columns.Float(required=False)
openness = columns.Float(required=False)
conscientiousness = columns.Float(required=False)
extraversion = columns.Float(required=False)
agreeableness = columns.Float(required=False)
range = columns.Float(required=False)
class GeoName(Model):
geonameid = columns.Integer(primary_key=True)
name = columns.Text()
asciiname = columns.Text()
alternatenames = columns.Text()
latitude = columns.Decimal()
longitude = columns.Decimal()
feature_class = columns.Text()
feature_code = columns.Text()
country_code = columns.Text()
cc2 = columns.Text()
admin1_code = columns.Text()
admin2_code = columns.Text()
admin3_code = columns.Text()
admin4_code = columns.Text()
population = columns.BigInt()
elevation = columns.Integer()
dem = columns.Integer()
timezone = columns.Text()
modification_date = columns.Date()
class Amount(UserType, JsonMixin):
"""
Amount
"""
amount = columns.BigInt(required=True)
currency = columns.Text(min_length=3, max_length=3, required=True)
def add(self, value=None):
if isinstance(value, Amount) and value.currency == self.currency:
self.amount += value.amount
def sub(self, value=None):
if isinstance(value, Amount) and value.currency == self.currency:
self.amount -= value.amount
def update(self, operation=None):
if isinstance(operation, Operation):
if operation.type == 'debit':
self.sub(operation.value)
elif operation.type == 'credit':
self.add(operation.value)
class Starships(m.Model):
__keyspace__ = "swapi"
__connection__ = "swapi"
id = col.BigInt(primary_key=True)
cargo_capacity = col.Text(max_length=32)
consumables = col.Text(max_length=96)
cost_in_credits = col.Text(max_length=32)
crew = col.Text(max_length=32)
hyperdrive_rating = col.Text(max_length=32)
length = col.Text(max_length=32)
manufacturer = col.Text(max_length=96)
max_atmosphering_speed = col.Text(max_length=32)
mglt = col.Text(max_length=96)
model = col.Text(max_length=96)
name = col.Text(max_length=96)
passengers = col.Text(max_length=16)
starship_class = col.Text(max_length=96)
films = col.Set(col.BigInt)
pilots = col.Set(col.BigInt)
created = col.Date()
edited = col.Date()
class draft_fsa_log_visit(Model):
fsa = columns.Text(primary_key=True)
userid = columns.Text(primary_key=True)
fsid = columns.Text(primary_key=True)
m_date = columns.BigInt(primary_key=True)
idsite = columns.Text()
location_path = columns.Text()
location_ipv4 = columns.Text()
location_ipv6 = columns.Text()
location_browser_lan = columns.Text()
location_country_code = columns.Text()
location_country_name = columns.Text()
location_browser_en = columns.Text()
location_city_name = columns.Text()
config_browser = columns.Text()
config_device = columns.Text()
config_browser_name = columns.Text()
config_browser_version = columns.Text()
config_resolution = columns.Text()
config_color_depth = columns.Text()
config_viewport_size = columns.Text()
config_java = columns.Text()
referal_xxx = columns.Text()
class Requests(Model):
botid = columns.Text(primary_key=True)
requests = columns.BigInt()
class user_rank_table(Model):
user = columns.Text(primary_key=True)
time = columns.BigInt()
rank = columns.Integer(index=True)
class CommitByRef(CommitModelMk2):
__table_name__ = 'commits_ref_to_object'
ref = columns.Text(primary_key=True, required=True)
uuid = columns.BigInt(required=True)
branch = columns.Text(required=True)
class TestModel3(models.Model):
__connection__ = 'cassandra2'
__keyspace__ = 'db2'
id = columns.BigInt(primary_key=True)
class CommitByID(CommitModel):
__table_name__ = 'commits_id_to_timestamp_uuid'
commit_id = columns.Text(primary_key=True, required=True)
uuid = columns.BigInt(required=True)
class CommitByUuidDescending(CommitModel):
__table_name__ = 'commits_timestamp_uuid_to_id_descending'
uuid = columns.BigInt(primary_key=True,
required=True,
clustering_order='DESC')
commit_id = columns.Text(required=True)
class Resource(Model):
"""Resource Model"""
id = columns.Text(default=default_cdmi_id, index=True)
container = columns.Text(primary_key=True, required=True)
name = columns.Text(primary_key=True, required=True)
checksum = columns.Text(required=False)
size = columns.BigInt(required=False, default=0, index=True)
metadata = columns.Map(columns.Text, columns.Text, index=True)
mimetype = columns.Text(required=False)
url = columns.Text(required=False)
create_ts = columns.DateTime()
modified_ts = columns.DateTime()
file_name = columns.Text(required=False, default="")
type = columns.Text(required=False, default='UNKNOWN')
# The access columns contain lists of group IDs that are allowed
# the specified permission. If the lists have at least one entry
# then access is restricted, if there are no entries in a particular
# list, then access is granted to all (authenticated users)
read_access = columns.List(columns.Text)
edit_access = columns.List(columns.Text)
write_access = columns.List(columns.Text)
delete_access = columns.List(columns.Text)
logger = logging.getLogger('database')
@classmethod
def create(cls, **kwargs):
"""Create a new resource
When we create a resource, the minimum we require is a name
and a container. There is little chance of getting trustworthy
versions of any of the other data at creation stage.
"""
# TODO: Allow name starting or ending with a space ?
# kwargs['name'] = kwargs['name'].strip()
kwargs['create_ts'] = datetime.now()
kwargs['modified_ts'] = kwargs['create_ts']
if 'metadata' in kwargs:
kwargs['metadata'] = meta_cdmi_to_cassandra(kwargs['metadata'])
# Check the container exists
from drastic.models.collection import Collection
collection = Collection.find_by_path(kwargs['container'])
if not collection:
raise NoSuchCollectionError(kwargs['container'])
# Make sure parent/name are not in use.
existing = cls.objects.filter(container=kwargs['container']).all()
if kwargs['name'] in [e['name'] for e in existing]:
raise ResourceConflictError(merge(kwargs['container'],
kwargs['name']))
res = super(Resource, cls).create(**kwargs)
res.mqtt_publish('create')
return res
def mqtt_publish(self, operation):
payload = dict()
payload['id'] = self.id
payload['url'] = self.url
payload['container'] = self.container
payload['name'] = self.name
payload['create_ts'] = self.create_ts
payload['modified_ts'] = self.modified_ts
payload['metadata'] = meta_cassandra_to_cdmi(self.metadata)
topic = '{2}/resource{0}/{1}'.format(self.container, self.name, operation)
# Clean up the topic by removing superfluous slashes.
topic = '/'.join(filter(None, topic.split('/')))
# Remove MQTT wildcards from the topic. Corner-case: If the resource name is made entirely of # and + and a
# script is set to run on such a resource name. But that's what you get if you use stupid names for things.
topic = topic.replace('#', '').replace('+', '')
logging.info('Publishing on topic "{0}"'.format(topic))
publish.single(topic, json.dumps(payload, default=datetime_serializer))
def delete(self):
self.mqtt_publish('delete')
super(Resource, self).delete()
@classmethod
def find_by_id(cls, id_string):
"""Find resource by id"""
return cls.objects.filter(id=id_string).first()
@classmethod
def find_by_path(cls, path):
"""Find resource by path"""
coll_name, resc_name = split(path)
return cls.objects.filter(container=coll_name, name=resc_name).first()
def __unicode__(self):
return self.path()
def get_acl_metadata(self):
"""Return a dictionary of acl based on the Resource schema"""
return serialize_acl_metadata(self)
def get_container(self):
"""Returns the parent collection of the resource"""
# Check the container exists
from drastic.models.collection import Collection
container = Collection.find_by_path(self.container)
if not container:
raise NoSuchCollectionError(self.container)
else:
return container
def get_metadata(self):
"""Return a dictionary of metadata"""
return meta_cassandra_to_cdmi(self.metadata)
def get_metadata_key(self, key):
"""Return the value of a metadata"""
return decode_meta(self.metadata.get(key, ""))
def md_to_list(self):
"""Transform metadata to a list of couples for web ui"""
return metadata_to_list(self.metadata)
def path(self):
"""Return the full path of the resource"""
return merge(self.container, self.name)
def to_dict(self, user=None):
"""Return a dictionary which describes a resource for the web ui"""
data = {
"id": self.id,
"name": self.name,
"container": self.container,
"path": self.path(),
"checksum": self.checksum,
"size": self.size,
"metadata": self.md_to_list(),
"create_ts": self.create_ts,
"modified_ts": self.modified_ts,
"mimetype": self.mimetype or "application/octet-stream",
"type": self.type,
"filename": self.file_name,
"url": self.url,
}
if user:
data['can_read'] = self.user_can(user, "read")
data['can_write'] = self.user_can(user, "write")
data['can_edit'] = self.user_can(user, "edit")
data['can_delete'] = self.user_can(user, "delete")
return data
def update(self, **kwargs):
"""Update a resource"""
kwargs['modified_ts'] = datetime.now()
if 'metadata' in kwargs:
kwargs['metadata'] = meta_cdmi_to_cassandra(kwargs['metadata'])
super(Resource, self).update(**kwargs)
self.mqtt_publish('update')
return self
def user_can(self, user, action):
"""
User can perform the action if any of the user's group IDs
appear in this list for 'action'_access in this object.
"""
if user.administrator:
return True
l = getattr(self, '{}_access'.format(action))
if len(l) and not len(user.groups):
# Group access required, user not in any groups
return False
if not len(l):
# Group access not required
return True
# if groups has less than user.groups then it has had a group
# removed, it confirms presence in l
groups = set(user.groups) - set(l)
return len(groups) < len(user.groups)
class ExampleModel(models.Model):
id = columns.BigInt(primary_key=True)
created_at = columns.DateTime()
deleted = columns.Boolean(default=False)
class SuiteResultsByStartTime(SuiteResultsBase):
__table_name__ = 'suite_results_by_start_time'
start_time = columns.DateTime(primary_key=True, required=True, clustering_order='DESC')
sdk = columns.Text(primary_key=True, required=True)
uuid = columns.BigInt(primary_key=True, required=True)
class ScyllaOrderItem(Model):
order_id = columns.UUID(primary_key=True, default=uuid.uuid4)
item_id = columns.UUID(primary_key=True, default=uuid.uuid4)
price = columns.Decimal()
item_num = columns.BigInt()
class draft_user_daily_report(Model):
bucket = columns.Integer(primary_key=True)
m_date = columns.BigInt(primary_key=True)
users = columns.Integer()
class IllegalTimestampColumnModel(Model):
my_primary_key = columns.Integer(primary_key=True)
timestamp = columns.BigInt()
class ExampleModel2(models.Model):
id = columns.BigInt(primary_key=True)
class Transaction(Base):
__table_name__ = "transactions"
bucket = columns.Text(primary_key=True, partition_key=True, required=True)
hash = columns.Text(primary_key=True, required=True)
address = columns.Text(required=True)
value = columns.BigInt(required=True)
transaction_time = columns.Integer(required=True)
signature_message_fragment = columns.Text()
tag = columns.Text(required=True)
tag_index = columns.BigInt(required=True)
current_index = columns.Integer(required=True)
last_index = columns.Integer(required=True)
bundle = columns.Text(required=True)
trunk_transaction_hash = columns.Text(required=True)
branch_transaction_hash = columns.Text(required=True)
nonce = columns.Text(required=True)
min_weight_magnitude = columns.Integer(required=True)
@classmethod
def filter(cls, buckets=list(), hashes=list()):
transactions = list()
for transaction in Transaction.objects.filter(bucket__in=buckets,
hash__in=hashes):
transactions.append(transaction.as_json())
return transactions
@classmethod
def get(cls, bucket, hash):
try:
transaction = Transaction.objects.get(bucket=bucket, hash=hash)
return transaction.as_json()
except DoesNotExist:
return None
@classmethod
def from_address(cls, address):
address_meta = Address.get(address)
if not address_meta:
return list()
return Transaction.filter(
buckets=[
transaction['bucket']
for transaction in address_meta['transactions']
],
hashes=[
transaction['hash']
for transaction in address_meta['transactions']
])
@classmethod
def from_transaction_hash(cls, hash):
transaction_meta = TransactionHash.get(hash)
if not transaction_meta:
return None
return Transaction.get(transaction_meta['bucket'],
transaction_meta['hash'])
@classmethod
def from_bundle_hash(cls, bundle):
bundle_meta = Bundle.get(bundle)
if not bundle_meta:
return list()
return Transaction.filter(
buckets=[
transaction['bucket']
for transaction in bundle_meta['transactions']
],
hashes=[
transaction['hash']
for transaction in bundle_meta['transactions']
])
def as_json(self):
return {
"hash": self.hash,
"address": self.address,
"value": self.value,
"timestamp": self.transaction_time,
"signature_message_fragment": self.signature_message_fragment,
"tag": self.tag,
"tag_index": self.tag_index,
"current_index": self.current_index,
"last_index": self.last_index,
"bundle": self.bundle,
"trunk_transaction_hash": self.trunk_transaction_hash,
"branch_transaction_hash": self.branch_transaction_hash,
"nonce": self.nonce,
"min_weight_magnitude": self.min_weight_magnitude,
"persistence": True # since all txs from db are confirmed
}
class CommitByUuidDescendingMk2(CommitModelMk2):
__table_name__ = 'commits_uuid_to_object_descending'
branch = columns.Text(partition_key=True, required=True)
uuid = columns.BigInt(primary_key=True,
required=True,
clustering_order='DESC')
class TestModel3(models.Model):
__keyspace__ = 'db2'
id = columns.BigInt(primary_key=True)
class ScyllaStockItem(Model):
id = columns.UUID(primary_key=True, default=uuid.uuid4)
price = columns.Decimal()
in_stock = columns.BigInt()
class TestModel(models.Model):
Index = columns.Integer(primary_key=True)
Number = columns.BigInt()
Info = columns.Text()
class TestModel(models.Model):
__keyspace__ = 'db'
id = columns.BigInt(primary_key=True)
created_at = columns.DateTime()
deleted = columns.Boolean(default=False)
