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