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 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 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 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 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 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 Venue(db.Model):
__tablename__ = 'Venue'
id: int = db.Column(db.Integer, primary_key=True, autoincrement=True)
name: str = db.Column(db.String, nullable=False)
city: str = db.Column(db.String(120), nullable=False)
state: str = db.Column(db.String(120), nullable=False)
phone: str = db.Column(db.String(120), nullable=True)
image_link: str = db.Column(db.String(500), nullable=True)
genres: str = db.Column(db.String(120), nullable=False)
address: str = db.Column(db.String(120), nullable=False)
website: str = db.Column(db.String(120), nullable=True)
facebook_link: str = db.Column(db.String(120), nullable=True)
seeking_talent: bool = db.Column(db.Boolean, nullable=False)
seeking_description: str = db.Column(db.String(500), nullable=True)
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 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 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 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 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 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 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 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 User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=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
}
}
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 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