class Organization(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), unique=True)
org_key =db.Column(db.String(100), unique=True)# some key for new users to register wth
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
whois_enabled = db.Column(db.Boolean, default=True)
ipinfo_enabled = db.Column(db.Boolean, default=True)
vt_enabled = db.Column(db.Boolean, default=False)
vt_api_key = db.Column(db.String(1000))
shodan_enabled = db.Column(db.Boolean, default=False)
shodan_api_key = db.Column(db.String(1000))
urlscan_enabled = db.Column(db.Boolean, default=False)
urlscan_api_key = db.Column(db.String(1000))
emailrep_enabled = db.Column(db.Boolean, default=False)
emailrep_api_key = db.Column(db.String(1000))
riskiq_enabled = db.Column(db.Boolean, default=False)
riskiq_username = db.Column(db.String(50))
riskiq_api_key = db.Column(db.String(50))
gn_enabled = db.Column(db.Boolean, default=False)
gn_api_key = db.Column(db.String(50))
av_enabled = db.Column(db.Boolean, default=False)
av_api_key = db.Column(db.String(100))
misp_enabled = db.Column(db.Boolean, default=False)
misp_api_key = db.Column(db.String(100))
misp_url = db.Column(db.String(1000))
hibp_api_key = db.Column(db.String(100))
hibp_enabled = db.Column(db.Boolean, default=False)
hunter_api_key = db.Column(db.String(100))
hunter_enabled = db.Column(db.Boolean, default=False)
slack_webhook = db.Column(db.String(1000))
slack_webhook_on_report_create = db.Column(db.Boolean, default=False)
slack_webhook_on_req_create = db.Column(db.Boolean, default=False)
slack_webhook_on_req_update = db.Column(db.Boolean, default=False)
class Songs(db.Model):
__tablename__ = 'Songs'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
duration = db.Column(db.Integer, nullable=False)
upload_time = db.Column(db.DateTime(timezone=True), server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), nullable=True)
def __init__(self, data):
self.name = data.get('name')
self.duration = data.get('duration')
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
self.updated_at = func.now()
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_all():
return Songs.query.all()
@staticmethod
def get_one(song_id):
return Songs.query.get(song_id)
class Consumers(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
organization = db.Column(db.Integer, db.ForeignKey('organization.id'))# add foreign key
name = db.Column(db.String(100))
email = db.Column(db.String(100))
poc = db.Column(db.String(100))
subtitle = db.Column(db.String(100))
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
user = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
report = db.Column(db.Integer, db.ForeignKey('reports.id'), nullable=True)
requirement = db.Column(db.Integer, db.ForeignKey('reports.id'), nullable=True)
comment = db.Column(db.String(100000), nullable=True)
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
indicator = db.Column(db.Integer, db.ForeignKey('indicators.id'), nullable=True)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
organization = db.Column(db.Integer, db.ForeignKey('organization.id'))# add foreign key
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
tn_api_key = db.Column(db.String(50))
role = db.Column(db.String(50), default='user')
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
new_user = db.Column(db.Boolean, default=True)
class RegularTask(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), nullable=False)
label = db.Column(db.String(120), nullable=False)
task_desc = db.Column(db.String(400), nullable=False)
time_created = db.Column(db.DateTime(), nullable=False)
end_time = db.Column(db.DateTime())
is_done = db.Column(db.Boolean(), nullable=False)
def save_task(self):
ses = db.session
ses.add(self)
ses.commit()
@classmethod
def get_task_by_user(cls, username):
return list(
map(lambda x: x.serialize,
cls.query.filter_by(username=username).all()))
@classmethod
def get_task_by_user_and_id(cls, username, id):
return cls.query.filter_by(username=username, id=id).first()
@classmethod
def get_task_by_user_and_id_json(cls, username, id):
return list(
map(lambda x: x.serialize,
cls.query.filter_by(username=username, id=id).all()))
def mark_as_done(self):
self.is_done = not self.is_done
db.session.commit()
def delete_task(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.commit()
@property
def serialize(self):
return {
'id': self.id,
'label': self.label,
'task_desc': self.task_desc,
'username': self.username,
'is_done': self.is_done,
'time_created': self.time_created.isoformat(),
'end_time': self.end_time.isoformat()
}
class Reports(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
title = db.Column(db.String(500))
content = db.Column(db.String(100000))
creator = db.Column(db.String(100))
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
friendly_id = db.Column(db.String(100))
is_archived = db.Column(db.Boolean, default=False)
#tags = db.Column(db.String(1000))
# linked_reqs = db.Column(db.String(1000))
tlp = db.Column(db.String(100))
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
sku = db.Column(db.String(12), unique=True)
name = db.Column(db.String(64))
discription = db.Column(db.Text, nullable=True)
price = db.Column(db.Numeric(10, 2))
image = db.Column(db.Text, nullable=True)
created = db.Column(db.DateTime(timezone=True), server_default=func.now())
updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
def __str__(self):
return f"{self.id}-{self.name}"
class Energy(db.Model):
__tablename__ = "energy"
id = db.Column(db.Integer, primary_key=True)
energy = db.Column(db.Float(64))
measurement_time = db.Column(db.DateTime(), default=sql.func.now())
created = db.Column(
db.DateTime(),
default=sql.func.now() # use db to set timestamp
)
updated = db.Column(db.DateTime(),
default=sql.func.now(),
onupdate=sql.func.now())
asset_id = Column(Integer, ForeignKey('asset.id'))
class FlattenArray(db.Model):
"""
Here the table name is defined, the id field is created as
primary key, the array field es created to save de flatten array
and the created at field and updated_at filed are created
"""
__tablename__ = 'flatten_array'
id = db.Column(db.Integer, primary_key=True)
array = db.Column(db.String(500))
created_at = db.Column(db.DateTime(), default=datetime.datetime.now())
updated_at = db.Column(db.DateTime(),
onupdate=datetime.datetime.now(),
default=datetime.datetime.now())
class Podcasts(db.Model):
__tablename__ = 'Podcasts'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
duration = db.Column(db.Integer, nullable=False)
upload_time = db.Column(db.DateTime(timezone=True), server_default=func.now())
host = db.Column(db.String(100), nullable=False)
_participants = db.Column('participants', db.Text, nullable=True, )
updated_at = db.Column(db.DateTime(timezone=True), nullable=True)
@hybrid_property
def participants(self):
if self._participants:
return self._participants.split(',')
@participants.setter
def participants(self, participants):
if participants:
self._participants = ",".join(participants)
else:
self._participants = None
def __init__(self, data):
self.name = data.get('name')
self.duration = data.get('duration')
self.host = data.get('host')
self.participants = data.get('participants')
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
setattr(self, key, item)
self.updated_at = func.now()
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_all():
return Podcasts.query.all()
@staticmethod
def get_one(podcast_id):
return Podcasts.query.get(podcast_id)
class Requirements(db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
friendly_id = db.Column(db.String(100), unique=True)
title = db.Column(db.String(500))
owner = db.Column(db.String(100))
priority = db.Column(db.String(100))
summary = db.Column(db.String(10000))
gaps = db.Column(db.String(10000))
collection_requirements = db.Column(db.String(10000))
deliverables = db.Column(db.String(10000))
time_requirement = db.Column(db.Date())
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
creator = db.Column(db.String(100))
is_archived = db.Column(db.Boolean, default=False)
class SuperAdmin(db.Model):
__bind_key__ = 'super-admins'
__tablename__ = 'super-admins'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
pwdhash = db.Column(db.String(54))
is_active = db.Column(db.Boolean(), default=True)
is_staff = db.Column(db.Boolean(), default=True)
is_admin = db.Column(db.Boolean(), default=True)
is_super_admin = db.Column(db.Boolean(), default=True)
created_on = db.Column(db.DateTime(), default=datetime.datetime.now())
def __init__(self, username, name, email, password):
self.username = username.lower()
self.name = name.lower()
self.email = email.lower()
self.set_password(password)
def set_password(self, password):
self.pwdhash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.pwdhash, password)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'))
username = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
email_confirmed_at = db.Column(db.DateTime())
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
class Asset(db.Model):
__tablename__ = "asset"
id = db.Column(db.Integer, primary_key=True)
role = db.Column(db.String(32))
manufacturer = db.Column(db.String(32))
model = db.Column(db.String(32))
serial_number = db.Column(db.String(32))
latitude = db.Column(db.Float(64))
longitude = db.Column(db.Float(64))
energy_unit = db.Column(db.String(32))
is_accumulated = db.Column(db.Boolean)
created = db.Column(db.DateTime(), default=sql.func.now())
updated = db.Column(db.DateTime(),
default=sql.func.now(),
onupdate=sql.func.now())
measurements = relationship(Energy)
class Transaction(db.Model):
__tablename__ = "transaction"
transaction_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("user.user_id"),
nullable=False)
pool_id = db.Column(db.Integer,
db.ForeignKey("pool.pool_id"),
nullable=True)
pool_hash = db.Column(db.String(100),
db.ForeignKey("pool.pool_hash"),
nullable=True)
transaction_amount_buy = db.Column(db.Float(precision=5, asdecimal=True),
nullable=True)
transaction_amount_sell = db.Column(db.Float(precision=5, asdecimal=True),
nullable=True)
transaction_is_deposit = db.Column(db.Boolean, nullable=True)
transaction_wallet_to = db.Column(db.String(100), nullable=True)
transaction_wallet_from = db.Column(db.String(100), nullable=True)
transaction_status = db.Column(
db.Integer, default=0
) # Determines if this transaction is win/loss 0 = in progress 1 = win -1 = loss 2 = deposited
transaction_tcreate = db.Column(db.DateTime(timezone=True),
default=func.now())
transaction_tmodified = db.Column(db.DateTime(timezone=True),
default=func.now(),
onupdate=func.now())
# pool = db.relationship(
# "Pool",
# backref="transaction",
# primaryjoin="Transaction.pool_id == Pool.pool_id",
# )
user = db.relationship(
"User",
backref="transaction",
primaryjoin="Transaction.user_id == User.user_id",
)
# Transaction status
TRANSACTION_IN_PROGRESS = 0
TRANSACTION_POOL_WIN = 1
TRANSACTION_POOL_LOSS = -1
TRANSACTION_IS_DEPOSIT = 2
TRANSACTION_CANCELLED = 3
class Report(db.Model):
__tablename__ = 'report'
id = db.Column(db.Integer(), primary_key=True, comment='主键，自增')
case_names = db.Column(db.String(128), nullable=True, comment='用例的名称集合')
read_status = db.Column(db.String(16), nullable=True, comment='阅读状态')
performer = db.Column(db.String(16), nullable=True, comment='执行者')
project_id = db.Column(db.String(16), nullable=True)
create_time = db.Column(db.DateTime(), index=True, default=datetime.now)
class Show(db.Model):
__tablename__ = 'Show'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime(), nullable=False)
venue_id = db.Column(db.Integer, db.ForeignKey('Venue.id'), nullable=False)
artist_id = db.Column(db.Integer,
db.ForeignKey('Artist.id'),
nullable=False)
class Event(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
dt = db.Column(db.DateTime(), default=datetime.utcnow)
event_type = db.Column(db.String(128), nullable=False)
payload = db.Column(db.Text)
state = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Event {id}>'.format(id=self.id)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False, unique=True)
email = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(100), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(),
default=datetime.utcnow,
onupdate=datetime.utcnow)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f'<{self.id}:{self.username}>'
class Views(db.Model):
__tablename__ = 'views'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, nullable=False)
type = db.Column(db.String(10), nullable=False)
obj_id = db.Column(db.Integer, nullable=False)
created = db.Column(db.DateTime(), nullable=False, default=datetime.now())
def __init__(self, user, type, obj):
self.user_id = user
self.type = type
self.obj_id = obj
class Consulta(db.Model):
# table name
__tablename__ = 'consulta'
IdConsulta = db.Column(db.Integer(), primary_key=True, autoincrement=True)
IdObraSocial = db.Column(db.Integer(), nullable=False)
IdGestionturno = db.Column(db.Integer(), nullable=False)
Fecha = db.Column(db.DateTime(), nullable=False)
IdPaciente = db.Column(db.Integer(), nullable=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Show(db.Model):
__tablename__ = 'show'
id = db.Column(db.Integer, primary_key=True)
venue_id = db.Column(db.Integer, db.ForeignKey(Venue.id), nullable=False)
artist_id = db.Column(db.Integer, db.ForeignKey(Artist.id), nullable=False)
start_time = db.Column(db.DateTime())
@hybrid_property
def start_time_pretty(self):
# return self.shows_count['upcoming']
return format_datetime(self.start_time)
class IssueHistory(db.Model):
__tablename__ = 'issue_history'
id = db.Column(db.Integer, primary_key=True)
issue_id = db.Column(db.Integer,
db.ForeignKey('issues.id'),
nullable=False)
status_id = db.Column(db.Integer, db.ForeignKey('statuses.id'))
create_time = db.Column(db.DateTime(), default=datetime.utcnow)
reason = db.Column(db.Text)
note = db.Column(db.Text)
issue = db.relationship('Issue')
status = db.relationship('Status')
class USSDModel(db.Model):
__tablename__ = 'farmers'
id = db.Column(db.Integer(), primary_key=True)
sessionID = db.Column(db.String(120), nullable=False)
phoneNumber = db.Column(db.String(120), nullable=False)
name = db.Column(db.String(120), nullable=False)
county = db.Column(db.String(120), nullable=False)
location = db.Column(db.String(120), nullable=False)
products = db.Column(db.String(), nullable=False)
ready = db.Column(db.String(120), nullable=False)
quantity = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(timezone=True), server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
# CREATE
def create_record(self):
db.session.add(self)
db.session.commit()
@classmethod
def fetch_all(cls):
return cls.query.order_by(cls.time_created.desc()).all()
class Phone(db.Model):
__tablename__ = 'unique_phones'
id = db.Column(db.Integer(), primary_key=True)
sessionID = db.Column(db.String(120), nullable=False)
phoneNumber = db.Column(db.String(120), nullable=False)
time_created = db.Column(db.DateTime(timezone=True), server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
# CREATE
def create_record(self):
db.session.add(self)
db.session.commit()
@classmethod
def fetch_all(cls):
return cls.query.order_by(cls.time_created.desc()).all()
@classmethod
def fetch_one(cls,id):
rec=cls.query.filter_by(sessionID = id).first()
if rec:
return True
else:
return False
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
phone = db.Column(db.String(100), nullable=True)
show_whats = db.Column('show_whats',
db.Integer(),
nullable=False,
default='1')
can_email = db.Column('can_email',
db.Integer(),
nullable=False,
default='1')
status = db.Column(db.String(100), nullable=True)
active = db.Column('is_active', db.Integer(), nullable=False, default='1')
last_login = db.Column(db.DateTime())
created = db.Column(db.DateTime(), nullable=False, default=datetime.now())
last_modified = db.Column(db.DateTime(),
nullable=False,
default=datetime.now())
class Persona(db.Model):
# table name
__tablename__ = 'persona'
IdPersona = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Apellido = db.Column(db.String(), nullable=False)
Celular = db.Column(db.String(), nullable=False)
Direccion = db.Column(db.String(), nullable=False)
Dni = db.Column(db.String(), nullable=False)
Email = db.Column(db.String(), nullable=False)
FechaNacimiento = db.Column(db.DateTime(), nullable=False)
Nombre = db.Column(db.String(), nullable=False)
Tel = db.Column(db.String(), nullable=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Expense(db.Model):
__tablename__ = "expense"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
item = db.Column(db.String(100), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
date = db.Column(db.DateTime(), default=datetime.utcnow())
price = db.Column(db.Integer, nullable=False, default=0)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, item, quantity, price):
self.item = item
self.quantity = quantity
self.price = price
self.date = datetime.utcnow()
def __str__(self):
return f"{self.item} and {self.date}"
class Issue(db.Model):
__tablename__ = 'issues'
id = db.Column(db.Integer, primary_key=True)
status_id = db.Column(db.Integer, db.ForeignKey('statuses.id'), default=2)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
customer_id = db.Column(db.Integer, nullable=False)
body = db.Column(db.Text, nullable=False)
create_data = db.Column(db.DateTime(), default=datetime.utcnow)
rating = db.Column(db.Integer)
management_id = db.Column(db.Integer)
contractor = db.Column(db.String(256))
contractor_id = db.Column(db.Integer)
status = db.relationship('Status')
category = db.relationship('Category')
def __repr__(self):
return '<Issue {id}>'.format(id=self.id)
