class Question(db.Model):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True)
answers = db.relationship('Answer',
uselist=True,
back_populates='question')
text = db.Column(db.Text)
class SubCounties(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
# db.relationship('Ward', backref='sub_county', lazy='joined')
def __init__(self, name):
self.name = name
class Locations(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
ward = db.Column(db.Integer, db.ForeignKey('wards.id'), nullable=False)
def __init__(self, name, wards):
self.name = name
self.wards = wards
class Recruiter(db.Model):
__tablename__ = 'recruiter'
id = db.Column(db.Integer, db.ForeignKey(User.id), primary_key=True)
user = db.relationship(User)
applications = db.relationship('Application',
uselist=True,
back_populates='recruiter')
is_senior = db.Column(db.Boolean, default=False)
class BookModel(db.Model):
__tablename__ = "books"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
pages = db.Column(db.Integer, nullable=False)
def __init__(self, title, pages):
self.title = title
self.pages = pages
class Structure(db.Model):
__tablename__ = 'structure'
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.String(100))
system_id = db.Column(db.Integer, db.ForeignKey(System.id), nullable=True)
system = db.relationship(System, foreign_keys=[system_id])
corporation_id = db.Column(db.Integer,
db.ForeignKey(Corporation.id),
nullable=True)
corporation = db.relationship(Corporation, uselist=False)
redlisted = db.Column(db.Boolean, default=False)
@classmethod
def get(cls, character, id):
structure = db.session.query(cls).get(id)
if structure is None or structure.system_id is None:
if structure is not None:
db.session.delete(structure)
db.session.commit()
try:
structure_data = character.get_op(
'get_universe_structures_structure_id',
structure_id=id,
)
Corporation.get(structure_data['owner_id'])
System.get(structure_data['solar_system_id'])
structure = Structure(
id=id,
name=structure_data['name'],
system_id=structure_data['solar_system_id'],
corporation_id=structure_data['owner_id'])
except esi.ESIException:
structure = Structure(
id=id,
name='Unknown Structure {}'.format(id),
)
db.session.add(structure)
db.session.commit()
return structure
@classmethod
def get_multi(cls, character, id_list):
existing_items = db.session.query(Structure).filter(
Structure.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
for id in missing_ids:
return_items[id] = cls.get(character, id)
return return_items
@property
def is_redlisted(self):
if self.redlisted:
return True
else:
return bool(self.system and self.system.is_redlisted)
class Villages(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
sub_location = db.Column(db.Integer,
db.ForeignKey('sub_locations.id'),
nullable=False)
def __init__(self, name, sub_location):
self.name = name
self.sub_location = sub_location
class SubLocations(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
location = db.Column(db.Integer,
db.ForeignKey('locations.id'),
nullable=False)
def __init__(self, name, location):
self.name = name
self.location = location
class ConfigItem(db.Model):
__tablename__ = 'config_item'
key = db.Column(db.String, primary_key=True)
value = db.Column(db.String)
def __str__(self):
return '{}: {}'.format(self.key, self.value)
def __repr__(self):
return 'ConfigItem(key={!r}, value={!r})'.format(self.key, self.value)
class Job(db.Model):
# __tablename__ = 'jobs'
job_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(20), nullable=False)
skills = db.relationship('Skill',
secondary=job_requirements,
backref=db.backref('job', lazy='dynamic'))
def __repr__(self):
return '<Job %r>' % (self.title)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
class bulletin_board(db.Model):
__tablename__ = 'bulletin_board'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __init__(self, username='', email=''):
self.username = username
self.email = email
def __repr__(self):
return 'Username: {}, email: {}.'.format(self.username, self.email)
class Candidate(db.Model):
# __tablename__ = 'candidates'
candidate_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(20), nullable=False)
skills = db.relationship(
'Skill', secondary=candidate_skills,
backref=db.backref('candidate', lazy='dynamic')
)
def __repr__(self):
return '<Candidate %r %r>' % (self.title, self.skills)
class Wards(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
sub_county = db.Column(
db.Integer,
db.ForeignKey('sub_counties.id'),
nullable=False,
)
def __init__(self, name, sub_county):
self.name = name
self.sub_county = sub_county
class Genres(db.Model):
__tablename__ = 'genres'
id = db.Column('id', db.Integer, primary_key=True)
genre = db.Column('genre', db.String(250), unique=True)
def __init__(self, id, genre):
self.id = id
self.genre = genre
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Character(db.Model):
__tablename__ = 'characters'
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
cv = db.Column(db.Text)
note = db.Column(db.Text)
x = db.Column(db.Integer)
y = db.Column(db.Integer)
width = db.Column(db.Integer)
height = db.Column(db.Integer)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
class Users(db.Model):
__tablename__ = 'users'
id = db.Column('id', db.Integer, primary_key=True)
name = db.Column('name', db.String(150))
username = db.Column('username', db.String(250), unique=True)
email = db.Column('email', db.String(100), unique=True)
password = db.Column('password', db.Text)
terms = db.Column('terms', db.Boolean)
created_at = db.Column('created_at', db.DateTime)
updated_at = db.Column('updated_at', db.DateTime)
def __init__(self, id, name, username, email, password, terms, created_at,
updated_at):
self.name = name
self.id = id
self.username = username
self.email = email
self.password = password
self.terms = terms
self.created_at = created_at
self.updated_at = updated_at
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Type(db.Model):
__tablename__ = 'type'
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey(Group.id))
name = db.Column(db.String(100))
redlisted = db.Column(db.Boolean, default=False)
price = db.Column(db.Float, default=0.)
@classmethod
def get(cls, id):
type = db.session.query(cls).get(id)
if type is None:
type_dict = esi.get_op(
'get_universe_types_type_id',
type_id=id,
)
Group.get(type_dict['group_id'])
type = Type(id=id,
name=type_dict['name'],
group_id=type_dict['group_id'])
db.session.add(type)
db.session.commit()
return type
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(Type).filter(Type.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
if len(missing_ids) > 0:
new_data_dict = esi.get_op('get_universe_types_type_id',
type_id=list(missing_ids))
group_ids = set(item['group_id']
for item in new_data_dict.values())
Group.get_multi(list(group_ids))
prices = get_prices(missing_ids)
for type_id, type_data in new_data_dict.items():
type = Type(id=type_id,
name=type_data['name'],
group_id=type_data['group_id'],
price=prices.get(type_id, 0))
db.session.add(type)
return_items[type_id] = type
db.session.commit()
return return_items
@property
def is_redlisted(self):
return self.redlisted
class Answer(db.Model):
__tablename__ = 'answer'
question_id = db.Column(db.Integer,
db.ForeignKey(Question.id),
primary_key=True)
question = db.relationship("Question",
uselist=False,
back_populates='answers')
application_id = db.Column(db.Integer,
db.ForeignKey(Application.id),
primary_key=True)
application = db.relationship("Application",
uselist=False,
back_populates="answers")
text = db.Column(db.Text)
class Skill(db.Model):
# __tablename__ = 'skills'
skill_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
jobs = db.relationship('Job',
secondary="job_requirements",
backref='job_skill',
lazy="dynamic")
candidates = db.relationship('Candidate',
secondary="candidate_skills",
backref='candidate_skill',
lazy="dynamic")
def __repr__(self):
return '<Skill %r>' % self.name
class System(db.Model):
__tablename__ = 'system'
id = db.Column(db.Integer, primary_key=True)
region_id = db.Column(db.Integer, db.ForeignKey(Region.id))
region = db.relationship(Region, uselist=False)
name = db.Column(db.String(100))
redlisted = db.Column(db.Boolean, default=False)
@classmethod
def get(cls, id):
system = db.session.query(cls).get(id)
if system is None:
system_data = esi.get_op(
'get_universe_systems_system_id',
system_id=id,
)
constellation_data = esi.get_op(
'get_universe_constellations_constellation_id',
constellation_id=system_data['constellation_id'],
)
region = Region.get(constellation_data['region_id'])
system = System(
id=id,
region_id=constellation_data['region_id'],
name=system_data['name'],
)
db.session.add(system)
db.session.commit()
return system
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(cls).filter(cls.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
for id in missing_ids:
return_items[id] = cls.get(id)
return return_items
@property
def is_redlisted(self):
if self.redlisted:
return True
else:
region = Region.get(self.region_id)
return region.is_redlisted
class Alliance(db.Model):
__tablename__ = 'alliance'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
ticker = db.Column(db.String(20))
redlisted = db.Column(db.Boolean, default=False)
corporations = db.relationship('Corporation', back_populates='alliance')
@classmethod
def get(cls, id, *args, **kwargs):
alliance = db.session.query(cls).get(id)
if alliance is None:
alliance_data = esi.get_op(
'get_alliances_alliance_id',
alliance_id=id,
)
alliance = Alliance(id=id,
name=alliance_data['name'],
ticker=alliance_data['ticker'])
db.session.add(alliance)
db.session.commit()
return alliance
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(Alliance).filter(
Alliance.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
if len(missing_ids) > 0:
new_data_dict = esi.get_op('get_alliances_alliance_id',
alliance_id=list(missing_ids))
for alliance_id, data in new_data_dict.items():
alliance = Alliance(id=alliance_id,
name=data['name'],
ticker=data['ticker'])
db.session.add(alliance)
return_items[alliance_id] = alliance
db.session.commit()
return return_items
@property
def is_redlisted(self):
return self.redlisted
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
application_id = db.Column(db.Integer, db.ForeignKey(Application.id))
application = db.relationship(Application, back_populates='images')
is_confirmed = db.Column(db.Boolean, default=False, nullable=False)
@property
def url(self):
if not app.config.get('TESTING'):
s3 = boto3.client(
's3',
region_name=aws_region_name,
endpoint_url=aws_endpoint_url,
config=Config(signature_version=aws_signature_version),
)
url = s3.generate_presigned_url('get_object',
Params={
'Bucket': aws_bucket_name,
'Key': self.filename
},
ExpiresIn=3600)
else:
url = 'placeholder url for {}'.format(self.id)
return url
@property
def filename(self):
return str(self.id)
@classmethod
def delete(cls, id, key):
if not app.config.get('TESTING'):
s3 = boto3.client(
's3',
region_name=aws_region_name,
endpoint_url=aws_endpoint_url,
config=Config(signature_version=aws_signature_version),
)
s3.delete_object(
Bucket=aws_bucket_name,
Key=key,
)
Image.query.filter_by(id=id).delete()
db.session.commit()
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
characters = db.relationship('Character',
uselist=True,
back_populates='user')
recruiter = db.relationship('Recruiter', uselist=False)
admin = db.relationship('Admin', uselist=False)
applications = db.relationship('Application',
uselist=True,
back_populates='user')
redlisted = db.Column(db.Boolean, default=False)
@classmethod
def get(cls, id):
user = db.session.query(cls).get(id)
if user is None:
character = Character.get(id=id)
user = cls(id=id, name=character.name)
db.session.add(user)
db.session.commit()
if character.user_id is None:
character.user_id = user.id
db.session.commit()
return user
def get_id(self):
return self.id
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(cls).filter(cls.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
for id in missing_ids:
return_items[id] = cls.get(id)
return return_items
@property
def is_redlisted(self):
return self.redlisted
class Region(db.Model):
__tablename__ = 'region'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
redlisted = db.Column(db.Boolean, default=False)
esi_op_name = 'get_universe_regions_region_id'
esi_id_name = 'region_id'
@classmethod
def _construct(cls, esi_data):
return cls(id=esi_data[cls.esi_id_name], name=esi_data['name'])
@classmethod
def get(cls, id):
result = db.session.query(cls).get(id)
if result is None:
esi_data = esi.get_op(cls.esi_op_name, **{cls.esi_id_name: id})
result = cls._construct(esi_data)
db.session.add(result)
db.session.commit()
return result
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(cls).filter(cls.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
if len(missing_ids) > 0:
new_data_dict = esi.get_op(cls.esi_op_name,
**{cls.esi_id_name: list(missing_ids)})
for id, esi_data in new_data_dict.items():
return_items[id] = cls._construct(esi_data)
db.session.add(return_items[id])
db.session.commit()
return return_items
@property
def is_redlisted(self):
return self.redlisted
class Show(db.Model):
__tablename__ = 'Show'
id: int = db.Column(db.Integer, primary_key=True, autoincrement=True)
start_time: datetime = db.Column(db.DateTime)
# Foreign keys
venue_id: int = db.Column(db.Integer,
db.ForeignKey('Venue.id'),
primary_key=True,
nullable=False)
artist_id: int = db.Column(db.Integer,
db.ForeignKey('Artist.id'),
primary_key=True,
nullable=False)
# Relationships
venue = db.relationship('Venue',
backref=db.backref('shows', cascade='all, delete'))
artist = db.relationship('Artist',
backref=db.backref('shows',
cascade='all, delete'))
class Note(db.Model):
__tablename__ = 'note'
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer)
text = db.Column(db.Text)
title = db.Column(db.Text, nullable=True)
is_chat_log = db.Column(db.Boolean)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
application_id = db.Column(db.Integer, db.ForeignKey(Application.id))
application = db.relationship("Application",
uselist=False,
back_populates="notes")
class Group(db.Model):
__tablename__ = 'group'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
@classmethod
def get(cls, id):
group = db.session.query(cls).get(id)
if group is None:
group_data = esi.get_op(
'get_universe_groups_group_id',
group_id=id,
)
group = Group(id=id, name=group_data['name'])
db.session.add(group)
db.session.commit()
return group
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(Group).filter(Group.id.in_(id_list))
return_items = {item.id: item for item in existing_items}
missing_ids = set(id_list).difference(
[item.id for item in existing_items])
if len(missing_ids) > 0:
new_data_dict = esi.get_op('get_universe_groups_group_id',
group_id=list(missing_ids))
for group_id, group_data in new_data_dict.items():
group = Group(
id=group_id,
name=group_data['name'],
)
db.session.add(group)
return_items[group_id] = group
db.session.commit()
return return_items
class BloodStock(Model):
__tablename__ = "blood_stock"
id = Column(db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False)
ab_positive = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
ab_negative = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
a_positive = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
a_negative = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
b_positive = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
b_negative = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
o_positive = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
o_negative = db.Column(db.BigInteger,
default=0,
nullable=False,
index=True)
