class Roles(db.Model):
__bind_key__ = 'caesar'
__tablename__ = '%s_roles' % TABLE_PREFIX
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(20), unique=True)
name = db.Column(db.Unicode(80), unique=True)
description = db.Column(db.Unicode(255))
class Settings(db.Model):
__bind_key__ = 'caesar'
__tablename__ = '%s_settings' % TABLE_PREFIX
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(25), unique=True, nullable=False)
name = db.Column(db.Unicode(50), unique=True, nullable=False)
value = db.Column(db.Unicode(100))
def __unicode__(self):
return self.name
class Post(db.Model):
__tablename__ = 'post'
id = db.Column('id', db.Integer, primary_key=True)
title = db.Column('title', db.Unicode(50), unique=True)
pic_address = db.Column('pic_address', db.Unicode(50), unique=True)
latitude = db.Column('latitude', db.Unicode(50))
longitude = db.Column('longitude', db.Unicode(50))
date_time = db.Column('date_time', db.Unicode(70))
def __init__(self):
pass
def __repr__(self):
return '< Post %r>' % {self.like, self.comment}
class Scan(db.Model):
__tablename__ = 'scans'
id = db.Column(db.Integer, primary_key = True)
relative_id = db.Column(db.Integer)
description = db.Column(db.Text)
target_url = db.Column(db.String(128))
start_time = db.Column(db.Time, default=datetime.utcnow)
scan_time = db.Column(db.Time, nullable=True)
profile = db.Column(db.String(32))
status = db.Column(db.String(32))
deleted = db.Column(db.Boolean, default=False)
run_instance = db.Column(db.Unicode(128))
num_vulns = db.Column(db.Integer)
vulns = db.relationship("Vulnerability", back_populates="scan")
user_id = db.Column(db.String(40), db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="scans")
def __init__(self, id, description, target, profile, user_id):
self.relative_id = id
self.description = description
self.target_url = target
self.profile = profile
self.status = 'Enqueued'
self.user_id = user_id
self.num_vulns = 0
self.run_instance = '' # will be populated with URL of running instance
def doneScan(self):
self.scan_time = datetime.utcnow()
# change status?
def __repr__(self):
return '<Scan %d>' % self.id
class Tag(db.Model):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255), nullable=False)
todo_items = db.relationship('TodoItem', back_populates="tags", secondary=todo_item_tags)
def serialize(self):
return {
'id': self.id,
'name': self.name,
}
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.Unicode(32), unique = True)
description = db.Column(db.Text)
def __init__(self, name, description):
self.name = name
self.description = description
def __repr__(self):
return '<Role %r>' % self.name
class RegistryDeliveryAddress(CustomModelMixin, Model):
__tablename__ = 'registry_delivery_addresses'
full_name = Column(db.String(100), nullable=False)
phone_number = db.Column(db.String(50), nullable=True)
address = Column(db.Text, nullable=False)
city = Column(db.String(50), nullable=False)
state = Column(db.String(50), nullable=False)
additional_info = Column(db.Text, nullable=True)
registry_type = Column(db.Unicode(255))
registry_id = Column(db.Integer, nullable=False)
class RegistryProducts(CustomModelMixin, Model):
__tablename__ = 'registry_products'
product_id = reference_col("products", nullable=False)
has_been_purchased = Column(db.Boolean, default=False)
registry_type = Column(db.Unicode(255))
registry_id = Column(db.Integer, nullable=False)
product = relationship("Product", backref=backref("registry_products", cascade="all, delete-orphan"))
def __str__(self):
return self.product.name
class User(db.Model):
__tablename__ = 'user'
id = db.Column('id', db.Integer, primary_key=True)
name = db.Column('name', db.Unicode(50), unique=True)
email = db.Column('email', db.Unicode(50), unique=True)
password = db.Column('password', db.Unicode(50))
authentication_key = db.Column('authentication_key',
db.String(70),
unique=True)
# insert data to table
def __init__(self, name, email):
self.name = name
self.email = email
def __repr__(self):
return '< User %r> ' % (self.name, self.email)
def get(self, name, email):
for usr in self.user:
if usr['name'] == id and usr['email'] == email:
return usr
api.abort(404, "User {} doesn't exist".format(name, email))
def create(self, name, email, password):
self.id += 1
self.name = name
self.email = email
self.password = password
def update(self, id, email):
usr = self.get(id)
usr.update(email)
return usr
def delete(self, id):
usr = self.get(id)
self.user.remove(usr)
class Order(CustomModelMixin, Model):
__tablename__ = 'orders'
order_number = Column(db.String(255), unique=True)
transaction_id = reference_col("transactions", nullable=False)
status = Column(ChoiceType(STATUS, impl=db.String()))
date_created = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
registry_type = Column(db.Unicode(255))
registry_id = Column(db.Integer, nullable=False)
transaction = relationship("Transaction", backref=backref("orders", uselist=True))
def generate_order_number(self):
self.order_number = f"ORD{dt.date.today().strftime('%Y%m%d')}00000{self.id}"
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.String(40), primary_key = True) # UUID
email = db.Column(db.String(32), index=True, unique=True)
name = db.Column(db.Unicode(64))
password_hash = db.Column(db.String(128))
roles = db.relationship('Role', secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
organization = db.Column(db.Unicode(128), nullable=True)
scans = db.relationship("Scan", back_populates="user")
domains = db.relationship("Domain", back_populates="user")
num_domains = db.Column(db.Integer)
num_scans = db.Column(db.Integer)
def __init__(self, email, password, name=None, organization=None):
self.id = str(uuid.uuid4())
self.name = name
self.email = email
self.password = password
self.organization = organization
self.num_scans = 0
self.num_domains = 0
def __repr__(self):
return '<User %r>' % 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, 'pbkdf2:sha256')
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
class QuestionData(db.Model):
""" Feedback-form question-data for all experiments """
q_id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(), nullable=False)
session_id = db.Column(db.Integer, db.ForeignKey('session.session_id'))
exp_name = db.Column(db.String(), nullable=False)
rating = db.Column(db.String())
difficulty = db.Column(db.String())
distraction = db.Column(db.String()) #informative
#extrahelp = db.Column(db.String) #added new
openended = db.Column(db.Unicode())
def __repr__(self):
pass
def add_json_data(self, json_event):
""" Parse and add backbone.js json data for a questionnaire """
self.rating = json_event['rating']
if json_event['difficulty'] == "Not difficult":
json_event['difficulty'] = "1"
elif json_event['difficulty'] == "Somewhat difficult":
json_event['difficulty'] = "5"
elif json_event['difficulty'] == "Very difficult":
json_event['difficulty'] = "10"
elif json_event['difficulty'] == "Not rated":
json_event['difficulty'] = "0"
self.difficulty = json_event['difficulty']
if json_event['distraction'] == "No distraction":
json_event['distraction'] = "1"
elif json_event['distraction'] == "Some distractions":
json_event['distraction'] = "5"
elif json_event['distraction'] == "Frequent interruptions":
json_event['distraction'] = "10"
elif json_event['distraction'] == "Not rated":
json_event['distraction'] = "0"
self.distraction = json_event['distraction']
#self.extrahelp = json_event['extrahelp']
self.openended = clean_db_string(json_event['openended'])
current_app.logger.info("%s added to QuestionData for session id %s " %
(self.q_id, self.session_id))
class User(SystemInfo):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
cellphone = db.Column(db.String(20))
address = db.Column(db.Unicode(255), nullable=True)
password = db.Column(db.String(45))
# 虛擬關聯外鍵，對應到共享此傘的紀錄
share_records = db.relationship('UsingShareRecord', backref='users')
# 虛擬關聯外鍵，紀錄多筆使用此雨傘資源的紀錄
using_resource_records = db.relationship('UsingShareRecord',
backref='users')
def __init__(self, **kwargs):
for k, v in kwargs.iteritems():
setattr(self, k, v)
def __repr__(self):
print "<User: id='%d', name='%s', password='******', cellphone='%s', address='%s'>" % (
self.id, self.name, self.password, self.cellphone, self.address)
