class Recordings(Base, CreationMixin, TimeStampMixin):
__tablename__ = 'recordings'
id = Column(UUIDType(binary=False), primary_key=True)
title = Column(UnicodeText, nullable=False)
url = Column(UnicodeText, nullable=False)
recorded_datetime = Column(DateTime, nullable=False)
organization_id = Column(ForeignKey('organizations.id'))
def to_dict(self):
resp = super(Recordings, self).to_dict()
resp.update(
title=self.title,
url=self.url,
recorded_datetime=str(self.recorded_datetime),
organization_id=self.organization_id,
)
return resp
@classmethod
def get_by_organization_id(cls, id):
with transaction.manager:
recordings = DBSession.query(
Recordings,
).filter(
Recordings.organization_id == id,
).all()
return recordings
class File(db.Model):
"""
A File.
"""
__tablename__ = 'files'
file_location = db.Column(db.Text, unique=False, nullable=False,
primary_key=True)
file_name = db.Column(db.Text, unique=False, nullable=False)
file_id = db.Column(UUIDType(binary=False), primary_key=True)
is_duplicate = db.Column(db.Boolean, default=False, nullable=False)
is_ocrable = db.Column(db.Boolean, default=False, nullable=False)
@property
def serialize(self):
"""
Transforms the object into a json object.
This will be used at the front-end, so dont include
sensitive information in the json object.
"""
return {
'file_location': self.file_location,
'file_name': self.file_name,
'is_duplicate': self.is_duplicate,
'is_ocrable': self.is_ocrable
}
@property
def checkValid(self):
pass
class PlaylistAssignments(Base, CreationMixin, TimeStampMixin):
__tablename__ = 'playlist_assignments'
id = Column(UUIDType(binary=False), primary_key=True)
playlist_id = Column(ForeignKey('playlists.id'))
recording_id = Column(ForeignKey('recordings.id'), nullable=False)
@classmethod
def delete_by_playlist_id_and_recording_id(cls, pid, rid):
success = False
with transaction.manager:
playlist = DBSession.query(
PlaylistAssignments,
).filter(
PlaylistAssignments.playlist_id == pid,
PlaylistAssignments.recording_id == rid,
).first()
if playlist is not None:
DBSession.remove(playlist)
transaction.commit()
success = True
return success
def to_dict(self):
resp = super(PlaylistAssignments, self).to_dict()
resp.update(
playlist_id=self.playlist_id,
recording_id=self.recording_id,
)
return resp
class People(Base, CreationMixin, TimeStampMixin):
__tablename__ = 'people'
id = Column(UUIDType(binary=False), primary_key=True)
first = Column(UnicodeText, nullable=False)
last = Column(UnicodeText, nullable=False)
address_0 = Column(UnicodeText, nullable=False)
address_1 = Column(UnicodeText, nullable=False)
city = Column(UnicodeText, nullable=False)
state = Column(UnicodeText, nullable=False)
zipcode = Column(UnicodeText, nullable=False)
phone = Column(UnicodeText, nullable=False)
fax = Column(UnicodeText, nullable=False)
primary_website = Column(UnicodeText, nullable=False)
secondary_website = Column(UnicodeText, nullable=False)
# these should probably be brough out into a seperate table as
# many to one so we don't have to keep adding columns ...
twitter = Column(UnicodeText, nullable=False)
facebook = Column(UnicodeText, nullable=False)
instagram = Column(UnicodeText, nullable=False)
periscope = Column(UnicodeText, nullable=False)
user_id = Column(ForeignKey('users.id'), nullable=False)
organization_id = Column(ForeignKey('organizations.id'), nullable=True)
def to_dict(self):
resp = super(People, self).to_dict()
resp.update(
first=self.first,
address_0=self.address_0,
address_1=self.address_1,
city=self.city,
state=self.state,
zipcode=self.zipcode,
phone=self.phone,
fax=self.fax,
primary_website=self.primary_website,
secondary_website=self.secondary_website,
# see note on definitions
twitter=self.twitter,
facebook=self.facebook,
instagram=self.instagram,
periscope=self.periscope,
user_id=self.user_id,
organization_id=self.organization_id,
)
return resp
@classmethod
def get_by_organization_id(cls, id):
with transaction.manager:
people = DBSession.query(
People,
).filter(
People.organization_id == id,
).all()
return people
class User(UserMixin, db.Model):
def __init__(self, id, first_name='', uuid='', practice_uuid='',
practice_name='', practice_id='', practice_admin='', invoice_layout = '', namaf_profession = '', practice_role='', practice_folder_id='', active=True):
self.uuid = uuid
self.first_name = first_name
self.practice_uuid = practice_uuid
self.practice_name = practice_name
self.practice_id = practice_id
self.practice_admin = practice_admin
self.invoice_layout = invoice_layout
self.namaf_profession = namaf_profession
self.practice_role = practice_role
self.id = id
self.practice_folder_id = practice_folder_id
self.active = active
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
uuid_bin = db.Column(UUIDType(binary=False))
uuid_text = db.Column(db.String(36), nullable=False)
title = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(255), nullable=False)
second_name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(100), unique=True)
current_practice_uuid = db.Column(db.String(36), nullable=True)
current_practice_role = db.Column(db.DateTime, nullable=False)
created_on = db.Column(db.DateTime(),default=datetime.utcnow)
last_active = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow)
class Device(db.Model):
__tablename__ = 'device'
baked_query = db.bakery(lambda session: session.query(Device))
uuid = db.Column(
UUIDType(binary=True),
nullable=False,
primary_key=True,
unique=True,
)
name = db.Column(db.String(128), nullable=False)
registered_at = db.Column(ArrowType, default=arrow.utcnow)
owner_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
device_logs = db.relationship(DeviceLog,
backref='device',
cascade='all, delete-orphan')
device_tasks = db.relationship(DeviceTask,
backref='device',
cascade='all, delete-orphan')
def upgrade():
bind = op.get_bind()
session = db.Session(bind=bind)
for table_name, model in models.items():
# this script adds missing uuid columns
if has_uuid_column(table_name, bind):
continue
with op.batch_alter_table(table_name) as batch_op:
batch_op.add_column(
sa.Column(
"uuid",
UUIDType(binary=True),
primary_key=False,
default=uuid4,
), )
add_uuids(model, table_name, session)
# add uniqueness constraint
with op.batch_alter_table(table_name) as batch_op:
# batch mode is required for sqllite
batch_op.create_unique_constraint(f"uq_{table_name}_uuid",
["uuid"])
# add UUID to Dashboard.position_json; this function is idempotent
# so we can call it for all objects
slice_uuid_map = {
slc.id: slc.uuid
for slc in session.query(models["slices"]).options(
load_only("id", "uuid")).all()
}
update_dashboards(session, slice_uuid_map)
class CveTag(BaseModel):
__tablename__ = "cves_tags"
tags = db.Column(JSONB)
# Relationships
user_id = db.Column(UUIDType(binary=False), db.ForeignKey("users.id"))
user = db.relationship("User", back_populates="cve_tags")
cve_id = db.Column(UUIDType(binary=False), db.ForeignKey("cves.id"))
# Index
__table_args__ = (db.Index("ix_cves_tags", tags, postgresql_using="gin"), )
def __repr__(self):
return "<CveTag {}>".format(self.id)
class FormInstance(db.Model):
id = db.Column(UUIDType(binary=False),
primary_key=True,
default=generate_uuid)
template = db.Column(
EncryptedType(db.String, SECRET_KEY, AesEngine, 'pkcs5'))
created_at = db.Column(db.DateTime)
class Task(BaseModel):
__tablename__ = "tasks"
key = db.Column(db.String(), nullable=False)
status = db.Column(db.Enum(StatusType),
default=StatusType.pending,
nullable=False)
previous = db.Column(JSONBType, default=[])
# Relationship
workflow_id = db.Column(UUIDType(binary=False),
db.ForeignKey("workflows.id"),
nullable=False)
workflow = db.relationship("Workflow",
backref=db.backref("tasks", lazy=True))
def __repr__(self):
return f"<Task {self.key}>"
def to_dict(self):
d = super().to_dict()
d.update({
"key": self.key,
"status": self.status.value,
"task": self.id,
"previous": self.previous,
})
return d
class WorkingFile(db.Model, BaseMixin, SerializerMixin):
"""
Describes the file related to the work done on a given task. It is
used as source of output files published for a given entity.
"""
shotgun_id = db.Column(db.Integer(), index=True)
name = db.Column(db.String(250))
description = db.Column(db.String(200))
comment = db.Column(db.Text())
revision = db.Column(db.Integer())
size = db.Column(db.Integer())
checksum = db.Column(db.Integer())
path = db.Column(db.String(400))
data = db.Column(JSONB)
task_id = db.Column(
UUIDType(binary=False),
db.ForeignKey("task.id"),
index=True
)
entity_id = db.Column(
UUIDType(binary=False),
db.ForeignKey("entity.id"),
index=True
)
person_id = \
db.Column(UUIDType(binary=False), db.ForeignKey("person.id"))
software_id = \
db.Column(UUIDType(binary=False), db.ForeignKey("software.id"))
outputs = relationship(
"OutputFile",
back_populates="source_file"
)
__table_args__ = (
db.UniqueConstraint(
"name",
"task_id",
"entity_id",
"revision",
name="working_file_uc"
),
)
def __repr__(self):
return "<WorkingFile %s>" % self.id
class LabelEvent(db.Model):
__tablename__ = 'label_event'
id = db.Column(
UUIDType(binary=False),
server_default=db.func.uuid_generate_v4(),
primary_key=True
)
data_id = db.Column(
UUIDType(binary=False),
db.ForeignKey(Dataset.id, ondelete='CASCADE'),
nullable=False,
index=True,
)
data = db.relationship(Dataset, backref='label_events')
label_id = db.Column(
UUIDType(binary=False),
db.ForeignKey('problem_label.id', ondelete='CASCADE'),
nullable=False,
index=True,
)
label = db.relationship(
'ProblemLabel'
)
label_matches = db.Column(
db.Boolean(),
nullable=True
)
created_at = db.Column(
db.DateTime,
server_default=db.func.now(),
nullable=False
)
created_by = db.Column(
db.Unicode(255),
nullable=False,
)
def __repr__(self):
return '<LabelEvent label=%r>' % self.label
class Dispatchers(Base, CreationMixin, TimeStampMixin):
__tablename__ = 'dispatchers'
scraper_id = Column(
UUIDType(binary=False),
ForeignKey('scrapers.id'),
nullable=False,
)
current_job_id = Column(
UUIDType(binary=False),
ForeignKey('jobs.id'),
nullable=True,
)
last_callin_datetime = Column(DateTime, nullable=True)
up_time = Column(Integer, nullable=False)
idle = Column(Boolean, nullable=False)
dispatch_count = Column(Integer, nullable=False)
workers = relationship('Workers', backref='dispatcher', lazy='joined')
@classmethod
def update_status(self,
dispatcher_id,
last_callin_datetime,
up_time,
idle=True):
with transaction.manager:
dispatcher = DBSession.query(Dispatchers, ).filter(
Dispatchers.id == dispatcher_id, ).first()
if dispatcher is not None:
dispatcher.last_callin_datetime = last_callin_datetime
dispatcher.up_time = up_time
dispatcher.idle = idle
transaction.commit()
return dispatcher
def to_dict(self):
resp = super(Dispatchers, self).to_dict()
current_job = None
if self.current_job:
current_job = self.current_job.to_dict()
current_job_run = None
resp.update(
scraper=self.scraper.to_dict(),
wrokers=[w.to_dict() for w in self.workers],
current_job=current_job,
)
return resp
class Feature(db.Model):
"""Model for tracking feature requests."""
__tablename__ = "home_feature"
REQUEST_STATUS_PENDING = 0
REQUEST_STATUS_APPROVED = 1
REQUEST_STATUS_REJECTED = 2
REQUEST_STATUS_ONGOING = 3
REQUEST_STATUS_RESCHEDULED = 4
REQUEST_STATUS_COMPLETED = 5
REQUEST_STATUS = ((REQUEST_STATUS_PENDING,
'Pending'), (REQUEST_STATUS_APPROVED, 'Approved'),
(REQUEST_STATUS_REJECTED,
'Rejected'), (REQUEST_STATUS_ONGOING, 'Ongoing'),
(REQUEST_STATUS_RESCHEDULED,
'Rescheduled'), (REQUEST_STATUS_COMPLETED, 'Completed'))
PRODUCT_AREA_POLICIES = 0
PRODUCT_AREA_BILLING = 1
PRODUCT_AREA_CLAIMS = 2
PRODUCT_AREA_REPORTS = 3
PRODUCT_AREAS = ((PRODUCT_AREA_POLICIES,
'Policies'), (PRODUCT_AREA_BILLING, 'Billing'),
(PRODUCT_AREA_CLAIMS, 'Claims'), (PRODUCT_AREA_REPORTS,
'Reports'))
id = db.Column(UUIDType(binary=False),
primary_key=True,
unique=True,
default=uuid.uuid4)
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.Text(), nullable=False)
client = db.Column(db.ForeignKey('home_client.id'), nullable=False)
client_priority = db.Column(db.Integer, nullable=False)
target_date = db.Column(db.Date, nullable=False)
product_area = db.Column(ChoiceType(PRODUCT_AREAS, impl=db.Integer()),
default=PRODUCT_AREA_POLICIES)
requested_by = db.Column(db.ForeignKey('auth_user.id'), nullable=False)
request_status = db.Column(ChoiceType(REQUEST_STATUS, impl=db.Integer()),
default=REQUEST_STATUS_PENDING)
date_added = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return "{}_{}".format(self.shortened_title, self.shortened_id)
@property
def shortened_title(self):
"""Get shortened version title."""
return str(self.title)[:20]
@property
def shortened_id(self):
"""Get shortened version of id."""
return str(self.id)[-8:]
class Site(db.Model, Timestamp):
id = db.Column(db.Integer, primary_key=True)
uuid = db.Column(UUIDType(binary=False),
default=uuid.uuid4,
nullable=False)
url = db.Column(db.String(120), unique=True, nullable=False)
origins = db.Column(ScalarListType())
def upgrade():
"""Upgrade database."""
op.create_table(
'rdm_parents_community',
sa.Column(
'community_id',
UUIDType(),
nullable=False
),
sa.Column(
'record_id',
UUIDType(),
nullable=False
),
sa.Column(
'request_id',
UUIDType(),
nullable=True
),
sa.ForeignKeyConstraint(
['community_id'],
['communities_metadata.id'],
name=op.f(
'fk_rdm_parents_community_community_id_communities_metadata'),
ondelete='CASCADE'
),
sa.ForeignKeyConstraint(
['record_id'],
['rdm_parents_metadata.id'],
name=op.f(
'fk_rdm_parents_community_record_id_rdm_parents_metadata'),
ondelete='CASCADE'
),
sa.ForeignKeyConstraint(
['request_id'],
['request_metadata.id'],
name=op.f(
'fk_rdm_parents_community_request_id_request_metadata'),
ondelete='SET NULL'
),
sa.PrimaryKeyConstraint(
'community_id',
'record_id',
name=op.f('pk_rdm_parents_community')
)
)
class TransactionRecord(db.Model):
__table__ = "transaction_record"
id = db.Column(db.Integer, primary_key=True)
transaction_id = db.Column(UUIDType(), db.ForeignKey("transaction.id"))
field = db.Column(db.String(32), doc=_("Field"))
before = db.Column(db.PickleType, doc=_('Original Value'))
after = db.Column(db.PickleType, doc=_('New Value'))
transactions = db.relationship(Transaction, )
class User(CreatedAtMixin, UpdatedAtMixin, Base):
id = Column(UUIDType(), default=uuid.uuid4, primary_key=True)
name = Column(String(50), nullable=False)
__tablename__ = 'users'
def __repr__(self):
return "<User(id='%s', name='%s')>" % (self.id, self.name)
class OrderPayment(Model):
__tablename__ = 'order_payments'
order_id = Column(UUIDType(binary=False),
ForeignKey('order.id'),
nullable=False)
payment_details = Column(JSONB)
status = Column(order_payment_status)
class DriverDeposit(Model):
__tablename__ = "driver_deposit"
driver_id = Column(UUIDType(binary=False), ForeignKey('drivers.id'))
amount = Column(Float(10))
def __repr__(self):
return f'DriverDeposit: {self.id}'
class UserAppData(db.Model):
'''
the user app data model tracks the version of the app installed @ the client
'''
user_id = db.Column('user_id', UUIDType(binary=False), db.ForeignKey("user.user_id"), primary_key=True, nullable=False)
app_ver = db.Column(db.String(40), primary_key=False, nullable=False)
update_at = db.Column(db.DateTime(timezone=False), server_default=db.func.now(), onupdate=db.func.now())
completed_tasks = db.Column(db.JSON)
class UserTaskResults(db.Model):
'''
the user task results
'''
user_id = db.Column('user_id', UUIDType(binary=False), db.ForeignKey("user.user_id"), primary_key=True, nullable=False)
task_id = db.Column(db.String(40), nullable=False, primary_key=True)
results = db.Column(db.JSON)
update_at = db.Column(db.DateTime(timezone=False), server_default=db.func.now(), onupdate=db.func.now())
class User(db.Model):
__tablename__ = "users"
id = db.Column('id', UUIDType(binary=False), primary_key=True)
username = db.Column('username', db.Unicode, unique=True)
password = db.Column('password', db.Unicode)
first_name = db.Column('first_name', db.Unicode)
last_name = db.Column('last_name', db.Unicode)
class AuthApi(db.Model, AuditEntity):
__tablename__ = 'xf_auth_api'
internal = db.Column(UUIDType(binary=False),
primary_key=True,
default=uuid.uuid4)
client_secret = db.Column(db.String(), nullable=False, unique=True)
api_key = db.Column(db.String(), nullable=False, unique=True)
class ProjectionRecord(Base):
__tablename__ = "projections"
# Projection ID.
projection_id = Column(UUIDType(), primary_key=True)
# State of the projection (serialized dict, possibly encrypted).
state = Column(Text())
class PublicationImage(db.Model): # type: ignore
"""Images for publications."""
id = db.Column(UUIDType(binary=False), primary_key=True, default=uuid4)
url = db.Column(db.String, nullable=False)
publication_id = db.Column(db.Integer,
db.ForeignKey('publication.id'),
nullable=False)
class GuestUser(db.Model):
id = db.Column(UUIDType(binary=False),
default=uuid.uuid4,
primary_key=True)
password = db.Column(PasswordType(schemes=['bcrypt']), nullable=False)
name = db.Column(db.String, nullable=False)
corporation_id = db.Column(db.Integer, nullable=True)
corporation = db.Column(db.String, nullable=True)
alliance_id = db.Column(db.Integer, nullable=True)
alliance = db.Column(db.String, nullable=True)
guest_pass_id = db.Column(UUIDType(binary=False),
db.ForeignKey('guest_pass.id'))
banned = db.Column(db.Boolean, default=False)
last_ip = db.Column(IPAddressType, default=u'127.0.0.1')
last_login_on = db.Column(ArrowType, default=arrow.utcnow)
created_on = db.Column(ArrowType, default=arrow.utcnow, nullable=False)
updated_on = db.Column(ArrowType, default=arrow.utcnow, nullable=False)
class Gym(Base):
__tablename__ = 'gym'
id = Column(UUIDType(binary=False), primary_key=True, default=uuid.uuid4)
name = Column(String(100))
city = Column(String(100))
MAC_address = Column(String(17), unique=True)
spotify_playlist_id = Column(String(50))
class MalwareMeta(Base):
__tablename__ = 'malpedia_malware_meta'
uuid = Column(UUIDType(), primary_key=True, index=True)
name = Column(Text, index=True)
commonname = Column(Text)
description = Column(Text)
updated = Column(Text)
class Reference(Base):
"""symbol coordinates of spans linked with entity class and, possible, entity"""
__tablename__ = 'references'
reference_id = Column(UUIDType(binary=False), server_default=text("uuid_generate_v4()"), primary_key=True)
markup = Column(UUIDType(binary=False), ForeignKey('markups.markup_id'))
markup_rel = relationship(Markup)
# class of ontology
entity_class = Column(String(40))
# example of class of ontology
entity = Column(UUIDType(binary=False), ForeignKey('entities.entity_id'))
# symbol coordinates
start_offset = Column(Integer())
end_offset = Column(Integer())
length_offset = Column(Integer())
# outer id (for example - in Open Corpora)
outer_id = Column(Integer())
