class Directory(db.Model, ModelMixin): user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False) name = db.Column(db.String(128), unique=True, nullable=False) user = db.relationship(User) def nb_alias(self): return GenEmail.filter_by(directory_id=self.id).count() def __repr__(self): return f"<Directory {self.name}>"
class ClientManager(db.Model): __tablename__ = 'client_manager' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) manager = db.relationship(user_model, backref="clients") clients = db.relationship(ClientModel, secondary=client_user_association, cascade='all') def __str__(self): return str(self.manager)
class Shops(db.Model): __tablename__ = 'shops' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) city = db.Column(db.Integer, db.ForeignKey('city.id')) describe = db.Column(db.Text, nullable=True) adress = db.Column(db.String(100), nullable=False) score = db.Column(db.Integer, nullable=False, default=5) pictures = db.Column(db.Text, nullable=False) price = db.Column(db.Integer, nullable=False) type = db.Column(db.String(20), nullable=True) comment = db.relationship('shop_comments', backref='shop', lazy='lazy')
class MineVerifiedStatus(Base): __tablename__ = 'mine_verified_status' mine_verified_status_id = db.Column(db.Integer, primary_key=True, server_default=FetchedValue()) mine_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('mine.mine_guid')) healthy_ind = db.Column(db.Boolean, nullable=False, server_default=FetchedValue()) verifying_user = db.Column(db.String, nullable=False, default=User().get_user_username) verifying_timestamp = db.Column(db.DateTime, nullable=False, server_default=FetchedValue()) update_user = db.Column(db.String(60), nullable=False, default=User().get_user_username, onupdate=User().get_user_username) update_timestamp = db.Column(db.DateTime, nullable=False, server_default=FetchedValue(), onupdate=datetime.datetime.now) mine = db.relationship('Mine', backref=backref("verified_status", uselist=False, lazy='joined'), lazy='select', uselist=False) def json(self): return { 'mine_guid': str(self.mine_guid), 'mine_name': self.mine.mine_name, 'healthy': self.healthy_ind, 'verifying_user': self.verifying_user, 'verifying_timestamp': str(self.verifying_timestamp) } @classmethod def find_by_mine_guid(cls, mine_guid): try: uuid.UUID(mine_guid, version=4) return cls.query.filter_by(mine_guid=mine_guid).first() except ValueError: return None @classmethod def find_by_user_id(cls, user_id): return cls.query.filter_by(verifying_user=user_id).all()
class Image(db.Model): """Class to represent an image""" __tablename__ = "images" id = db.Column(db.Integer, primary_key=True) path = db.Column(db.Text(), unique=True, index=True, nullable=False) uploaded_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) image_type_id = db.Column(db.Integer, db.ForeignKey("image_types.id"), nullable=False) event_id = db.Column(db.Integer, db.ForeignKey("events.id"), nullable=False) def __repr__(self): """Return a string representation of the Image class. Used for debugging purposes """ return "<Image at: %r>" % self.path
class VarianceDocumentXref(Base): __tablename__ = "variance_document_xref" variance_document_xref_guid = db.Column(UUID(as_uuid=True), primary_key=True, server_default=FetchedValue()) mine_document_guid = db.Column( UUID(as_uuid=True), db.ForeignKey('mine_document.mine_document_guid')) variance_id = db.Column(db.Integer, db.ForeignKey('variance.variance_id'), server_default=FetchedValue()) created_at = db.Column(db.DateTime, server_default=FetchedValue()) mine_document = db.relationship('MineDocument', lazy='joined') mine_guid = association_proxy('mine_document', 'mine_guid') document_manager_guid = association_proxy('mine_document', 'document_manager_guid') document_name = association_proxy('mine_document', 'document_name') def __repr__(self): return '<VarianceDocumentXref %r>' % self.variance_document_xref_guid
class ResetPasswordCode(db.Model, ModelMixin): """For resetting password""" user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False) code = db.Column(db.String(128), unique=True, nullable=False) user = db.relationship(User) expired = db.Column(ArrowType, nullable=False, default=_expiration_1h) def is_expired(self): return self.expired < arrow.now()
class AliasUsedOn(db.Model, ModelMixin): """Used to know where an alias is created""" __table_args__ = ( db.UniqueConstraint("gen_email_id", "hostname", name="uq_alias_used"), ) gen_email_id = db.Column( db.ForeignKey(GenEmail.id, ondelete="cascade"), nullable=False ) hostname = db.Column(db.String(1024), nullable=False)
class Posts(db.Model): __tablename__ = 'posts' id = db.Column(db.Integer,primary_key=True,autoincrement=True) # 评论帖子id # id rid # 1 0 表示新发表的 # 2 1 表示对第一篇帖子的评论 rid = db.Column(db.Integer,index=True,default=0) # index 创建索引, 默认是0 content = db.Column(db.Text) timestamp = db.Column(db.DateTime,default=datetime.utcnow) uid = db.Column(db.Integer, db.ForeignKey('users.id'))
class Message(SurrogatePK, Model): __tablename__ = 'messages' user_id = Column(db.Integer, db.ForeignKey('users.id')) body = Column(db.String(140)) timestamp = Column(db.DateTime(timezone=True), index=True, default=maya.now().datetime) user = relationship('User', back_populates='messages', lazy='joined') def __repr__(self): return '<Message {}>'.format(self.body)
class SandGrvQryActivity(Base): __tablename__ = "sand_grv_qry_activity" __table_args__ = {"schema": "now_submissions"} id = db.Column(db.Integer, primary_key=True, server_default=FetchedValue()) messageid = db.Column( db.Integer, db.ForeignKey('now_submissions.application.messageid')) type = db.Column(db.String) disturbedarea = db.Column(db.Numeric(14, 2)) timbervolume = db.Column(db.Numeric(14, 2)) def __repr__(self): return '<SandGrvQryActivity %r>' % self.id
class ProdutoVenda(db.Model): __tablename__ = 'produtovenda_tb' produtovendaid = db.Column(db.Integer, primary_key=True) vendaid = db.Column(db.Integer, db.ForeignKey('venda_tb.vendaid'), nullable=False) produtoid = db.Column(db.Integer, db.ForeignKey('produto_tb.produtoid'), nullable=False) qtdproduto = db.Column(db.Integer, nullable=False) dt_inclusao = db.Column(db.DateTime) def __init__(self, vendaid, produtoid, qtdproduto, produtovendaid=None): self.produtovendaid = produtovendaid self.vendaid = vendaid self.produtoid = produtoid self.qtdproduto = qtdproduto def serialize(self): return {"produtoid": self.produtoid, "qtdproduto": self.qtdproduto}
class MqttAccess(db.Model): """ Represent MQTT access """ __tablename__ = 'mqtt_access' id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, default=datetime.utcnow) updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow) topic = db.Column(db.String(256), nullable=False) access = db.Column(db.Integer, nullable=False, default=1) username = db.Column(db.String(32), db.ForeignKey('mqtt_clients.username'))
class Spots(db.Model): __tablename__ = 'spots' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) city = db.Column(db.Integer, db.ForeignKey('city.id')) describe = db.Column(db.Text, nullable=True) adress = db.Column(db.String(100), nullable=False) score = db.Column(db.Integer, nullable=False, default=5) pictures = db.Column(db.Text, nullable=False) price = db.Column(db.Integer, nullable=False) type = db.Column(db.String(20), nullable=True) rank = db.Column(db.Integer, nullable=True, default=5)
class SurfaceBulkSampleActivity(Base): __tablename__ = "surface_bulk_sample_activity" __table_args__ = {"schema": "now_submissions"} id = db.Column(db.Integer, primary_key=True) messageid = db.Column( db.Integer, db.ForeignKey('now_submissions.application.messageid')) type = db.Column(db.String) disturbedarea = db.Column(db.Numeric(14, 2)) timbervolume = db.Column(db.Numeric(14, 2)) def __repr__(self): return '<SurfaceBulkSampleActivity %r>' % self.id
class UndergroundExploration(ActivitySummaryBase): __tablename__ = "underground_exploration" __mapper_args__ = { 'polymorphic_identity': 'underground_exploration', ## type code } activity_summary_id = db.Column( db.Integer, db.ForeignKey('activity_summary.activity_summary_id'), primary_key=True) total_ore_amount = db.Column(db.Integer) total_ore_unit_type_code = db.Column(db.String, db.ForeignKey('unit_type.unit_type_code')) total_waste_amount = db.Column(db.Integer) total_waste_unit_type_code = db.Column(db.String, db.ForeignKey('unit_type.unit_type_code')) proposed_activity = db.Column(db.String) details = db.relationship( 'UndergroundExplorationDetail', secondary='activity_summary_detail_xref', load_on_pending=True) def __repr__(self): return '<UndergroundExploration %r>' % self.activity_summary_id
class Notification(db.Model): __tablename__ = 'notifications' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) name = db.Column(db.String(128), index=True) timestamp = db.Column(db.Float, index=True, default=time) payload_json = db.Column(db.Text) def get_data(self): return json.loads(str(self.payload_json))
class SamplePlaceholder(db.Model): # pylint: disable=too-few-public-methods """Placeholder for Mongo Sample in SampleGroup<->Sample relationship.""" sample_id = db.Column(UUID(as_uuid=True), primary_key=True) sample_group_id = db.Column(UUID(as_uuid=True), db.ForeignKey('sample_groups.id'), primary_key=True) def __init__(self, sample_id=None, sample_group_id=None): """Initialize SampleGroup<->SamplePlaceholder model.""" self.sample_id = sample_id self.sample_group_id = sample_group_id
class Posts(db.Model): __tablename__ = 'posts' id = db.Column(db.Integer, primary_key=True) rid = db.Column(db.Integer, index=True, default=0) content = db.Column(db.Text) timestamp = db.Column(db.DateTime, default=datetime.utcnow) views = db.Column(db.Integer,default=0) # 外键 uid = db.Column(db.Integer, db.ForeignKey('users.id')) comments = db.relationship('Comments', backref='post', lazy='dynamic')
class Post(Base): __tablename__ = 'post' STATUS_DRAFT = 0 STATUS_PUBLIC = 1 STATUS_DELETED = 2 FORMAT_MARKDOWN = 0 FORMAT_HTML = 1 FORMAT_TEXT = 2 title = db.Column(db.String(100)) slug = db.Column(db.String(100), unique=True) body = db.Column(db.Text) status = db.Column(db.SmallInteger, default=STATUS_DRAFT) format = db.Column(db.SmallInteger, default=FORMAT_MARKDOWN) author_id = db.Column(db.Integer, db.ForeignKey('user.id')) author = db.relationship('User', backref=db.backref('posts', lazy='dynamic')) category_id = db.Column(db.Integer, db.ForeignKey('page_category.id')) category = db.relationship('PageCategory', backref=db.backref('posts', lazy='dynamic')) tags = db.relationship('Tag', secondary=post_tag, backref=db.backref('posts', lazy='dynamic'), lazy='dynamic') def get_slug_url(self): return url_for('page.post_detail_slug', slug=self.slug) def get_permanent_url(self): return url_for('page.post_detail_id', post_id=self.id) def __init__(self, *args, **kwargs): super(Post, self).__init__(*args, **kwargs) def __repr__(self): return '<Post: %r>' % self.title
class MineType(AuditMixin, Base): __tablename__ = "mine_type" mine_type_guid = db.Column(UUID(as_uuid=True), primary_key=True, server_default=FetchedValue()) mine_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('mine.mine_guid'), nullable=False) mine_tenure_type_code = db.Column(db.String, db.ForeignKey('mine_tenure_type_code.mine_tenure_type_code'), nullable=False) active_ind = db.Column(db.Boolean, nullable=False, default=True) mine_type_detail = db.relationship('MineTypeDetail', backref='mine_type', order_by='desc(MineTypeDetail.update_timestamp)', lazy='select') mine_tenure_type = db.relationship('MineTenureTypeCode', backref='mine_types', load_on_pending=True) def __repr__(self): return '<MineType %r>' % self.mine_type_guid def active(self, records): return list(filter(lambda x: x.active_ind, records)) @classmethod def create(cls, mine_guid, mine_tenure_type_code, add_to_session=True): mine_type = cls(mine_guid=mine_guid, mine_tenure_type_code=mine_tenure_type_code) if add_to_session: mine_type.save(commit=False) return mine_type @classmethod def find_by_guid(cls, _id): uuid.UUID(_id, version=4) return cls.query.filter_by(mine_type_guid=_id).first() def expire_record(self): for detail in self.mine_type_detail: detail.expire_record() self.active_ind = False self.save()
class OrderDetail(db.Model, CRUDModel): id = db.Column(db.Integer, primary_key=True, autoincrement=True) number = db.Column(db.Integer) subtotal = db.Column(db.Integer) order_id = db.Column(db.Integer, db.ForeignKey('order.id')) product_id = db.Column(db.Integer, db.ForeignKey('product.id')) # Many-to-one order = db.relationship('Order', back_populates='order_details') product = db.relationship('Product', back_populates='order_details') def __repr__(self): return ("<{class_name}(" "id='{self.id}'," ")>".format(class_name=self.__class__.__name__, self=self)) @classmethod def list(order_detail_cls, **kwargs): many = kwargs.pop('many', False) order_detail_list = order_detail_cls.query.filter_by(**kwargs).all() if len(order_detail_list) > 1 or many is True: return order_detail_list elif len(order_detail_list) == 1: return order_detail_list[0] else: return None @classmethod def create(order_detail_cls, **kwargs): product_id = kwargs.get('id') if product_id: kwargs['product_id'] = kwargs.pop('id') kwargs.pop('name') kwargs.pop('price') new_order_detail = order_detail_cls(**kwargs) db.session.add(new_order_detail) db.session.commit() return new_order_detail else: raise AttributeError('Please set the required fields')
class Bond(Base, AuditMixin): __tablename__ = "bond" class _ModelSchema(Base._ModelSchema): bond_id = fields.Integer(dump_only=True) bond_guid = fields.String(dump_only=True) bond_type_code = FieldTemplate(field=fields.String, one_of='BondType') bond_status_code = FieldTemplate(field=fields.String, one_of='BondStatus') bond_id = db.Column(db.Integer, primary_key=True, server_default=FetchedValue()) bond_guid = db.Column(UUID(as_uuid=True), nullable=False, server_default=FetchedValue()) amount = db.Column(db.Numeric(14, 2), nullable=False) bond_type_code = db.Column(db.String, db.ForeignKey('bond_type.bond_type_code')) payer_party_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('party.party_guid'), nullable=False) institution_party_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('party.party_guid'), nullable=False) bond_status_code = db.Column(db.String, db.ForeignKey('bond_status.bond_status_code')) reference_number = db.Column(db.String) permits = db.relationship('Permit', uselist=False, lazy='select', secondary='bond_permit_xref') def __repr__(self): return '<Bond %r>' % self.bond_guid @classmethod def find_by_bond_guid(cls, bond_guid): return cls.query.filter_by(bond_guid=bond_guid).first()
class Sponsorship(AbstractModel): """Class to represent a sponsorship deal.""" __tablename__ = "sponsorships" event_id = db.Column(db.Integer, db.ForeignKey("events.id"), primary_key=True) sponsor_id = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True) package_id = db.Column(db.Integer, db.ForeignKey("packages.id"), primary_key=True) timestamp = db.Column(db.DateTime, nullable=True) confirmation_code = db.Column(db.String(64), nullable=True) event = db.relationship("Event", back_populates="sponsorships") sponsor = db.relationship("User", back_populates="sponsorships") package = db.relationship("Package", back_populates="sponsorships") def is_current(self): """Return True if the sponsorship is for an event that has a status of live, return False otherwise. """ return self.event.is_ongoing() def is_past(self): """Return True if the sponsorship is for an event that has a status of past, return False otherwise. """ return self.event.has_ended() def __repr__(self): """Returns a string representation of a sponsorship deal. Used for debugging purposes. """ return "<[Event: %r, Sponsor: %r, Package: %r]>" % ( self.event_id, self.sponsor_id, self.package_id, )
class Event(db.Model): __tablename__ = 'user_event' public_id = db.Column(UUID(as_uuid=True), unique=True, server_default=text("uuid_generate_v4()")) id = db.Column(db.Integer, index=True, autoincrement=True, primary_key=True) # ---- Relationships ---- # user_id = db.Column(db.Integer, db.ForeignKey('user_table.id'), primary_key=True) # ---- Basic Event details ---- # title = db.Column(db.String(255), nullable=False) venue = db.Column(db.String(120), nullable=False) location = db.Column(db.String(120), nullable=False) description = db.Column(db.String(280), nullable=False) starts_at = db.Column(db.DateTime, index=True, nullable=False) ends_at = db.Column(db.DateTime, index=True, nullable=False) # ---- Meta data ---- # created_at = db.Column(db.DateTime, index=True, server_default=func.now()) updated_at = db.Column( db.DateTime, index=True, server_default=func.now()) # ToDo: fix auto updation def to_dict(self): data = { 'public_id': self.public_id, 'title': self.title, 'venue': self.venue, 'location': self.title, 'description': self.description, 'starts_at': self.starts_at, 'ends_at': self.ends_at, 'created_at': self.created_at, 'updated_at': self.updated_at } return data def from_dict(self, data): for field in [ 'user_id', 'title', 'venue', 'location', 'description', 'starts_at', 'ends_at' ]: if field in data: setattr(self, field, data[field]) def __repr__(self): return '<Event {}>'.format(self.id)
class MineLocation(AuditMixin, Base): __tablename__ = "mine_location" mine_location_guid = db.Column(UUID(as_uuid=True), primary_key=True) mine_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('mine_identity.mine_guid')) latitude = db.Column(db.Numeric(9, 7), nullable=False) longitude = db.Column(db.Numeric(11, 7), nullable=False) effective_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) expiry_date = db.Column(db.DateTime, nullable=False, default=datetime.strptime('9999-12-31', '%Y-%m-%d')) def __repr__(self): return '<MineLocation %r>' % self.mine_guid def json(self): lat = self.latitude lon = self.longitude return { 'mine_location_guid': str(self.mine_location_guid), 'mine_guid': str(self.mine_guid), 'latitude': str(lat), 'longitude': str(lon), } @classmethod def find_by_mine_guid(cls, _id): return cls.query.filter_by(mine_guid=_id).first() @classmethod def find_by_mine_location_guid(cls, _id): return cls.query.filter_by(mine_location_guid=_id).first() @classmethod def create_mine_location(cls, mine_identity, random_location, user_kwargs, save=True): mine_location = cls(mine_location_guid=uuid.uuid4(), mine_guid=mine_identity.mine_guid, latitude=random_location.get('latitude', 0), longitude=random_location.get('longitude', 0), effective_date=datetime.today(), expiry_date=datetime.today(), **user_kwargs) if save: mine_location.save(commit=False) return mine_location
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(60)) body = db.Column(db.Text) author = db.Column(db.String(20)) photo = db.Column(db.String(256)) slug = db.Column(db.String(128)) down_url = db.Column(db.String(256)) sources = db.Column(db.String(60)) recommend = db.Column(db.Boolean) timestamp = db.Column(db.DateTime, default=datetime.now, index=True) category_id = db.Column(db.Integer, db.ForeignKey('category.id')) category = db.relationship('Category', back_populates='posts')
class Employee(UserMixin, db.Model): """ Create an Employee table """ __tablename__ = 'employees' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(60), index=True, unique=True) username = db.Column(db.String(60), index=True, unique=True) first_name = db.Column(db.String(60), index=True) last_name = db.Column(db.String(60), index=True) password_hash = db.Column(db.String(128)) department_id = db.Column(db.Integer, db.ForeignKey('departments.id')) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) is_admin = db.Column(db.Boolean, default=False) @property def password(self): """ Prevents password from being accessed """ raise AttributeError('password is not a readable attribute.') @password.setter def password(self, password): """ Set password to a hashed password """ self.password_hash = generate_password_hash(password) def verify_password(self, password): """ Check if hashed password matches actual password """ return check_password_hash(self.password_hash, password) def __repr__(self): return '<Employee: {}>'.format(self.username)
class OAuth2Token(db.Model): """ OAuth2 Access Tokens storage model. """ __tablename__ = 'oauth2_token' id = db.Column(db.Integer, primary_key=True) # pylint: disable=invalid-name client_id = db.Column( db.String(length=40), db.ForeignKey('oauth2_client.client_id'), index=True, nullable=False, ) client = db.relationship('OAuth2Client') user_id = db.Column(db.ForeignKey('user.id', ondelete='CASCADE'), index=True, nullable=False) user = db.relationship('User') class TokenTypes(str, enum.Enum): # currently only bearer is supported Bearer = 'Bearer' token_type = db.Column(db.Enum(TokenTypes), nullable=False) access_token = db.Column(db.String(length=255), unique=True, nullable=False) refresh_token = db.Column(db.String(length=255), unique=True, nullable=True) expires = db.Column(db.DateTime, nullable=False) scopes = db.Column(ScalarListType(separator=' '), nullable=False) @classmethod def find(cls, access_token=None, refresh_token=None): if access_token: return cls.query.filter_by(access_token=access_token).first() elif refresh_token: return cls.query.filter_by(refresh_token=refresh_token).first() def delete(self): with db.session.begin(): db.session.delete(self)
class LegislationActSection(Base): __tablename__ = "legislation_act_section" __table_args__ = { 'comment': 'Contains a list of sections (or provisions of the act); i.e. "1.9.1", "1.5.1", etc.' } legislation_act_section_id = db.Column(db.Integer, primary_key=True) legislation_act_id = db.Column( db.Integer, db.ForeignKey('legislation_act.legislation_act_id')) section = db.Column(db.String(64)) def __repr__(self): return f'<LegislationActSection legislation_act_section_id={self.legislation_act_section_id} section={self.section}>'