class Album(db.Model):
__tablename__ = "albums"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255), nullable=False)
artist = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text(), nullable=False)
genre = db.Column(db.String(255), nullable=False)
image = db.Column(db.Text(), nullable=False)
release_date = db.Column(db.DateTime(), nullable=False)
user_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
index=True,
nullable=False)
slug = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, title, artist, description, genre, image, release_date,
user_id):
self.title = title
self.artist = artist
self.description = description
self.genre = genre
self.image = image
self.release_date = release_date
self.user_id = user_id
class Objective(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.Text(), nullable=False)
description = db.Column(db.Text(), default='')
product_id = db.Column(db.Integer(),
db.ForeignKey('product.id', ondelete='CASCADE'),
index=True)
targets = db.relationship('Target',
backref=db.backref('objective', lazy='joined'),
passive_deletes=True)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
def get_owner(self):
return self.product.product_group.name
def __repr__(self):
return '<SLO {} | {}>'.format(self.product.name, self.title)
class Product(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False, index=True)
email = db.Column(db.String(120), nullable=True)
slug = db.Column(db.String(120), unique=True, nullable=False, index=True)
product_group_id = db.Column(db.Integer(),
db.ForeignKey('product_group.id'),
nullable=False)
objectives = db.relationship('Objective',
backref=db.backref('product', lazy='joined'),
lazy='dynamic',
passive_deletes=True)
indicators = db.relationship('Indicator',
backref=db.backref('product', lazy='joined'),
lazy='dynamic',
passive_deletes=True)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
def get_owner(self):
return self.product_group.name
def __repr__(self):
return '<Product {}>'.format(self.name)
class Tour(db.Model):
__tablename__ = "tours"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255), nullable=False)
artist = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text(), nullable=False)
genre = db.Column(db.String(255), nullable=False)
start_date = db.Column(db.DateTime(), nullable=False)
end_date = db.Column(db.DateTime(), nullable=False)
user_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
index=True,
nullable=False)
slug = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, title, artist, description, genre, start_date, end_date,
user_id):
self.title = title
self.artist = artist
self.description = description
self.genre = genre
self.start_date = start_date
self.end_date = end_date
self.user_id = user_id
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
avatar_url = db.Column(db.String(80), nullable=True)
github_id = db.Column(db.Integer(), nullable=True)
tasks = db.relationship('Task', backref='user', lazy=True)
def __init__(self, username, avatar_url, github_id):
self.username = username
self.avatar_url = avatar_url
self.github_id = github_id
@staticmethod
def find_or_create_from_token(access_token):
data = GitHub.get_user_from_token(access_token)
"""Find existing user or create new User instance"""
instance = User.query.filter_by(username=data['login']).first()
if not instance:
instance = User(data['login'], data['avatar_url'], data['id'])
db.session.add(instance)
db.session.commit()
return instance
def __repr__(self):
return "<User: {}>".format(self.username)
class Target(db.Model):
id = db.Column(db.Integer(), primary_key=True)
target_from = db.Column(db.Float(), nullable=True)
target_to = db.Column(db.Float(), nullable=True)
indicator_id = db.Column(db.Integer(),
db.ForeignKey('indicator.id'),
nullable=False)
objective_id = db.Column(db.Integer(),
db.ForeignKey('objective.id', ondelete='CASCADE'),
nullable=False)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
__table_args__ = (db.UniqueConstraint(
'indicator_id',
'objective_id',
name='target_indicator_id_objective_id_key'), )
def get_owner(self):
return self.objective.product.product_group.name
def __repr__(self):
return '<Target {} | {} - {}>'.format(self.objective.product.name,
self.target_from, self.target_to)
class Employee(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(), unique=True, nullable=False)
completed_task = db.Column(db.Integer(), default=0, nullable=False)
tasks = db.relationship("Task",
secondary=task_empl,
backref=db.backref("empls"),
lazy="dynamic")
class Movies(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
image_url = db.Column(db.String(length=300))
title = db.Column(db.String(length=100))
views = db.Column(db.String(length=10))
good = db.Column(db.Integer())
auth = db.Column(db.String(length=30))
vocation = db.Column(db.String(length=30))
video_url = db.Column(db.String(length=300), default='')
class Foo(db.Model):
"A foo."
__tablename__ = 'foo'
id = db.Column('id', db.Integer(), primary_key=True)
bar = db.Column('bar', db.Integer(), nullable=False)
baz = db.Column('baz', db.Text(), nullable=False)
created_ts = db.Column(db.DateTime(timezone=True),
server_default=text('NOW()'))
basket_id = db.Column(db.Integer, db.ForeignKey('basket.id'))
class Task(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(), nullable=False)
description = db.Column(db.String(), nullable=False)
created_at = db.Column(db.String(), default=datetime.utcnow())
deadline = db.Column(db.String())
priority = db.Column(db.Enum(priorityEnum), default="high")
is_done = db.Column(db.Boolean(), default=False)
category_id = db.Column(db.Integer(), db.ForeignKey("category.id"))
def __repr__(self):
return f"<Task-{self.id}\n \
class Tasks(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column('任务名称', db.String(50), nullable=False, unique=True)
target = db.Column('检测目标', db.String(255), nullable=False)
status = db.Column('任务状态', db.Integer(), default=0)
task_id = db.Column('任务ID', db.Integer(), unique=True)
start_time = db.Column('开始时间', db.DateTime, nullable=False, default=datetime.utcnow)
end_tiem = db.Column('结束时间', db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<task name : %s task status %s>' % self.name, self.status
class Urls(db.Model):
__tablename__ = 'urls'
id = db.Column(db.Integer(), primary_key=True)
task_id = db.Column('任务ID', db.Integer(), nullable=False)
url = db.Column('url链接', db.String(400))
method = db.Column('请求方法', db.String(10))
params = db.Column('请求参数', db.String(255), nullable=True)
referer = db.Column('请求源地址', db.String(400))
start_time = db.Column('开始时间', db.DateTime, default=datetime.utcnow)
end_time = db.Column('结束时间', db.DateTime, default=datetime.utcnow)
def __repr__(self):
return '<task id : %d>' % self.task_id
class Comment(db.Model):
"""评论"""
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
user_id = db.Column(db.Integer(), db.ForeignKey(User.id))
user = db.relationship(User, backref='comments')
post_id = db.Column(db.Integer(), db.ForeignKey(Post.id))
post = db.relationship(Post, backref='comments')
def __str__(self):
return f'{self.content[:18]}'
class Hall(db.Model):
__tablename__ = 'hall'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), nullable=False)
abbr = db.Column(db.String(10), nullable=True)
x = db.Column(db.Float())
y = db.Column(db.Float())
def __init__(self, name, abbr, x=0, y=0):
self.name = name
self.abbr = abbr
self.x = x
self.y = y
def __repr__(self):
return "<Hall: {}>".format(self.id)
def json_to_database():
halls = location.get_halls()['halls']
print('Writing {} halls to database...'.format(len(halls)))
for h in halls:
try:
hall = Hall(h['name'], h['abbr'], x=h['x'], y=h['y'])
print('Adding Hall {}, ({}, {})'.format(
hall.name, hall.x, hall.y))
db.session.add(hall)
except Exception as e:
print('Error in writing halls to table -- {}'.format(e))
print('Skipping...')
continue
db.session.commit()
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
class Customer(db.Model):
__tablename__ = 'customer'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
email = db.Column(db.String(50))
class User(db.Model, UserMixin):
def __init__(self, username, email, password, description=None, admin=None):
self.username = username
self.email = email
self.password = pbkdf2_sha256.hash(password)
self.description = description
self.admin = admin
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
description = db.Column(db.String())
image_file = db.Column(db.String(), default="default.jpg", nullable=False)
last_seen = db.Column(db.String(), default=datetime.now().strftime("%d/%m/%y %H:%M:%S"))
date_created = db.Column(db.String(), default=datetime.now().strftime("%d/%m/%y"))
admin = db.Column(db.Boolean(), default=False, nullable=False)
def verify_password(self, pwd):
"""
Verify actual password with hashed
"""
return pbkdf2_sha256.verify(pwd, self.password)
def is_admin(self):
"""
Verify admin
"""
return self.admin
def __repr__(self):
return f"User('{self.username}','{self.password}')"
class UserModel(BaseModel):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True) # type:int
# required fields after signup to send messages
registration_id = db.Column(db.Integer, index=True) # type:int
device_id = db.Column(db.Integer, index=True) # type:int
identity_public_key = db.Column(db.String()) # type:str
signed_pre_key = db.Column(db.String()) # type:str
one_time_pre_keys = db.Column(ARRAY(db.String())) # type: List[str]
friends = db.Column(ARRAY(db.Integer())) # type: List[int]
# LoginModel reference
login = relationship("LoginModel", uselist=False, back_populates="user") # type:LoginModel
def to_dict(self):
return {'user_id': self.id,
'username': self.login.username,
'registration_id': self.registration_id,
'device_id': self.device_id,
'identity_public_key': self.identity_public_key,
'one_time_pre_key': self.one_time_pre_keys,
'signed_pre_key': self.signed_pre_key}
def to_public_dict(self):
one_time_pre_key = self.one_time_pre_keys[0]
return {'user_id': self.id,
'username': self.login.username,
'registration_id': self.registration_id,
'device_id': self.device_id,
'identity_public_key': self.identity_public_key,
'one_time_pre_key': one_time_pre_key,
'signed_pre_key': self.signed_pre_key}
class Book(ResourceMixin, db.Model):
__tablename__ = 'book'
id = db.Column(db.Integer, primary_key=True)
genre_id = db.Column(db.Integer, db.ForeignKey('genre.id'))
notes = db.relationship('Note', backref='book', lazy='dynamic')
title = db.Column(db.String(128))
desc = db.Column(db.String(512))
status = db.Column(db.Enum('Todo', 'In progress', 'Save', 'Done'),
server_default='Save')
rating = db.Column(db.Integer(), default=0)
icon_path = db.Column(db.String(128))
book_path = db.Column(db.String(128))
drive_book_id = db.Column(db.String(128))
drive_icon_id = db.Column(db.String(128))
def __init__(self, **kwargs):
super(Book, self).__init__(**kwargs)
def __repr__(self):
return '<Book {}>'.format(self.title)
@classmethod
def search(cls, query):
if not query:
return ''
search_query = '%{0}%'.format(query)
search_chain = (Book.title.ilike(search_query),
Book.desc.ilike(search_query))
return or_(*search_chain)
class Signee(db.Model):
__tablename__ = 'signee'
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(80), unique=True, nullable=False)
def __init__(self, email):
self.email = email
@staticmethod
def signUp(email):
instance = Signee(email)
db.session.add(instance)
db.session.commit()
return instance
# @staticmethod
# def find_or_create_from_token(access_token):
# data = GitHub.get_user_from_token(access_token)
#
# """Find existing user or create new User instance"""
# instance = User.query.filter_by(username=data['login']).first()
#
# if not instance:
# instance = User(data['login'], data['avatar_url'], data['id'])
# db.session.add(instance)
# db.session.commit()
#
# return instance
def __repr__(self):
return "<User: {}>".format(self.username)
class IndicatorValue(db.Model):
__tablename__ = 'indicatorvalue'
timestamp = db.Column(db.DateTime(), nullable=False)
value = db.Column(db.Numeric(), nullable=False)
indicator_id = db.Column(db.Integer(),
db.ForeignKey('indicator.id', ondelete='CASCADE'),
nullable=False,
index=True)
__table_args__ = (db.PrimaryKeyConstraint(
'timestamp',
'indicator_id',
name='indicatorvalue_timestamp_indicator_id_pkey'), )
def as_dict(self):
return {
'timestamp': self.timestamp,
'value': self.value,
'indicator_id': self.indicator_id
}
def update_dict(self):
return {'value': self.value}
def __repr__(self):
return '<SLI value {} | {}: {}>'.format(self.indicator.name,
self.timestamp, self.value)
class BaseModel:
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
deleted = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
updated_at = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow,
nullable=False)
deleted_at = db.Column(db.DateTime, nullable=True)
def commit(self):
try:
db.session.add(self)
db.session.commit()
return self
except Exception as E:
db.session.rollback()
raise E
def delete(self):
self.deleted = True
self.deleted_at = datetime.utcnow()
self.commit()
class MasterUser(db.Model, UserMixin):
"""后台用户"""
__tablename__ = 'master_users'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(32),
nullable=False,
unique=True,
index=True)
password_hash = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False, unique=True)
role_id = db.Column(db.SmallInteger,
db.ForeignKey("master_roles.id"),
default=0,
comment='用户角色')
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
login_at = db.Column(db.DateTime, default=datetime.now())
def __repr__(self):
return '<%s (%r)>' % (self.__class__.__name__, self.username)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
class Indicator(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(120), nullable=False, index=True)
source = db.Column(db.JSON(), nullable=False)
unit = db.Column(db.String(20), nullable=False, default='')
aggregation = db.Column(db.String(80), default='average')
is_deleted = db.Column(db.Boolean(),
default=False,
index=True,
server_default=false())
product_id = db.Column(db.Integer(),
db.ForeignKey('product.id'),
nullable=False,
index=True)
slug = db.Column(db.String(120), nullable=False, index=True)
targets = db.relationship('Target',
backref=db.backref('indicator', lazy='joined'),
lazy='dynamic')
values = db.relationship('IndicatorValue',
backref='indicator',
lazy='dynamic',
passive_deletes=True)
username = db.Column(db.String(120), default='')
created = db.Column(db.DateTime(), default=datetime.utcnow)
updated = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
__table_args__ = (db.UniqueConstraint(
'name',
'product_id',
'is_deleted',
name='indicator_name_product_id_key'), )
def get_owner(self):
return self.product.product_group.name
def __repr__(self):
return '<SLI {} | {} | {}>'.format(self.product.name, self.name,
self.source)
class VulnsResult(db.Model):
__tablename__ = 'vulns_result'
id = db.Column(db.Integer(), primary_key=True)
task_id = db.Column('任务ID', db.Integer())
vuln_url = db.Column('漏洞链接', db.String(400), nullable=False)
requests = db.Column('请求头部', db.Text)
response = db.Column('响应内容', db.Text)
def __repr__(self):
return '<task id : %d>' % self.task_id
def get_vuln_detail(self, id):
data = VulnsResult.query.filter_by(id=id).first()
return data
def get_vuln_all_by_task_id(self, task_id):
data = VulnsResult.query.filter_by(task_id).all()
return data
class Order(db.Model):
__tablename__ = 'order'
id = db.Column(db.Integer(), primary_key=True)
date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
status = db.Column(db.Enum(OrderStatusEnum))
price = db.Column(db.Float())
customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'))
customer = relationship(Customer)
class Ies(db.Model):
__tablename__ = 'Ies'
cod_ies = db.Column(db.INT(), primary_key=True)
nome_ies = db.Column(db.Text())
sigla_ies = db.Column(db.Text())
num_cnpj = db.Column(db.BigInteger())
tipo_organizacao = db.Column(db.Text())
cod_mantenedora = db.Column(db.Integer())
email_ies = db.Column(db.Text())
site_ies = db.Column(db.Text())
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer(), primary_key=True)
nickname = db.Column(db.String(64), unique=True)
password = db.Column(db.String(128))
icon = db.Column(db.String(64), default='default.jpg')
phone = db.Column(db.INTEGER(), unique=True)
email = db.Column(db.String(128), unique=True)
confirmed = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(64))
class Basket(db.Model):
"A basket of foos."
__tablename__ = 'basket'
id = db.Column('id', db.Integer(), primary_key=True)
name = db.Column('name', db.Text(), nullable=False)
created_ts = db.Column(db.DateTime(timezone=True),
server_default=text('NOW()'))
foos = db.relationship('Foo', backref='basket', lazy='dynamic')
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __init__(self, name, description=''):
self.name = name
self.description = description
def __repr__(self):
return "<Role %s--%s>" % (self.name, self.description)
