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 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 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 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 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 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 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 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 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 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 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
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, db.ForeignKey(User.id), primary_key=True)
user = db.relationship(User)
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 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
}
}
