class StateOfLand(Base):
__tablename__ = "state_of_land"
_edit_groups = [NOW_APPLICATION_EDIT_GROUP]
now_application_id = db.Column(
db.Integer, db.ForeignKey('now_application.now_application_id'), primary_key=True)
now_application = db.relationship('NOWApplication')
has_community_water_shed = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
has_archaeology_sites_affected = db.Column(
db.Boolean, nullable=False, server_default=FetchedValue())
present_land_condition_description = db.Column(db.String)
means_of_access_description = db.Column(db.String)
physiography_description = db.Column(db.String)
old_equipment_description = db.Column(db.String)
type_of_vegetation_description = db.Column(db.String)
recreational_trail_use_description = db.Column(db.String)
arch_site_protection_plan = db.Column(db.String)
fn_engagement_activities = db.Column(db.String)
cultural_heritage_description = db.Column(db.String)
has_shared_info_with_fn = db.Column(db.Boolean, nullable=True)
has_fn_cultural_heritage_sites_in_area = db.Column(db.Boolean, nullable=True)
has_activity_in_park = db.Column(db.Boolean, nullable=True)
is_on_private_land = db.Column(db.Boolean, nullable=True)
has_auth_lieutenant_gov_council = db.Column(db.Boolean, nullable=True)
def __repr__(self):
return '<StateOfLand %r>' % self.now_application_id
class HzManage(Base):
__tablename__ = 'hz_manage'
id = Column(Integer, primary_key=True)
user_name = Column(String(20), nullable=False, server_default=FetchedValue())
psd = Column(String(40), nullable=False, server_default=FetchedValue())
status = Column(Integer, nullable=False, server_default=FetchedValue())
class MineIncidentDocumentXref(Base):
__tablename__ = "mine_incident_document_xref"
mine_incident_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'))
mine_incident_id = db.Column(
db.Integer,
db.ForeignKey('mine_incident.mine_incident_id'),
server_default=FetchedValue())
mine_incident_document_type_code = db.Column(
db.String,
db.ForeignKey(
'mine_incident_document_type_code.mine_incident_document_type_code'
),
nullable=False)
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 '<MineIncidentDocumentXref %r>' % self.mine_incident_document_xref_guid
class ApplicationStatusCode(AuditMixin, Base):
__tablename__ = 'application_status_code'
application_status_code = db.Column(db.String(3),
primary_key=True,
server_default=FetchedValue())
description = db.Column(db.String(100), nullable=False)
display_order = db.Column(db.Integer, nullable=False)
active_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
def __repr__(self):
return '<ApplicationStatusCode %r>' % self.application_status_code
def json(self):
return {
'application_status_code': self.application_status_code,
'description': self.description,
}
@classmethod
def find_by_application_status_code(cls, code):
return cls.query.filter_by(application_status_code=code).first()
@classmethod
def find_all_active_application_status_code(cls):
try:
return cls.query.filter_by(active_ind=True).all()
except ValueError:
return None
class MineComment(Base, AuditMixin):
__tablename__ = "mine_comment"
mine_comment_id = db.Column(db.Integer, primary_key=True, server_default=FetchedValue())
mine_comment_guid = db.Column(UUID(as_uuid=True), nullable=False, server_default=FetchedValue())
mine_guid = db.Column(db.Integer, db.ForeignKey('mine.mine_guid'), nullable=False)
mine_comment = db.Column(db.String, nullable=False)
deleted_ind = db.Column(db.Boolean, nullable=False, default=False)
comment_user = db.Column(nullable=False, default=User().get_user_username)
comment_datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<MineComment %r>' % self.mine_comment_guid
@classmethod
def create(cls, mine, mine_comment, add_to_session=True):
new_comment = cls(mine_comment=mine_comment)
mine.comments.append(new_comment)
if add_to_session:
new_comment.save(commit=False)
return new_comment
@classmethod
def find_by_guid(cls, _id):
return cls.query.filter_by(mine_comment_guid=_id).filter_by(deleted_ind=False).first()
@classmethod
def find_by_mine_guid(cls, _id):
return cls.query.filter_by(mine_guid=_id).filter_by(deleted_ind=False).all()
class ArticleSchool(db.Model):
__tablename__ = 'article_school'
articleID = db.Column(db.Integer, primary_key=True)
communityID = db.Column(db.ForeignKey('community_school.communityID',
ondelete='CASCADE'),
index=True)
schoolID = db.Column(db.ForeignKey('school_info.schoolID',
ondelete='CASCADE'),
nullable=False,
index=True)
userID = db.Column(db.ForeignKey('user_info.userID', ondelete='CASCADE'),
index=True)
nickName = db.Column(db.String(20, 'utf8_unicode_ci'), nullable=False)
title = db.Column(db.String(50, 'utf8_unicode_ci'))
content = db.Column(db.String(5000, 'utf8_unicode_ci'))
viewNumber = db.Column(db.Integer, server_default=FetchedValue())
reply = db.Column(db.Integer, server_default=FetchedValue())
heart = db.Column(db.Integer, server_default=FetchedValue())
writtenTime = db.Column(db.DateTime)
community = db.relationship(
'CommunitySchool',
primaryjoin='ArticleSchool.communityID == CommunitySchool.communityID',
backref=backref('articles', cascade="all,delete"))
user_info = db.relationship(
'UserInfo',
primaryjoin='ArticleSchool.userID == UserInfo.userID',
backref=backref('article_schools', cascade="all,delete"))
school_info = db.relationship(
'SchoolInfo',
primaryjoin='ArticleSchool.schoolID == SchoolInfo.schoolID',
backref=backref('user_info_schools', cascade="all,delete"))
class Camp(ActivitySummaryBase):
__tablename__ = "camp"
__mapper_args__ = {
'polymorphic_identity': 'camp', ## type code
}
activity_summary_id = db.Column(
db.Integer,
db.ForeignKey('activity_summary.activity_summary_id'),
primary_key=True)
camp_name = db.Column(db.String)
camp_number_people = db.Column(db.String)
camp_number_structures = db.Column(db.String)
has_fuel_stored = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
has_fuel_stored_in_bulk = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
has_fuel_stored_in_barrels = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
volume_fuel_stored = db.Column(db.Integer)
details = db.relationship('CampDetail',
secondary='activity_summary_detail_xref',
load_on_pending=True)
def __repr__(self):
return '<Camp %r>' % self.activity_summary_id
class Power(Base):
__tablename__ = 'power'
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
id = Column(Integer, primary_key=True)
year = Column(Integer, nullable=False)
month = Column(Integer, nullable=False)
day = Column(Integer, nullable=False)
hour = Column(Integer, nullable=False)
minute = Column(Integer, nullable=False)
value = Column(Float, nullable=False)
pre_value = Column(Float)
createdAt = Column(DateTime, nullable=False, server_default=FetchedValue())
updatedAt = Column(DateTime, nullable=False, server_default=FetchedValue())
buildingId = Column(ForeignKey('building.id'), index=True)
building = relationship('Building',
primaryjoin='Power.buildingId == Building.id',
backref='powers')
def __repr__(self):
return f'<Power id:{self.id}>'
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
class Model(Base):
__tablename__ = 'model'
__table_args__ = {'mysql_collate': 'utf8_general_ci'}
id = Column(Integer, primary_key=True)
api_key = Column(String(100), nullable=False)
filename = Column(String(100), nullable=False)
filepath = Column(String(200), nullable=False)
learning_percent = Column(Float)
learning_log = Column(String(200))
learning_status = Column(Enum('STOP', 'LEARNING', 'COMPLETE', 'FAILURE'),
nullable=False,
server_default=FetchedValue())
target = Column(Enum('BROKEN', 'POWER'), nullable=False)
createdAt = Column(DateTime, nullable=False, server_default=FetchedValue())
updatedAt = Column(DateTime, nullable=False, server_default=FetchedValue())
buildingId = Column(ForeignKey('building.id'), index=True)
building = relationship('Building',
primaryjoin='Model.buildingId == Building.id',
backref='models')
def __repr__(self):
return f'<Model id:{self.id}>'
def as_dict(self):
return {x.name: getattr(self, x.name) for x in self.__table__.columns}
class ReclamationInvoice(Base, AuditMixin):
__tablename__ = "reclamation_invoice"
class _ModelSchema(Base._ModelSchema):
reclamation_invoice_id = fields.Integer(dump_only=True)
reclamation_invoice_guid = fields.String(dump_only=True)
reclamation_invoice_id = db.Column(db.Integer,
primary_key=True,
server_default=FetchedValue())
reclamation_invoice_guid = db.Column(UUID(as_uuid=True),
nullable=False,
unique=True,
server_default=FetchedValue())
permit_id = db.Column(db.Integer, db.ForeignKey('permit.permit_id'))
project_id = db.Column(db.String, nullable=False)
amount = db.Column(db.Numeric(14, 2), nullable=False)
vendor = db.Column(db.String, nullable=False)
permit = db.relationship('Permit', lazy='joined')
documents = db.relationship('ReclamationInvoiceDocument', lazy='select')
def __repr__(self):
return '<ReclamationInvoice %r>' % self.reclamation_invoice_guid
@classmethod
def find_by_reclamation_invoice_guid(cls, reclamation_invoice_guid):
return cls.query.filter_by(
reclamation_invoice_guid=reclamation_invoice_guid).first()
class PermitAmendmentDocument(AuditMixin, Base):
__tablename__ = "permit_amendment_document"
_edit_groups = [PERMIT_EDIT_GROUP, PERMIT_AMENDMENT_EDIT_GROUP]
permit_amendment_document_guid = db.Column(UUID(as_uuid=True),
primary_key=True,
server_default=FetchedValue())
permit_amendment_id = db.Column(
db.Integer,
db.ForeignKey('permit_amendment.permit_amendment_id'),
nullable=True)
document_name = db.Column(db.String, nullable=False)
mine_guid = db.Column(UUID(as_uuid=True), nullable=False)
document_manager_guid = db.Column(UUID(as_uuid=True))
active_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
deleted_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
permit_amendment = db.relationship(
'PermitAmendment',
backref='related_documents',
lazy='joined',
primaryjoin=
'and_(PermitAmendment.permit_amendment_id == PermitAmendmentDocument.permit_amendment_id, PermitAmendmentDocument.deleted_ind==False)',
)
mine_name = association_proxy('permit_amendment', 'permit.mine.mine_name')
@classmethod
def find_by_permit_amendment_document_guid(cls, _guid):
return cls.query.filter_by(permit_amendment_document_guid=_guid,
deleted_ind=False).first()
class MineDocument(AuditMixin, Base):
__tablename__ = 'mine_document'
mine_document_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'))
document_manager_guid = db.Column(UUID(as_uuid=True))
document_name = db.Column(db.String(40), nullable=False)
active_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
upload_date = db.Column(db.Date, nullable=False, default=datetime.utcnow)
mine_name = association_proxy('mine', 'mine_name')
@classmethod
def find_by_mine_guid(cls, mine_guid):
return cls.query.filter_by(mine_guid=mine_guid).filter_by(
active_ind=True).all()
@classmethod
def find_by_mine_document_guid(cls, mine_document_guid):
return cls.query.filter_by(
mine_document_guid=mine_document_guid).filter_by(
active_ind=True).first()
# TODO: Remove when mine_party_appt is refactored
def json(self):
return {
'mine_document_guid': str(self.mine_document_guid),
'mine_guid': str(self.mine_guid),
'document_manager_guid': str(self.document_manager_guid),
'document_name': self.document_name
}
class Workcondition(Base):
__tablename__ = 'workcondition'
wcond_id = Column(Integer, primary_key=True)
user_id = Column(ForeignKey('user.user_id'), nullable=False, index=True)
wp_id = Column(ForeignKey('workplace.wp_id'), nullable=False, index=True)
cont_id = Column(ForeignKey('workcontract.cont_id'), index=True)
start_work_date = Column(String(8))
start_work_time = Column(Time)
end_work_time = Column(Time)
start_rest_time = Column(Time)
end_rest_time = Column(Time)
amount_work_time = Column(Time)
amount_rest_time = Column(Time)
hourly_pay = Column(Integer)
monthly_pay = Column(Integer)
payday = Column(String(4))
pay_type = Column(String(45))
wcond_status = Column(Integer,
nullable=False,
server_default=FetchedValue())
created_time = Column(DateTime, server_default=FetchedValue())
updated_time = Column(DateTime)
cont = relationship(
'Workcontract',
primaryjoin='Workcondition.cont_id == Workcontract.cont_id',
backref='workconditions')
user = relationship('User',
primaryjoin='Workcondition.user_id == User.user_id',
backref='workconditions')
wp = relationship('Workplace',
primaryjoin='Workcondition.wp_id == Workplace.wp_id',
backref='workconditions')
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())
variance_document_category_code = db.Column(
db.String,
db.ForeignKey(
'variance_document_category_code.variance_document_category_code'),
nullable=False)
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 PermitAmendmentDocument(AuditMixin, Base):
__tablename__ = "permit_amendment_document"
permit_amendment_document_guid = db.Column(
UUID(as_uuid=True), primary_key=True, server_default=FetchedValue())
permit_amendment_id = db.Column(
db.Integer, db.ForeignKey('permit_amendment.permit_amendment_id'), nullable=True)
document_name = db.Column(db.String, nullable=False)
mine_guid = db.Column(UUID(as_uuid=True), nullable=False)
document_manager_guid = db.Column(UUID(as_uuid=True))
active_ind = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
permit_amendment = db.relationship('PermitAmendment', backref='documents', lazy='joined')
mine_name = association_proxy('permit_amendment', 'permit.mine.mine_name')
def json(self):
return {
'mine_guid':
str(self.mine_guid),
'document_guid':
str(self.permit_amendment_document_guid),
'document_name':
self.document_name,
'document_manager_guid':
str(self.document_manager_guid) if self.document_manager_guid else None
}
@classmethod
def find_by_permit_amendment_guid(cls, _guid):
return cls.query.filter_by(permit_amendment_document_guid=_guid).first()
class MineReportDefinition(Base):
__tablename__ = "mine_report_definition"
mine_report_definition_id = db.Column(db.Integer,
primary_key=True,
server_default=FetchedValue())
mine_report_definition_guid = db.Column(UUID(as_uuid=True), nullable=False)
name = db.Column(db.String, nullable=False)
description = db.Column(db.String, nullable=False)
compliance_article_id = db.Column(
db.Integer,
db.ForeignKey('compliance_article.compliance_article_id'),
nullable=False)
due_date_period_months = db.Column(db.Integer, nullable=False)
mine_report_due_date_type = db.Column(
db.String,
db.ForeignKey('mine_report_due_date_type.mine_report_due_date_type'),
nullable=False)
active_ind = db.Column(db.Boolean,
server_default=FetchedValue(),
nullable=False)
categories = db.relationship('MineReportCategory',
lazy='selectin',
secondary='mine_report_category_xref')
compliance_articles = db.relationship(
'ComplianceArticle',
lazy='selectin',
secondary='mine_report_definition_compliance_article_xref')
def __repr__(self):
return '<MineReportDefinition %r>' % self.mine_report_definition_guid
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
# descriptive fields
code = db.Column(db.String(255), unique=True)
name = db.Column(db.String(255), unique=True)
quantity_per_unit = db.Column(db.Integer)
list_price = db.Column(db.Float)
selling_price = db.Column(db.Float)
description = db.Column(db.Text)
discontinued = db.Column(db.Boolean())
# REF: Supplier (brand) table
supplier_id = db.Column(db.Integer(), db.ForeignKey(Supplier.id))
supplier = db.relationship(Supplier, backref='suppliers')
# auto-completed from database trigger (concatentates several fields)
fullname = db.Column(db.String(1000),
server_default=FetchedValue(),
server_onupdate=FetchedValue())
# intial amount; managed in a separate form
initial_volume = db.Column(db.Integer)
# REF: tags table
tags = db.relationship('Tag', secondary=product_tags_table)
def __str__(self):
return self.fullname
class NOWApplicationDocumentXref(AuditMixin, Base):
__tablename__ = "now_application_document_xref"
now_application_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'))
now_application_id = db.Column(
db.Integer,
db.ForeignKey('now_application.now_application_id'),
server_default=FetchedValue())
now_application_document_type_code = db.Column(
db.String,
db.ForeignKey(
'now_application_document_type.now_application_document_type_code')
)
mine_document = db.relationship('MineDocument', lazy='joined')
now_application_document_type = db.relationship(
'NOWApplicationDocumentType', 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 '<ApplicationDocumentXref %r>' % self.application_document_xref_guid
class FoodStockChangeLog(Base):
__tablename__ = 'food_stock_change_log'
id = Column(Integer, primary_key=True, autoincrement=True)
food_id = Column(Integer, nullable=False, index=True)
unit = Column(Integer, nullable=False, server_default=FetchedValue())
total_stock = Column(Integer, nullable=False, server_default=FetchedValue())
note = Column(String(100), nullable=False, server_default=FetchedValue())
class Client(Base):
__tablename__ = 'client'
id = Column(String(36), primary_key=True, nullable=False)
dateadded = Column(DateTime, server_default=FetchedValue())
firstname = Column(String(250), nullable=False)
lastname = Column(String(250), nullable=False)
title = Column(String(250))
company = Column(String(250))
location = Column(String(250))
email = Column(String(250))
campaign_management_email = Column(String(250))
phone = Column(String(250))
ulincid = Column(String(36), nullable=False)
lpass_email = Column(String(250))
lpass_ulinc = Column(String(250))
lpass_li = Column(String(250))
email_server_id = Column(Integer, nullable=False)
new_connection_wh = Column(String(250))
new_message_wh = Column(String(250))
send_message_wh = Column(String(250))
isactive = Column(Boolean, nullable=False)
clientmanager = Column(String(36), nullable=False)
daily_tasks_email_id = Column(String(36))
client_sheet_id = Column(String(100))
ulinc_cookie_id = Column(String(100))
dateupdated = Column(DateTime, server_default=FetchedValue())
class MineReportComment(Base):
__tablename__ = "mine_report_comment"
mine_report_comment_id = db.Column(db.Integer,
primary_key=True,
server_default=FetchedValue())
mine_report_comment_guid = db.Column(UUID(as_uuid=True), nullable=False)
mine_report_id = db.Column(db.Integer,
db.ForeignKey('mine_report.mine_report_id'))
mine_report_submission_id = db.Column(
db.Integer,
db.ForeignKey('mine_report_submission.mine_report_submission_id'))
minespace_user_id = db.Column(db.Integer,
db.ForeignKey('minespace_user.user_id'))
core_user_id = db.Column(db.Integer,
db.ForeignKey('core_user.core_user_id'))
comment = db.Column(db.String, nullable=False)
comment_visibility = db.Column(db.Boolean, nullable=False)
due_date = db.Column(db.DateTime, nullable=False)
submission_year = db.Column(db.Integer)
deleted_ind = db.Column(db.Boolean,
server_default=FetchedValue(),
nullable=False)
mine_report_submissions = db.relationship('MineReportSubmission',
lazy='joined')
def __repr__(self):
return '<MineReportComment %r>' % self.mine_report_comment_guid
class MinePartyAppointmentType(AuditMixin, Base):
__tablename__ = "mine_party_appt_type_code"
mine_party_appt_type_code = db.Column(db.String(3), primary_key=True)
description = db.Column(db.String(100), nullable=False)
display_order = db.Column(db.Integer)
active_ind = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
person = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
organization = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
grouping_level = db.Column(db.Integer)
def json(self):
return {
'mine_party_appt_type_code': self.mine_party_appt_type_code,
'description': self.description,
'display_order': self.display_order,
'person': self.person,
'organization': self.organization,
'grouping_level': self.grouping_level,
'active_ind': self.active_ind
}
@classmethod
def find_by_mine_party_appt_type_code(cls, code):
try:
return cls.query.filter_by(mine_party_appt_type_code=code).first()
except ValueError:
return None
@classmethod
def find_all_active(cls):
try:
return cls.query.filter_by(active_ind=True).all()
except ValueError:
return None
class MsswUtility(Base):
__tablename__ = 'mssw_utility'
__table_args__ = (
Index('utility_fk_dict_sub_group_id_2_pub_dict_idx',
'fk_dict_utility_main_group_id', 'fk_dict_utility_sub_group_id'),
)
id = Column(Integer, primary_key=True)
name = Column(String(64), nullable=False)
display_name = Column(String(128), nullable=False)
fk_dict_utility_main_group_id = Column(
ForeignKey('pub_dict.id'), nullable=False, index=True)
fk_dict_utility_sub_group_id = Column(
ForeignKey('pub_dict.id'), nullable=False, index=True)
disabled = Column(Integer, nullable=False, server_default=FetchedValue())
operator_id = Column(ForeignKey('user.id'), index=True)
operate_time = Column(DateTime, nullable=False,
server_default=FetchedValue())
description = Column(String(200))
fk_dict_utility_main_group = relationship(
'PubDict', primaryjoin='MsswUtility.fk_dict_utility_main_group_id == PubDict.id', backref='pubdict_mssw_utilities')
fk_dict_utility_sub_group = relationship(
'PubDict', primaryjoin='MsswUtility.fk_dict_utility_sub_group_id == PubDict.id', backref='pubdict_mssw_utilities_0')
operator = relationship(
'User', primaryjoin='MsswUtility.operator_id == User.id', backref='mssw_utilities')
class MineDocument(AuditMixin, Base):
__tablename__ = 'mine_document'
mine_document_guid = db.Column(
UUID(as_uuid=True), primary_key=True, server_default=FetchedValue())
mine_guid = db.Column(
UUID(as_uuid=True), db.ForeignKey('mine_identity.mine_guid'))
document_manager_guid = db.Column(UUID(as_uuid=True))
document_name = db.Column(db.String(40), nullable=False)
active_ind = db.Column(
db.Boolean, nullable=False, server_default=FetchedValue())
mine_expected_document = db.relationship(
'MineExpectedDocument', secondary='mine_expected_document_xref')
def json(self):
return {
'mine_document_guid': str(self.mine_document_guid),
'mine_guid': str(self.mine_guid),
'document_manager_guid': str(self.document_manager_guid),
'document_name': str(self.document_name),
'active_ind': str(self.active_ind),
}
@classmethod
def find_by_mine_guid(cls, mine_guid):
return cls.query.filter_by(mine_guid=mine_guid).filter_by(
active_ind=True).all()
class MinePartyAppointmentType(AuditMixin, Base):
__tablename__ = "mine_party_appt_type_code"
mine_party_appt_type_code = db.Column(db.String(3), primary_key=True)
description = db.Column(db.String(100), nullable=False)
display_order = db.Column(db.Integer)
active_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
person = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
organization = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
grouping_level = db.Column(db.Integer)
@classmethod
def find_by_mine_party_appt_type_code(cls, code):
try:
return cls.query.filter_by(mine_party_appt_type_code=code).first()
except ValueError:
return None
@classmethod
def get_all(cls):
try:
return cls.query.order_by(desc(cls.grouping_level),
cls.display_order).all()
except ValueError:
return None
class ExpectedDocumentStatus(AuditMixin, Base):
__tablename__ = 'mine_expected_document_status_code'
exp_document_status_code = db.Column(db.String(3),
primary_key=True,
server_default=FetchedValue())
description = db.Column(db.String(100), nullable=False)
display_order = db.Column(db.Integer, nullable=False)
active_ind = db.Column(db.Boolean,
nullable=False,
server_default=FetchedValue())
def __repr__(self):
return '<ExpectedDocumentStatus %r>' % self.exp_document_status_code
def json(self):
return {
'exp_document_status_code': self.exp_document_status_code,
'description': self.description,
}
@classmethod
def find_by_expected_document_status(cls, code):
return cls.query.filter_by(exp_document_status_code=code).first()
@classmethod
def find_all_document_status(cls):
try:
return cls.query.filter_by(active_ind=True).all()
except ValueError:
return None
class Coupon_Info(db.Model):
__tablename__ = 'coupon_info'
Id = db.Column(Integer, primary_key=True)
Coupon_Name = db.Column(String(128),
nullable=False,
server_default=FetchedValue())
ShopId = db.Column(Integer, nullable=False, server_default=FetchedValue())
Coupon_Price = db.Column(DECIMAL,
nullable=False,
server_default=FetchedValue())
Member_Id = db.Column(Integer,
nullable=False,
server_default=FetchedValue())
Price = db.Column(DECIMAL, nullable=False, server_default=FetchedValue())
CreateTime = db.Column(DateTime,
nullable=False,
server_default=FetchedValue())
UpdateTime = db.Column(DateTime,
nullable=False,
server_default=FetchedValue())
Status = db.Column(Integer, nullable=False, server_default=FetchedValue())
QrCode_Url = db.Column(String(128),
nullable=False,
server_default=FetchedValue())
Order_sn = db.Column(String(128),
nullable=False,
server_default=FetchedValue())
class MineIncidentRecommendation(AuditMixin, Base):
__tablename__ = 'mine_incident_recommendation'
mine_incident_recommendation_id = db.Column(
db.Integer, primary_key=True, server_default=FetchedValue())
mine_incident_id = db.Column(
db.Integer, db.ForeignKey('mine_incident.mine_incident_id'), nullable=False)
recommendation = db.Column(db.String, nullable=False)
mine_incident_recommendation_guid = db.Column(UUID(as_uuid=True), nullable=False, server_default=FetchedValue())
deleted_ind = db.Column(db.Boolean, nullable=False, server_default=FetchedValue())
@classmethod
def create(cls, recommendation, mine_incident_id, add_to_session=True):
new_recommendation = cls(recommendation=recommendation, mine_incident_id=mine_incident_id)
if add_to_session:
new_recommendation.save(commit=False)
return new_recommendation
@classmethod
def find_by_mine_incident_recommendation_guid(cls, _id):
try:
uuid.UUID(str(_id), version=4)
return cls.query.filter_by(mine_incident_recommendation_guid=_id).filter_by(deleted_ind=False).first()
except ValueError:
raise AssertionError(INVALID_MINE_INCIDENT_RECOMMENDATION_GUID)
class InspectionRecord(LocalModel):
__tablename__ = "inspection_record"
id = Column(Integer, primary_key=True)
location_id = Column(Integer, ForeignKey("location.id"), nullable=False)
date_created = Column(
DateTime,
nullable=False,
server_default=sql.text("CURRENT_TIMESTAMP"),
server_onupdate=FetchedValue(),
)
inspector_id = Column(Integer, ForeignKey("user.id"), nullable=False)
inspector_submitted = Column(DateTime)
contact_id = Column(Integer, ForeignKey("person.id"), nullable=False)
contact_reviewed = Column(DateTime)
pharmacist_id = Column(Integer, ForeignKey("user.id"))
manager_reviewed = Column(DateTime)
comment = Column(TEXT)
is_active = Column(TINYINT, nullable=False, server_default="1")
last_updated = Column(
DateTime,
nullable=False,
server_default=sql.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
server_onupdate=FetchedValue(),
)
last_updated_by = Column(Integer, nullable=False)
# Relationships
location = relationship("Location")
inspector = relationship("User", foreign_keys=[inspector_id])
contact = relationship("Person")
pharmacist = relationship("User", foreign_keys=[pharmacist_id])
class Bond(Base, AuditMixin):
__tablename__ = "bond"
class _ModelSchema(Base._ModelSchema):
bond_id = fields.Integer(dump_only=True)
bond_guid = fields.UUID(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,
unique=True,
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'))
issue_date = db.Column(db.DateTime)
payer_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)
institution_name = db.Column(db.String)
institution_street = db.Column(db.String)
institution_city = db.Column(db.String)
institution_province = db.Column(
db.String, db.ForeignKey('sub_division_code.sub_division_code'))
institution_postal_code = db.Column(db.String)
note = db.Column(db.String)
project_id = db.Column(db.String)
payer = db.relationship('Party', lazy='joined')
permit = db.relationship('Permit',
uselist=False,
lazy='joined',
secondary='bond_permit_xref')
documents = db.relationship('BondDocument', lazy='select')
def __repr__(self):
return '<Bond %r>' % self.bond_guid
def save_bond_history(self):
bond_json = marshal(self, BOND)
del bond_json['bond_guid']
del bond_json['documents']
bond_json['payer_name'] = bond_json['payer']['party_name']
current_app.logger.info(bond_json)
bond_hist = BondHistory._schema().load(bond_json)
bond_hist.save()
return bond_hist
@classmethod
def find_by_bond_guid(cls, bond_guid):
return cls.query.filter_by(bond_guid=bond_guid).first()
