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)