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 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 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 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 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 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 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 Application(db.Model):
__tablename__ = 'application'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
recruiter_id = db.Column(db.Integer,
db.ForeignKey(Recruiter.id),
nullable=True)
recruiter = db.relationship(Recruiter)
is_submitted = db.Column(db.Boolean, default=False)
is_concluded = db.Column(db.Boolean, default=False)
is_accepted = db.Column(db.Boolean, default=False)
is_invited = db.Column(db.Boolean, default=False)
answers = db.relationship('Answer',
uselist=True,
back_populates='application')
notes = db.relationship('Note', uselist=True, back_populates='application')
images = db.relationship('Image',
uselist=True,
back_populates='application')
@classmethod
def get_for_user(cls, user_id):
return db.session.query(cls).filter(
db.and_(
cls.user_id == user_id,
db.or_(
cls.is_concluded == False,
db.and_(cls.is_accepted == True,
cls.is_invited == False)))).first()
@classmethod
def get_submitted_for_user(cls, user_id):
return db.session.query(cls).filter(
db.and_(
cls.user_id == user_id, cls.is_submitted == True,
db.or_(
cls.is_concluded == False,
db.and_(cls.is_accepted == True,
cls.is_invited == False)))).first()
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 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 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 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 Character(db.Model):
__tablename__ = 'character'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True)
user = db.relationship("User", uselist=False, back_populates='characters')
name = db.Column(db.String(100))
corporation_id = db.Column(db.Integer, db.ForeignKey(Corporation.id))
corporation = db.relationship(Corporation, uselist=False)
refresh_token = db.Column(db.Text, nullable=True)
redlisted = db.Column(db.Boolean, default=False)
blocked_from_applying = db.Column(db.Boolean, default=False)
@classmethod
def refresh_from_esi(cls):
ids = set(item[0] for item in db.session.query(Character.id).all())
new_data_dict = esi.get_op('get_characters_character_id',
character_id=list(ids))
corporation_ids = set(char['corporation_id']
for char in new_data_dict.values())
Corporation.get_multi(list(corporation_ids))
for character_id, character_data in new_data_dict.items():
character = Character.get(character_id)
if character.corporation_id != character_data['corporation_id']:
character.corporation_id = character_data['corporation_id']
db.session.commit()
@classmethod
def get(cls, id):
character = db.session.query(cls).get(id)
if character is None:
character_data = esi.get_op('get_characters_character_id',
character_id=id)
Corporation.get(character_data['corporation_id'])
character_details = {
'id': id,
'name': character_data['name'],
'corporation_id': character_data['corporation_id'],
}
if db.engine.execute(text('select * from "user" where "id" = :id'),
id=id).scalar():
# if db.session.query(db.exists().where(User.id==id)).scalar():
# set the user if that user exists
character_data['user_id'] = id
character = Character(**character_details)
db.session.add(character)
db.session.commit()
return character
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(Character).filter(
Character.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_characters_character_id',
character_id=list(missing_ids))
corporation_ids = set(char['corporation_id']
for char in new_data_dict.values())
corporations = Corporation.get_multi(list(corporation_ids))
for character_id, character_data in new_data_dict.items():
character = Character(
id=character_id,
name=character_data['name'],
corporation_id=character_data['corporation_id'],
)
db.session.add(character)
return_items[character_id] = character
db.session.commit()
return return_items
def get_op(self, op_name, **kwargs):
return esi.get_op(op_name, refresh_token=self.refresh_token, **kwargs)
def get_paged_op(self, op_name, **kwargs):
return esi.get_paged_op(op_name,
refresh_token=self.refresh_token,
**kwargs)
@property
def is_redlisted(self):
if self.redlisted:
return True
else:
return Corporation.get(self.corporation_id).is_redlisted
from models.database import db
candidate_skills = db.Table(
'candidate_skills',
db.Column('candidate_id', db.Integer,
db.ForeignKey('candidate.candidate_id')),
db.Column('skill_id', db.Integer, db.ForeignKey('skill.skill_id')))
job_requirements = db.Table(
'job_requirements',
db.Column('job_id', db.Integer, db.ForeignKey('job.job_id')),
db.Column('skill_id', db.Integer, db.ForeignKey('skill.skill_id')))
class Corporation(db.Model):
__tablename__ = 'corporation'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
ticker = db.Column(db.String(20))
ceo_id = db.Column(db.Integer)
alliance_id = db.Column(db.Integer, db.ForeignKey(Alliance.id))
alliance = db.relationship(Alliance,
uselist=False,
back_populates='corporations')
redlisted = db.Column(db.Boolean, default=False)
@classmethod
def refresh_from_esi(cls):
ids = set(item[0] for item in db.session.query(Corporation.id).all())
new_data_dict = esi.get_op('get_corporations_corporation_id',
corporation_id=list(ids))
alliance_ids = set()
for corp_data in new_data_dict.values():
if 'alliance_id' in corp_data:
alliance_ids.add(corp_data['alliance_id'])
Alliance.get_multi(list(alliance_ids))
for corporation_id, corporation_data in new_data_dict.items():
corporation = Corporation.get(corporation_id)
if corporation.ceo_id != corporation_data['ceo_id']:
corporation.ceo_id = corporation_data['ceo_id']
if corporation.alliance_id != corporation_data.get(
'alliance_id', None):
corporation.alliance_id = corporation_data['alliance_id']
db.session.commit()
@classmethod
def get(cls, id):
corporation = db.session.query(cls).get(id)
if corporation is None:
corporation_data = esi.get_op(
'get_corporations_corporation_id',
corporation_id=id,
)
corporation = Corporation(
id=id,
name=corporation_data['name'],
ticker=corporation_data['ticker'],
ceo_id=corporation_data['ceo_id'],
)
if corporation_data.get('alliance_id', None) is not None:
Alliance.get(corporation_data['alliance_id'])
corporation.alliance_id = corporation_data['alliance_id']
db.session.add(corporation)
db.session.commit()
return corporation
@classmethod
def get_multi(cls, id_list):
existing_items = db.session.query(Corporation).filter(
Corporation.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_corporations_corporation_id',
corporation_id=list(missing_ids))
alliance_ids = set()
for corp_data in new_data_dict.values():
if 'alliance_id' in corp_data:
alliance_ids.add(corp_data['alliance_id'])
alliances = Alliance.get_multi(list(alliance_ids))
for corporation_id, corporation_data in new_data_dict.items():
corporation = Corporation(
id=corporation_id,
name=corporation_data['name'],
ticker=corporation_data['ticker'],
ceo_id=corporation_data['ceo_id'],
)
if corporation_data.get('alliance_id', None) is not None:
corporation.alliance_id = corporation_data['alliance_id']
db.session.add(corporation)
return_items[corporation_id] = corporation
db.session.commit()
return return_items
@property
def is_redlisted(self):
if self.redlisted:
return True
elif self.alliance is not None and self.alliance.is_redlisted:
return True
else:
return False
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, db.ForeignKey(User.id), primary_key=True)
user = db.relationship(User)
class BloodBankModel(IndexedTimestampModel):
__tablename__ = "blood_banks"
id = Column(db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=True)
address = db.Column(db.String(255), nullable=False)
city = db.Column(db.String(65), nullable=False, index=True)
state = db.Column(db.String(255), nullable=False, index=True)
district = db.Column(db.String(65), index=True)
pincode = db.Column(db.BigInteger, nullable=True, index=True)
country = db.Column(db.String(65),
nullable=False,
default="India",
index=True)
blood_stock_id = db.Column(db.BigInteger,
db.ForeignKey('blood_stock.id'),
nullable=False)
latitude = db.Column(db.Numeric(10, 8), nullable=True, index=True)
longitude = db.Column(db.Numeric(11, 8), nullable=True, index=True)
contact_number = db.Column(db.String(65), nullable=True)
mobile_number = db.Column(db.BigInteger, nullable=True)
blood_stock_relation = db.relationship("BloodStock",
foreign_keys=[blood_stock_id])
# def __init__(self,name,email,state,country,address,blood_stock_id,city):
# self.email = email
# self.name = name
# self.address = address
# self.district = district
# self.pincode = pincode
# self.city = city
# self.state = state
# self.city = city
# self.country = country
# self.blood_stock_id = blood_stock_id
def to_json(self):
blood_stock_obj = BloodStock.query.filter_by(
id=self.blood_stock_id).first()
return {
"id": self.id,
"name": self.name,
"email": self.email,
"address": self.address,
"city": self.city,
"state": self.state,
"country": self.country,
"district": self.district,
"latitude": '{}'.format(self.latitude),
"longitude": '{}'.format(self.longitude),
"pincode": self.pincode,
"contact_number": self.contact_number,
"mobile_number": self.mobile_number,
"blood_stock": {
"ab_positive": blood_stock_obj.ab_positive,
"ab_negative": blood_stock_obj.ab_negative,
"a_positive": blood_stock_obj.a_positive,
"a_negative": blood_stock_obj.a_negative,
"b_positive": blood_stock_obj.b_positive,
"o_positive": blood_stock_obj.o_positive,
"o_negative": blood_stock_obj.o_negative
}
}
