class Address(db.Model):
__tablename__ = "addresses"
id = db.Column(db.Integer, primary_key=True)
address = db.Column(db.String(40), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
final_balance = db.Column(db.Integer)
class CVEGroupEntry(db.Model):
__tablename__ = 'cve_group_entry'
__versioned__ = {}
id = db.Column(db.Integer(),
index=True,
unique=True,
primary_key=True,
autoincrement=True)
group_id = db.Column(db.Integer(),
db.ForeignKey('cve_group.id', ondelete="CASCADE"),
nullable=False)
cve_id = db.Column(db.String(15),
db.ForeignKey('cve.id', ondelete="CASCADE"),
nullable=False)
group = db.relationship("CVEGroup", back_populates="issues")
cve = db.relationship("CVE")
__table_args__ = (db.Index('cve_group_entry__group_cve_idx',
group_id,
cve_id,
unique=True), )
def __repr__(self):
return '<CVEGroupEntry %r from %r referencing %r>' % (
self.id, self.group_id, self.cve_id)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.id}','{self.password}')"
class Group(db.Model):
__tablename__ = "groups"
id = db.Column(db.Integer, primary_key=True)
groupname = db.Column(db.String(64), unique=True)
def __repr__(self):
return '<Group {}>'.format(self.username)
class Car(db.Model):
__bind_key__ = 'cars'
number = db.Column(db.Integer, primary_key=True)
id = db.Column(db.Integer, unique=True, nullable=False)
plate = db.Column(db.String(10), unique=True, nullable=False)
brand = db.Column(db.String(20))
def __repr__(self):
return f"Car('{self.number}','{self.plate}','{self.id}','{self.brand}')"
class Advisory(db.Model):
WORKAROUND_LENGTH = 4096
IMPACT_LENGTH = 4096
CONTENT_LENGTH = 65536
REFERENCE_LENGTH = 120
__tablename__ = 'advisory'
id = db.Column(db.String(15), index=True, unique=True, primary_key=True)
group_package_id = db.Column(db.Integer(),
db.ForeignKey('cve_group_package.id'),
nullable=False,
unique=True,
index=True)
advisory_type = db.Column(db.String(64),
default='multiple issues',
nullable=False)
publication = db.Column(Publication.as_type(),
nullable=False,
default=Publication.scheduled)
workaround = db.Column(db.String(WORKAROUND_LENGTH), nullable=True)
impact = db.Column(db.String(IMPACT_LENGTH), nullable=True)
content = db.Column(db.String(CONTENT_LENGTH), nullable=True)
created = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False,
index=True)
reference = db.Column(db.String(REFERENCE_LENGTH), nullable=True)
group_package = db.relationship("CVEGroupPackage")
def __repr__(self):
return '<Advisory {}>'.format(self.id)
class User(db.Model):
NAME_LENGTH = 32
EMAIL_LENGTH = 128
SALT_LENGTH = 20
PASSWORD_LENGTH = 80
TOKEN_LENGTH = 120
IDP_ID_LENGTH = 255
__tablename__ = 'user'
id = db.Column(db.Integer(), index=True, unique=True, primary_key=True, autoincrement=True)
name = db.Column(db.String(NAME_LENGTH), index=True, unique=True, nullable=False)
email = db.Column(db.String(EMAIL_LENGTH), index=True, unique=True, nullable=False)
salt = db.Column(db.String(SALT_LENGTH), nullable=False)
password = db.Column(db.String(SALT_LENGTH), nullable=False)
token = db.Column(db.String(TOKEN_LENGTH), index=True, unique=True, nullable=True)
role = db.Column(UserRole.as_type(), nullable=False, default=UserRole.reporter)
active = db.Column(db.Boolean(), nullable=False, default=True)
idp_id = db.Column(db.String(IDP_ID_LENGTH), nullable=True, default=None, index=True, unique=True)
is_authenticated = False
is_anonymous = False
@property
def is_active(self):
return self.active
def get_id(self):
return '{}'.format(self.token)
def __str__(self):
return self.name
def __repr__(self):
return '<User %r>' % (self.name)
class Membership(db.Model):
__tablename__ = "memberships"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
group_id = db.Column(db.Integer, db.ForeignKey("groups.id"))
user = orm.relationship(User,
backref=orm.backref("orders",
cascade="all, delete-orphan"))
group = orm.relationship(Group,
backref=orm.backref("groups",
cascade="all, delete-orphan"))
class CVE(db.Model):
DESCRIPTION_LENGTH = 4096
REFERENCES_LENGTH = 4096
NOTES_LENGTH = 4096
__versioned__ = {}
__tablename__ = 'cve'
id = db.Column(db.String(15), index=True, unique=True, primary_key=True)
issue_type = db.Column(db.String(64), default='unknown')
description = db.Column(db.String(DESCRIPTION_LENGTH))
severity = db.Column(Severity.as_type(),
nullable=False,
default=Severity.unknown)
remote = db.Column(Remote.as_type(),
nullable=False,
default=Remote.unknown)
reference = db.Column(db.String(REFERENCES_LENGTH))
notes = db.Column(db.String(NOTES_LENGTH))
created = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False,
index=True)
changed = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False,
index=True)
@staticmethod
def new(id):
return CVE(id=id,
issue_type='unknown',
description='',
severity=Severity.unknown,
remote=Remote.unknown,
reference='',
notes='')
def __repr__(self):
return '{}'.format(self.id)
@property
def numerical_repr(self):
return issue_to_numeric(self.id)
def __gt__(self, other):
return self.numerical_repr > other.numerical_repr
def __lt__(self, other):
return self.numerical_repr < other.numerical_repr
class CVE(db.Model):
DESCRIPTION_LENGTH = 4096
REFERENCES_LENGTH = 4096
NOTES_LENGTH = 4096
__tablename__ = 'cve'
id = db.Column(db.String(15), index=True, unique=True, primary_key=True)
issue_type = db.Column(db.String(64), default='unknown')
description = db.Column(db.String(DESCRIPTION_LENGTH))
severity = db.Column(Severity.as_type(),
nullable=False,
default=Severity.unknown)
remote = db.Column(Remote.as_type(),
nullable=False,
default=Remote.unknown)
reference = db.Column(db.String(REFERENCES_LENGTH))
notes = db.Column(db.String(NOTES_LENGTH))
def __repr__(self):
return '{}'.format(self.id)
@property
def numerical_repr(self):
return issue_to_numeric(self.id)
def __gt__(self, other):
return self.numerical_repr > other.numerical_repr
def __lt__(self, other):
return self.numerical_repr < other.numerical_repr
class AddressTransaction(db.Model):
__tablename__ = "address_transactions"
id = db.Column(db.Integer, primary_key=True)
address_id = db.Column(db.Integer, db.ForeignKey("addresses.id"))
transaction_id = db.Column(db.Integer, db.ForeignKey("transactions.id"))
address = orm.relationship(Address,
backref=orm.backref(
"addresses", cascade="all, delete-orphan"))
transaction = orm.relationship(Transaction,
backref=orm.backref(
"transactions",
cascade="all, delete-orphan"))
@property
def hash(self):
return self.transaction.hash
class CVEGroup(db.Model):
REFERENCES_LENGTH = 4096
NOTES_LENGTH = 4096
__tablename__ = 'cve_group'
id = db.Column(db.Integer(),
index=True,
unique=True,
primary_key=True,
autoincrement=True)
status = db.Column(Status.as_type(),
nullable=False,
default=Status.unknown,
index=True)
severity = db.Column(Severity.as_type(),
nullable=False,
default=Severity.unknown)
affected = db.Column(db.String(32), nullable=False)
fixed = db.Column(db.String(32))
bug_ticket = db.Column(db.String(9))
reference = db.Column(db.String(REFERENCES_LENGTH))
notes = db.Column(db.String(NOTES_LENGTH))
created = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False,
index=True)
advisory_qualified = db.Column(db.Boolean(), default=True, nullable=False)
issues = db.relationship("CVEGroupEntry",
back_populates="group",
cascade="all,delete")
packages = db.relationship("CVEGroupPackage",
back_populates="group",
cascade="all,delete")
@property
def name(self):
return 'AVG-{}'.format(self.id)
def __str__(self):
return self.name
def __repr__(self):
return '<CVEGroup %r>' % (self.id)
class Medicines(db.Model):
"""Medicines table"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
dosage = db.Column(db.Integer, nullable=False)
dosage_unit = db.Column(db.String, nullable=False)
frequency = db.Column(db.String, nullable=False)
frequency_unit = db.Column(db.String, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return self.name
class Users(UserMixin, db.Model):
"""Users table"""
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone_number = db.Column(db.String(20), unique=True, nullable=True)
verified = db.Column(db.Boolean(), default=False)
password = db.Column(db.String(300), nullable=False)
medicines = db.relationship('Medicines', backref='medicine', lazy=True)
def __repr__(self):
return f'{self.first_name} {self.last_name}'
class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True)
uuid = db.Column(db.String(length=32), unique=True)
title = db.Column(db.String(length=200))
description = db.Column(db.Text())
date = db.Column(db.Date)
start_time = db.Column(db.TIMESTAMP)
end_time = db.Column(db.TIMESTAMP)
duration = db.Column(db.Integer())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
user = db.relationship('User', backref=db.backref('tasks', lazy='dynamic'))
@property
def objects(self):
return db_managers.TaskManager(self)
def save(self):
self.objects.save()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
first_name = db.Column(db.String(200), nullable=True)
last_name = db.Column(db.String(200), nullable=True)
is_active = db.Column(db.Boolean, default=False)
avatar = db.Column(db.String(200))
email = db.Column(db.String(200))
password = db.Column(db.String(200))
@property
def objects(self):
return db_managers.UserManager(self)
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = self.objects.get(data['id'])
return user
@classmethod
def authorize(cls, username, password):
q = db.session.query(cls).filter(cls.username == username)
try:
user = q.one()
if bcrypt.check_password_hash(user.password, password):
token = generate_token(user.id)
return user, token
else:
raise errors.UserNotAuthorized(username, 'Wrong password')
except exc.NoResultFound as error:
raise errors.UserNotFound(username, error.message)
# Flask-Login interation
def is_authenticated(self):
return True
def is_active(self):
return self.is_active
def is_anonymous(self):
return False
def get_id(self):
return self.id
def save(self, *args, **kwargs):
self.objects.save(*args, **kwargs)
def __repr__(self):
return "%s %s" % (
self.id,
self.username,
)
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(64))
lastname = db.Column(db.String(64))
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(120), unique=True)
password_hash = db.Column(db.String(128))
is_active = db.Column(db.Boolean, default=False)
failed_login_attempts = db.Column(db.Integer, default=0)
blocked = db.Column(db.Boolean, default=False)
profile_filename = db.Column(db.String(70))
external_auth = db.Column(db.String(20))
@property
def password(self):
return self.password_hash
@password.setter
def password(self, password_string):
if password_string:
self.password_hash = crypto.hash_pass(password_string)
else:
self.password_hash = None
def verify_password(self, password):
return crypto.verify_pass(password, self.password_hash)
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
def __repr__(self):
return '<User {}>'.format(self.username)
class Package(db.Model):
__tablename__ = 'package'
id = db.Column(db.Integer(),
index=True,
unique=True,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(96), index=True, nullable=False)
base = db.Column(db.String(96), index=True, nullable=False)
version = db.Column(db.String(64), nullable=False)
arch = db.Column(db.String(16), index=True, nullable=False)
database = db.Column(db.String(32), index=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
url = db.Column(db.String(192))
filename = db.Column(db.String(128), nullable=False)
md5sum = db.Column(db.String(32), nullable=False)
sha256sum = db.Column(db.String(64), nullable=False)
builddate = db.Column(db.Integer(), nullable=False)
def __repr__(self):
return '<pkgname: {}-{}>'.format(self.name, self.version)
class Transaction(db.Model):
__tablename__ = "transactions"
id = db.Column(db.Integer, primary_key=True)
hash = db.Column(db.String(100), unique=True)
