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}>'
