class Manager_Details(db.Model):
__tablename__ = 'XM_MANAGER_DETAILS'
MANAGER_ID = db.Column(db.String(128), primary_key=True)
SWARM_ID = db.Column(db.Integer)
MANAGER_HOSTNAME = db.Column(db.String(128), nullable=True)
MANAGER_IP = db.Column(db.String(128), nullable=True)
MANAGER_STATUS = db.Column(db.String(128), nullable=True)
ENGINE_VERSION = db.Column(db.String(128), nullable=False)
AVAILABILITY = db.Column(db.String(128), nullable=False)
MANAGER_STATE = db.Column(db.String(128), nullable=False)
CREATION_DATE = db.Column(db.Date, default=_get_date)
def __repr__(self):
return '<ManagerDetails (%s, %s) >' % (self.MANAGER_ID,
self.MANAGER_HOSTNAME)
class Word(db.Model):
__tablename__ = "twitter_word"
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(140))
counts = db.relationship('DateCount',
backref='twitter_word',
lazy='dynamic')
def __str__(self):
return str(self.word)
def as_dict(self):
return {
'id': self.id,
'word': self.word,
'counts': [c.as_dict() for c in self.counts]
}
class Setting(db.Model):
__tablename__ = 'setting'
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
index=True)
name = db.Column('name', db.String(255))
value = db.Column('value', db.Text)
def __init__(self, name, value):
self.name = name
self.value = value
def __repr__(self):
return "<Setting name={0}, value={1}>".format(self.name, self.value)
class Corpus(db.Model):
__tablename__ = 'corpus'
id = db.Column(db.Integer, primary_key=True)
user_id = ReferenceCol('users')
api_key = db.Column(db.String(80), nullable=False)
title = db.Column(db.String(80), nullable=False)
type = db.Column(db.String(80), nullable=False)
seed_url = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(5000))
model_file = db.Column(db.String(100), nullable=False)
corpus_file = db.Column(db.String(100), nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<Corpus %r>' % self.title
class Category(db.Model):
__tablename__ = u'categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
subject_id = db.Column(db.Integer, db.ForeignKey('subjects.id'))
name = db.Column(db.String(25), unique=True)
subject = db.relationship('Subject', backref='categories', lazy='joined')
def __init__(self, name=None, subject_id=None):
self.name = name
self.subject_id = subject_id
def __repr__(self):
return '<Category %r>' % self.name
def __str__(self):
return str(self.name)
class Waiting_c(db.Model):
__tablename__ = "waitings_c"
id = db.Column(db.Integer, primary_key=True)
ticket = db.Column(db.String)
oname = db.Column(db.String)
tname = db.Column(db.String)
n = db.Column(db.Boolean)
name = db.Column(db.String(300), nullable=True)
def __init__(self, ticket="Empty", oname="Empty", tname="Empty",
n=False, name=None):
self.id = 0
self.ticket = ticket
self.oname = oname
self.tname = tname
self.n = n
self.name = name
class Activity(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
name = db.Column(db.String(50), default='New Activity')
duration = db.Column(db.Float(), default=0)
date = db.Column(db.DateTime(),
default=lambda: datetime.datetime.now(tzinfo))
calories = db.Column(db.Float(), default=0)
def data(self):
return {
'id': self.id,
'name': self.name,
'duration': self.duration,
'date': self.date.isoformat(),
'calories': self.calories
}
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
application_id = db.Column(db.Integer,
db.ForeignKey('application.id'),
nullable=False)
date = db.Column(db.DateTime(),
default=lambda: datetime.datetime.now(tzinfo))
is_user = db.Column(db.Boolean, default=False)
text = db.Column(db.String(16000000), default='<Empty Message>')
def data(self):
return {
'date': self.date.isoformat(),
'isUser': self.is_user,
'text': self.text,
'id': self.id
}
class Occupation(db.Model, Serializer):
__tablename__ = 'occupations'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
def __init__(self, name=""):
self.name = name
def __repr__(self):
return {"Occupation": self.name}
def __unicode__(self):
return self.name
def serialize(self):
return Serializer.serialize(self)
class Effectif(db.Model):
__tablename__ = "effectif"
id_effectif = db.Column(db.Integer, primary_key=True)
siret = db.Column(db.String(255))
daterecuperationeffectif = db.Column(db.Date)
effectif = db.Column(db.Float)
def __init__(self, siret, daterecuperationeffectif, effectif):
self.siret = siret
self.daterecuperationeffectif = daterecuperationeffectif
self.effectif = effectif
def __repr__(self):
return '%s/%s/%s' % (self.siret, self.daterecuperationeffectif,
self.effectif)
class SurveyType(db.Model, Serializer):
__tablename__ = 'surveytypes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
def __init__(self, name=""):
self.name = name
def __repr__(self):
return {"Client Class": self.name}
def __unicode__(self):
return self.name
def serialize(self):
return Serializer.serialize(self)
class Submission(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
competition_id = db.Column(db.Integer,
db.ForeignKey('competition.id'),
nullable=False)
filename = db.Column(db.String(500), nullable=False)
submitted_on = db.Column(db.DateTime())
comment = db.Column(db.Text)
score = db.Column(db.Float)
preview_score = db.Column(db.Float)
def __repr__(self):
return "{}".format(self.id)
def __unicode__(self):
return "{}".format(self.id)
class Favorite(db.Model):
id = db.Column(db.Integer, primary_key=True)
account_id = db.Column(db.String(100), db.ForeignKey('account.email'))
account = db.relationship('Account',
backref=db.backref('favorites', lazy='dynamic'))
book_id = db.Column(db.Integer, db.ForeignKey('book.id'))
book = db.relationship('Book',
backref=db.backref('favorites', lazy='dynamic'))
def __init__(self, account, book):
self.account = account
self.book = book
def __repr__(self):
return '<Favorite %r>' % self.account_id
class CSRFToken(db.Model):
__tablename__ = 'csrf_token'
csrf_id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String())
expired = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
@classmethod
def generate_csrf_token(cls, user):
# first, check for expired CSRF tokens
tokens = cls.query.filter_by(user_csrf_tokens=user).all()
for token in tokens:
if token.expired < datetime.datetime.now():
db.session.delete(token)
# there should be maximum 10 CSRF tokens per user and not more, check and delete oldest one
if len(tokens) >= 10:
oldest_token = min(tokens, key=attrgetter("expired"))
db.session.delete(oldest_token)
# generate csrf token and save it to CSRF table
csrf_token = secrets.token_hex()
csrf = cls(token=csrf_token,
expired=datetime.datetime.now() +
datetime.timedelta(hours=1),
user_csrf_tokens=user)
db.session.add(csrf)
db.session.commit()
return csrf_token
@classmethod
def validate_csrf_token(cls, csrf_token):
if csrf_token:
# validate CSRF token from form
csrf_success = cls.query.filter_by(token=csrf_token).first()
if csrf_success:
return True
else:
return False
else:
return False
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False, unique=True)
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)
users = db.relationship('User',
backref='role',
cascade='all, delete-orphan')
def __repr__(self):
return self.name
class Presale(db.Model):
__tablename__ = 'presale'
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(255))
email = db.Column(db.String(255))
accredited = db.Column(db.Boolean())
entity_type = db.Column(db.String(255))
desired_allocation = db.Column(db.String(255))
desired_allocation_currency = db.Column(db.String(3))
citizenship = db.Column(db.String(2))
sending_addr = db.Column(db.String(255))
note = db.Column(db.Text())
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
ip_addr = db.Column(db.String(100))
def __str__(self):
return '%s' % (self.email)
class SubjectModel(db.Model):
__tablename__ = 'subjects'
id = db.Column(db.Integer, primary_key=True)
parent_id = db.Column(db.Integer, db.ForeignKey('subjects.id'))
name = db.Column(db.String(80), nullable=False)
content = db.relationship('ContentModel',
secondary=tags,
backref='tag_content')
parent = db.relationship('SubjectModel',
remote_side=id,
backref='parent_subject')
def __init__(self, name=None, parent_id=None, _id=None):
self.name = name
self.parent_id = parent_id
self.id = _id
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {
"subject_id": self.id,
"parent_id": self.parent_id,
"subject_name": self.name
}
@classmethod
def find_by_subject_id(cls, subject_id):
return cls.query.filter_by(id=subject_id).first()
@classmethod
def find_by_child_id(cls, subject_id):
return cls.query.filter_by(parent_id=subject_id).first()
@classmethod
def find_by_subject_name(cls, name):
return cls.query.filter_by(name=name).first()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Air(db.Model):
__tablename__ = 'air'
Time = db.Column(db.Integer, primary_key=True)
Id = db.Column(db.Integer, primary_key=True)
Station = db.Column(db.String(50))
Longitude = db.Column(db.Float)
Latitude = db.Column(db.Float)
CarbonMonoxide = db.Column(db.Float)
Ozone = db.Column(db.Float)
NitrogenDioxide = db.Column(db.Float)
SulfurDioxide = db.Column(db.Float)
PM25 = db.Column(db.Float)
PM10 = db.Column(db.Float)
VisibilityReduction = db.Column(db.Float)
AQI = db.Column(db.Float)
Summary = db.Column(db.Float)
def __init__(self, Time, Id, Station, Longitude, Latitude, CarbonMonoxide, Ozone, NitrogenDioxide, SulfurDioxide, PM25, PM10, VisibilityReduction, AQI, Summary):
self.Time = Time
self.Id = Id
self.Station = Station
self.Longitude = Longitude
self.Latitude = Latitude
self.CarbonMonoxide = CarbonMonoxide
self.Ozone = Ozone
self.NitrogenDioxide = NitrogenDioxide
self.SulfurDioxide = SulfurDioxide
self.PM25 = PM25
self.PM10 = PM10
self.VisibilityReduction = VisibilityReduction
self.AQI = AQI
if Summary == 'VERY GOOD':
self.Summary = 5
elif Summary == 'GOOD':
self.Summary = 4
elif Summary == 'FAIR':
self.Summary = 3
elif Summary == 'POOR':
self.Summary = 2
elif Summary == 'VERY POOR':
self.Summary = 1
else:
self.Summary = float('nan')
class ContentModel(db.Model):
__tablename__ = 'contents'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
text = db.Column(db.Text)
owner = db.relationship('UserModel',
secondary=content_owners,
backref='content_owners')
subject = db.relationship('SubjectModel',
secondary=tags,
backref='tag_subject')
levels = db.relationship('LevelModel',
secondary="coninlevels",
viewonly=True)
def __init__(self, name, text, _id=None):
self.name = name
self.text = text
self.id = _id
self.levels = []
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
'content_id': self.id,
'content_name': self.name,
'content': self.text
}
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
class Engine(db.Model):
'''
A model for an engine, encapsulating the attributes we track for
the engine.
'''
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
cylinder = db.Column(db.Integer)
fuel_type = db.Column(db.String)
horsepower = db.Column(db.Integer)
torque = db.Column(db.Integer)
def __init__(self, name, cylinder, fuel_type, horsepower, torque):
self.name = name
self.cylinder = cylinder
self.fuel_type = fuel_type
self.horsepower = horsepower
self.torque = torque
class Semester(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
start = db.Column(db.Date)
end = db.Column(db.Date)
def __init__(self, name, start, end):
self.name = name
self.start = start
self.end = end
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'start': str(self.start),
'end': str(self.end),
}
class Story(db.Model):
__tablename__='story'
id = db.Column(db.Integer, unique = True, autoincrement = True, primary_key = True)
title = db.Column(db.String(200), unique=True, nullable=False)
description = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
#Relationships
chapters = db.relationship('Chapter', backref='story', lazy='dynamic', uselist=True, cascade="all, delete-orphan")
def as_dict(self):
return {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
#return 'Point(x=%s, y=%s)' % (self.x, self.y)
#this is to create like a printable object
def __repr__(self):
return '<ID: %s; Title: %s; Description: %s>' % (
self.id, self.title, self.description)
class Token(db.Model):
tokenId = db.Column(db.Integer, primary_key=True)
string = db.Column(db.String(20))
created_at = db.Column(db.DateTime)
expired = db.Column(db.Boolean)
user_id = db.Column(db.Integer,
db.ForeignKey("user.userId"),
nullable=False)
user = db.relationship("User", backref=db.backref("tokens", lazy=True))
def __init__(self, user):
self.user = user
self.string = f"{generate_token()}=="
self.created_at = datetime.utcnow()
self.expired = False
def __repr__(self):
return f"<Token '{self.string}'>"
class Network(db.Model):
"""
A network object
The status can be
- created
- updated
- healthy
- deleted
- failed
"""
__tablename__ = 'networks'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
password = db.Column(db.String)
port = db.Column(db.Integer)
netmask = db.Column(db.Integer)
ip = db.Column(db.String)
status = db.Column(db.String())
class DeckCard(db.Model):
__tablename__ = 'deck_cards'
deck_id = db.Column(db.Integer, db.ForeignKey(Deck.id), primary_key=True)
card_oracle_id = db.Column(db.String(128),
db.ForeignKey(Card.oracle_id),
primary_key=True)
qty_main = db.Column(db.Integer, nullable=False, server_default='0')
qty_sideboard = db.Column(db.Integer, nullable=False, server_default='0')
is_commander = db.Column(db.Boolean,
nullable=False,
server_default='false')
is_companion = db.Column(db.Boolean,
nullable=False,
server_default='false')
card = db.relationship('Card', back_populates='decks')
deck = db.relationship('Deck', back_populates='cards')
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), unique=True)
# _search_on = 'slug'
def __init__(self, name=None):
'''
name - Team name
'''
self.name = name
def to_json(self):
return dict(type='teams', id=self.id, name=self.name)
def __repr__(self):
return '<Team {0}>'.format(self.name)
class JobComment(db.Model):
"""Job comment model.
Parameters
----------
db : Model
"""
__tablename__ = 'job_comment'
id = db.Column(db.Integer, primary_key=True)
details = db.Column(db.String(256))
made = db.Column(db.DateTime)
job_id = db.Column(db.Integer, db.ForeignKey('job.id'))
job = db.relationship('Job', backref=db.backref('job_comments', lazy=True))
resource_id = db.Column(db.Integer, db.ForeignKey('resource.id'))
resource = db.relationship('Resource', backref='job_comments')
class Food(db.Model):
id = db.Column(db.Integer, primary_key=True)
meal_id = db.Column(db.Integer)
name = db.Column(db.String(50), default='New Food')
calories = db.Column(db.Float(), default=0)
protein = db.Column(db.Float(), default=0)
carbohydrates = db.Column(db.Float(), default=0)
fat = db.Column(db.Float(), default=0)
def data(self):
return {
'id': self.id,
'name': self.name,
'calories': self.calories,
'carbohydrates': self.carbohydrates,
'protein': self.protein,
'fat': self.fat
}
class Map(db.Model):
__tablename__ = 'maps'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
maxX = db.Column(db.Integer)
maxY = db.Column(db.Integer)
zones = db.relationship('Zone', secondary=maps_help)
'''def __init__(self, id, name, maxX, maxY):
self.id = id
self.name = name
self.maxX = maxX
self.maxY = maxY'''
def asDict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def __repr__(self):
return '<id {0}'.format(self.id)
class Transaction(CustomModelMixin, Model):
__tablename__ = 'transactions'
txn_no = Column(db.String(255), unique=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
phone_number = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(255))
message = Column(db.Text, nullable=True)
# valid types are order and donation
type = Column(db.String(255))
payment_status = Column(ChoiceType(PAYMENT_STATUS, impl=db.String()))
total_amount = Column(db.Float, nullable=False)
discounted_amount = Column(db.Float, nullable=True)
discount_id = reference_col("discounts", nullable=True)
date_created = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
date_paid = Column(db.DateTime, nullable=True)
payment_txn_number = Column(db.String(255), nullable=True)
discount = relationship("Discount")
def generate_txn_number(self):
self.txn_no = f"TXN{dt.date.today().strftime('%Y%m%d')}00000{self.id}"
@property
def get_amount_paid(self):
return self.discounted_amount if self.discounted_amount else self.total_amount
@property
def full_name(self):
return f'{self.first_name} {self.last_name}'
@property
def get_items(self):
if self.type == 'order':
return self.orders
return self.donations
def __str__(self):
return self.txn_no
