class ComplianceArticleResource(Resource, UserMixin, ErrorMixin):
compliance_article_model = api.model('ComplianceArticle', {
'compliance_article_id': fields.Integer,
'article_act_code': fields.String,
'section': fields.String,
'sub_section': fields.String,
'paragraph': fields.String,
'sub_paragraph': fields.String,
'description': fields.String,
'long_description': fields.String,
'effective_date': fields.Date,
'expiry_date': fields.Date
})
@api.doc(
description=
'This endpoint returns a list of all possible compliance codes and their descriptions.'
)
@requires_any_of([MINE_VIEW, MINESPACE_PROPONENT])
@api.marshal_with(compliance_article_model, code=200, envelope='records')
def get(self):
records = ComplianceArticle.query.all()
if records is None:
records = []
return records
def test_update_new_item_in_list(db_session):
mine = MineFactory(mine_permit=5)
permit = PermitFactory()
partial_mine_permit_dict = marshal(
{'mine_permit': mine.mine_permit},
api.model('test_list',
{'mine_permit': fields.List(fields.Nested(PERMIT_MODEL))}))
new_permit_dict = marshal(permit, PERMIT_MODEL)
for pa in permit.permit_amendments:
db_session.delete(pa)
db_session.delete(permit)
del new_permit_dict['mine_guid']
del new_permit_dict['permit_guid']
#FOR TESTING ONLY, lets Permitid stay because it's correct and
#postgres sequence doesn't get increased by factory object creation
partial_mine_permit_dict['mine_permit'].append(new_permit_dict)
mine.deep_update_from_dict(partial_mine_permit_dict,
_edit_key=PERMIT_EDIT_GROUP)
mine = Mine.query.filter_by(mine_guid=mine.mine_guid).first()
assert len(mine.mine_permit) == 6
assert all(len(p.permit_amendments) > 0 for p in mine.mine_permit)
def test_update_field_in_nested_item(db_session):
mine = MineFactory(mine_permit=5)
new_permit_no = 'XXX-9999'
partial_mine_permit_dict = marshal(
{'mine_permit': mine.mine_permit},
api.model('test_list',
{'mine_permit': fields.List(fields.Nested(PERMIT_MODEL))}))
partial_mine_permit_dict['mine_permit'][1]['permit_no'] = new_permit_no
mine.deep_update_from_dict(partial_mine_permit_dict,
_edit_key=PERMIT_EDIT_GROUP)
mine = Mine.query.filter_by(mine_guid=mine.mine_guid).first()
assert mine.mine_permit[1].permit_no == new_permit_no
def test_delete_flag_in_nested_item_fail_orphan(db_session):
init_length = 5
mine = MineFactory(mine_permit=init_length)
partial_mine_permit_dict = marshal(
{'mine_permit': mine.mine_permit},
api.model('test_list',
{'mine_permit': fields.List(fields.Nested(PERMIT_MODEL))}))
partial_mine_permit_dict['mine_permit'][1][
'state_modified'] = STATE_MODIFIED_DELETE_ON_PUT
print(partial_mine_permit_dict)
mine.deep_update_from_dict(partial_mine_permit_dict,
_edit_key=PERMIT_EDIT_GROUP)
mine = Mine.query.filter_by(mine_guid=mine.mine_guid).first()
assert len(mine.mine_permit) == init_length - 1
def test_missing_nested_item_not_deleted(db_session):
init_length = 5
mine = MineFactory(mine_permit=init_length)
partial_mine_permit_dict = marshal(
{'mine_permit': mine.mine_permit},
api.model('test_list',
{'mine_permit': fields.List(fields.Nested(PERMIT_MODEL))}))
partial_mine_permit_dict['mine_permit'] = partial_mine_permit_dict[
'mine_permit'][:2]
assert len(partial_mine_permit_dict['mine_permit']) < init_length
mine.deep_update_from_dict(partial_mine_permit_dict,
_edit_key=PERMIT_EDIT_GROUP)
mine = Mine.query.filter_by(mine_guid=mine.mine_guid).first()
assert len(mine.mine_permit) == init_length
class ApplicationStatusCodeResource(Resource, UserMixin, ErrorMixin):
application_status_code_model = api.model(
'ApplicationStatusCode', {
'application_status_code': fields.String,
'description': fields.String,
})
@api.marshal_with(application_status_code_model, code=200)
@api.doc(
description=
'This endpoint returns a list of all possible document status codes and thier descriptions.'
)
@requires_role_view_all
def get(self):
application_status_codes = ApplicationStatusCode.find_all_active_application_status_code(
)
if application_status_codes:
result = application_status_codes
else:
result = []
return result
from app.extensions import db, api
from flask_restplus import fields
from sqlalchemy.ext.associationproxy import association_proxy
from app.nris.utils.base_model import Base
from app.nris.models.document import DOCUMENT_RESPONSE_MODEL
ATTENDEE_RESPONSE_MODEL = api.model(
'attendee', {
'first_name': fields.String,
'last_name': fields.String,
'org': fields.String,
'attendee_type': fields.String,
'title': fields.String,
})
class Attendee(Base):
__tablename__ = "attendee"
__table_args__ = {'comment': 'Any attendee on an inspection.'}
attendee_id = db.Column(db.Integer, primary_key=True)
inspection = db.relationship('Inspection', lazy='selectin')
inspection_id = db.Column(db.Integer,
db.ForeignKey('inspection.inspection_id'))
first_name = db.Column(db.String())
last_name = db.Column(db.String())
org = db.Column(db.String())
title = db.Column(db.String())
attendee_type_id = db.Column(
db.Integer, db.ForeignKey('attendee_type.attendee_type_id'))
INSPECTION_RESPONSE_MODEL = api.model(
'inspection', {
'external_id':
fields.Integer,
'inspection_date':
fields.DateTime,
'completed_date':
fields.DateTime,
'inspection_status_code':
fields.String,
'inspection_type_code':
fields.String,
'inspection_report_sent_date':
fields.DateTime,
'inspection_from_date':
fields.DateTime,
'inspection_to_date':
fields.DateTime,
'business_area':
fields.String,
'mine_no':
fields.String,
'inspector_idir':
fields.String,
'inspection_introduction':
fields.String,
'inspection_preamble':
fields.String,
'inspection_closing':
fields.String,
'officer_notes':
fields.String,
'attendees':
fields.List(fields.Nested(ATTENDEE_RESPONSE_MODEL)),
'documents':
fields.List(fields.Nested(DOCUMENT_RESPONSE_MODEL)),
'inspected_locations':
fields.List(fields.Nested(INSPECTED_LOCATION_RESPONSE_MODEL)),
})
from app.extensions import api
from flask_restplus import fields
SUBMISSION = api.model('Submission', {
'submission_id': fields.Integer,
'json': fields.String,
})
import uuid
from flask import request
from flask_restplus import Resource, fields
from werkzeug.exceptions import NotFound, InternalServerError, BadRequest
from app.api.constants import TIMEOUT_5_MINUTES
from app.extensions import api, cache
from app.api.now_submissions.models.application import Application
from app.api.now_submissions.response_models import APPLICATION
from app.api.utils.access_decorators import requires_role_view_all
from app.api.utils.resources_mixins import UserMixin
from app.api.services.nros_download_service import NROSDownloadService
from app.api.services.vfcbc_download_service import VFCBCDownloadService
DOWNLOAD_TOKEN_MODEL = api.model('DownloadToken',
{'token_guid': fields.String})
def DOWNLOAD_TOKEN(token_guid):
return f'application-document:download-token:{token_guid}'
class ApplicationDocumentTokenResource(Resource, UserMixin):
@api.doc(
description=
'Issues a one-time token for access to a document without auth headers.'
)
@api.marshal_with(DOWNLOAD_TOKEN_MODEL, code=200)
@requires_role_view_all
def get(self, application_guid, id):
from app.extensions import api
from flask_restplus import fields
from app.api.compliance.response_models import COMPLIANCE_ARTICLE_MODEL
class DateTime(fields.Raw):
def format(self, value):
return value.strftime("%Y-%m-%d %H:%M") if value else None
BASIC_MINE_LOCATION_MODEL = api.model(
'BasicMineLocation', {
'latitude': fields.String,
'longitude': fields.String,
'utm_easting': fields.String,
'utm_northing': fields.String,
'utm_zone_number': fields.String,
'utm_zone_letter': fields.String,
'mine_location_description': fields.String,
})
BASIC_MINE_LIST = api.model(
'BasicMineList', {
'mine_guid': fields.String,
'mine_name': fields.String,
'mine_no': fields.String,
'mine_location': fields.Nested(BASIC_MINE_LOCATION_MODEL),
})
MINE_TENURE_TYPE_CODE_MODEL = api.model('MineTenureTypeCode', {
'mine_tenure_type_code': fields.String,
from app.extensions import api
from flask_restplus import fields
MINE_DOCUMENT_MODEL = api.model(
'MineDocument', {
'mine_document_guid': fields.String,
'mine_guid': fields.String,
'document_manager_guid': fields.String,
'document_name': fields.String,
})
VARIANCE_DOCUMENT = api.inherit(
'VarianceDocumentModel', MINE_DOCUMENT_MODEL, {
'created_at': fields.Date,
'variance_document_category_code': fields.String
})
VARIANCE = api.model(
'Variance', {
'variance_guid': fields.String,
'mine_guid': fields.String,
'mine_name': fields.String,
'compliance_article_id': fields.Integer,
'variance_application_status_code': fields.String,
'applicant_guid': fields.String,
'inspector_party_guid': fields.String,
'note': fields.String,
'parties_notified_ind': fields.Boolean,
'issue_date': fields.Date,
'received_date': fields.Date,
'expiry_date': fields.Date,
from datetime import datetime
from flask_restplus import Resource, fields
from flask import request, current_app
from app.extensions import api
from app.api.mines.mine.models.mine import Mine
from app.api.mines.permits.permit.models.permit import Permit
from app.api.utils.access_decorators import requires_role_view_all
VERIFY_PERMIT_NOW_MODEL = api.model(
'VerifyPermitNOWModel', {
'a_Result': fields.String,
'a_NoWInfo': fields.String,
'a_ResponseMessage': fields.String,
'a_Timestamp': fields.DateTime
})
class VerifyPermitNOWResource(Resource):
@api.doc(
description=
'Verifies by permit number that a permit amendment is within 30 days of authorization ending. NOTE: This exists for integration purposes and does not follow the typical patterns of this API.',
params={
'a_PermitNumber': f'The permit number.',
})
@api.marshal_with(VERIFY_PERMIT_NOW_MODEL, code=200)
@requires_role_view_all
def get(self):
result = ""
class DateTime(fields.Raw):
def format(self, value):
return value.strftime("%Y-%m-%d %H:%M") if value else None
class Date(fields.Raw):
def format(self, value):
return value.strftime("%Y-%m-%d") if value else None
BASIC_MINE_LOCATION_MODEL = api.model(
'BasicMineLocation', {
'latitude': fields.String,
'longitude': fields.String,
'utm_easting': fields.String,
'utm_northing': fields.String,
'utm_zone_number': fields.String,
'utm_zone_letter': fields.String,
'mine_location_description': fields.String,
})
BASIC_MINE_LIST = api.model(
'BasicMineList', {
'mine_guid': fields.String,
'mine_name': fields.String,
'mine_no': fields.String,
'mine_location': fields.Nested(BASIC_MINE_LOCATION_MODEL),
})
MINE_TENURE_TYPE_CODE_MODEL = api.model('MineTenureTypeCode', {
'mine_tenure_type_code': fields.String,
from datetime import datetime
from flask_restplus import Resource, fields
from flask import request, current_app
from app.extensions import api
from app.api.mines.mine.models.mine import Mine
from app.api.mines.permits.permit.models.permit import Permit
from app.api.utils.access_decorators import requires_role_view_all
VERIFY_PERMIT_MINE_MODEL = api.model(
'VerifyPermitMineModel', {
'a_Result': fields.String,
'a_MineInfo': fields.String,
'a_ResponseMessage': fields.String,
'a_Timestamp': fields.DateTime
})
class VerifyPermitMineResource(Resource):
@api.doc(
description=
'Verifies that a permit is valid for a mine based on the type of deemed authorization. NOTE: This exists for integration purposes and does not follow the typical patterns of this API.',
params={
'a_PermitNumber': f'The permit number.',
'a_TypeofDeemedAuth':
f'The type of deemed authorization, eg INDUCED.'
})
@api.marshal_with(VERIFY_PERMIT_MINE_MODEL, code=200)
@requires_role_view_all
from app.extensions import api
from flask_restplus import fields
PERMIT_AMENDMENT_DOCUMENT_MODEL = api.model(
'PermitAmendmentDocument', {
'permit_amendment_document_guid': fields.String,
'mine_guid': fields.String,
'document_manager_guid': fields.String,
'document_name': fields.String,
'active_ind': fields.Boolean
})
PERMIT_AMENDMENT_MODEL = api.model(
'PermitAmendment', {
'permit_amendment_guid':
fields.String,
'permit_guid':
fields.String,
'permit_amendment_status_code':
fields.String,
'permit_amendment_type_code':
fields.String,
'received_date':
fields.Date,
'issue_date':
fields.Date,
'authorization_end_date':
fields.Date,
'permit_amendment_status_description':
fields.String,
'permit_amendment_type_description':
class DateTime(fields.Raw):
def format(self, value):
return value.strftime("%Y-%m-%d %H:%M") if value else None
class Date(fields.Raw):
def format(self, value):
return value.strftime("%Y-%m-%d") if value else None
ORDER_MODEL = api.model(
'MineComplianceOrder', {
"order_no": fields.String,
"violation": fields.String,
"report_no": fields.Integer,
"inspector": fields.String,
"due_date": fields.Date,
"order_status": fields.String,
"overdue": fields.Boolean,
})
COMPLAINCE_AGGREGATION_MODEL = api.model(
'MineComplianceStats', {
'num_inspections': fields.Integer,
'num_advisories': fields.Integer,
'num_warnings': fields.Integer,
'num_requests': fields.Integer,
})
MINE_COMPLIANCE_RESPONSE_MODEL = api.model(
'MineComplianceData', {
import uuid
from flask import request, current_app
from flask_restplus import Resource, fields
from werkzeug.exceptions import NotFound, BadRequest
from app.extensions import api, cache
from app.api.now_applications.models.now_application_document_type import NOWApplicationDocumentType
from app.api.utils.resources_mixins import UserMixin
from app.api.utils.include.user_info import User
from app.api.utils.access_decorators import requires_role_view_all, requires_role_edit_permit
from app.api.utils.custom_reqparser import CustomReqparser
from app.api.constants import TIMEOUT_5_MINUTES, NOW_DOCUMENT_DOWNLOAD_TOKEN
from app.api.now_applications.response_models import NOW_APPLICATION_DOCUMENT_TYPE_MODEL
NOW_DOCUMENT_DOWNLOAD_TOKEN_MODEL = api.model('NoticeOfWorkDocumentDownloadToken',
{'token': fields.String})
class NOWApplicationDocumentTypeListResource(Resource, UserMixin):
@api.doc(description='Get a list of all Notice of Work document types', params={})
@requires_role_view_all
@api.marshal_with(NOW_APPLICATION_DOCUMENT_TYPE_MODEL, code=200, envelope='records')
def get(self):
return NOWApplicationDocumentType.get_all()
class NOWApplicationDocumentTypeResource(Resource, UserMixin):
@api.doc(description='Get a list of all Notice of Work document types', params={})
@requires_role_view_all
@api.marshal_with(NOW_APPLICATION_DOCUMENT_TYPE_MODEL, code=200)
def get(self, document_type_code):
from app.extensions import api
from flask_restplus import fields
BOND_PARTY = api.model(
'Party', {
'party_name': fields.String,
'name': fields.String,
'first_name': fields.String,
})
BOND_DOCUMENT_MODEL = api.model(
'BondDocument', {
'mine_document_guid': fields.String,
'mine_guid': fields.String,
'document_manager_guid': fields.String,
'document_name': fields.String,
'upload_date': fields.Date,
'bond_document_type_code': fields.String
})
RECLAMATION_INVOICE_DOCUMENT_MODEL = api.model(
'MineDocument', {
'mine_document_guid': fields.String,
'mine_guid': fields.String,
'document_manager_guid': fields.String,
'document_name': fields.String,
'upload_date': fields.Date,
})
BOND = api.model(
'Bond', {
from datetime import datetime
from app.extensions import db, api
from flask_restplus import fields
from sqlalchemy.orm import validates
from sqlalchemy.ext.associationproxy import association_proxy
from app.nris.utils.base_model import Base
NONCOMPLIANCE_RESPONSE_MODEL = api.model(
'noncompliance_permit', {
'section_number': fields.String,
'section_title': fields.String,
'section_text': fields.String,
})
class NonCompliancePermit(Base):
__tablename__ = "noncompliance_permit"
__table_args__ = {
'comment':
'For an issued order, this table contains the additional details about the permit conditions found to be in non-compliance.'
}
noncompliance_permit_id = db.Column(db.Integer, primary_key=True)
order_stop_detail_id = db.Column(
db.Integer, db.ForeignKey('order_stop_detail.order_stop_detail_id'))
section_number = db.Column(db.String(256))
section_title = db.Column(db.String(2048))
section_text = db.Column(db.String())
def __repr__(self):
return f'<NonCompliancePermit noncompliance_permit_id={self.noncompliance_permit_id} section_number={self.section_number}>'
from datetime import datetime
from app.extensions import db, api
from sqlalchemy.orm import validates
from sqlalchemy.ext.associationproxy import association_proxy
from app.nris.utils.base_model import Base
from flask_restplus import fields
WARNING_DETAILS_RESPONSE_MODEL = api.model('order_warning_detail', {
'detail': fields.String,
'respond_date': fields.Date,
})
class OrderWarningDetail(Base):
__tablename__ = "order_warning_detail"
__table_args__ = {
'comment':
'For each inspection observation, this table contains details of a warning issued by an inspector. A warning is a written notification to a person that is not in compliance with a specific Regulatory Requirement at the time of inspection.'
}
order_warning_detail_id = db.Column(db.Integer, primary_key=True)
inspected_location_id = db.Column(
db.Integer, db.ForeignKey('inspected_location.inspected_location_id'))
detail = db.Column(db.String())
respond_date = db.Column(db.DateTime)
def __repr__(self):
return f'<OrderWarningDetail order_warning_detail_id={self.order_warning_detail_id}> inspected_location_id={self.inspected_location_id}'
from flask_restplus import Resource, fields
from app.extensions import api
from ....utils.access_decorators import requires_role_view_all
from ....utils.resources_mixins import UserMixin
from ...region.models.region import MineRegionCode
MINE_REGION_OPTION = api.model('MineRegion', {
'mine_region_code': fields.String,
'description': fields.String
})
class MineRegionResource(Resource, UserMixin):
@api.doc(params={'mine_region_guid': 'Mine region guid.'})
@api.marshal_with(MINE_REGION_OPTION, code=201, envelope='records')
@requires_role_view_all
def get(self):
return MineRegionCode.active()
from app.extensions import api
from flask_restplus import fields
MINESPACE_USER_MODEL = api.model(
'MineDocument', {
'user_id': fields.String,
'keycloak_guid': fields.String,
'email': fields.String,
'mines': fields.List(fields.String),
})
from flask_restplus import fields
CLIENT = api.model(
'Client', {
'type': fields.String,
'org_legalname': fields.String,
'org_doingbusinessas': fields.String,
'ind_firstname': fields.String,
'ind_lastname': fields.String,
'ind_middlename': fields.String,
'ind_phonenumber': fields.String,
'dayphonenumber': fields.String,
'dayphonenumberext': fields.String,
'faxnumber': fields.String,
'email': fields.String,
'org_bcfedincorpnumber': fields.String,
'org_bcregnumber': fields.String,
'org_societynumber': fields.String,
'org_hstregnumber': fields.String,
'org_contactname': fields.String,
'mailingaddressline1': fields.String,
'mailingaddressline2': fields.String,
'mailingaddresscity': fields.String,
'mailingaddressprovstate': fields.String,
'mailingaddresscountry': fields.String,
'mailingaddresspostalzip': fields.String,
})
CONTACT = api.model(
'CONTACT', {
from flask_restplus import Resource, reqparse, fields
from flask import request
from datetime import datetime
from werkzeug.exceptions import BadRequest, NotFound, InternalServerError
from app.extensions import api
from ..models.core_user import CoreUser
from app.api.utils.resources_mixins import UserMixin
from app.api.utils.access_decorators import requires_role_view_all, requires_role_mine_edit
idir_user_detail_model = api.model(
'idir_user_detail', {
'bcgov_guid': fields.String,
'username': fields.String,
'title': fields.String,
'city': fields.String,
'department': fields.String,
})
core_user_model = api.model(
'core_user', {
'core_user_guid': fields.String,
'email': fields.String,
'phone_no': fields.String,
'idir_user_detail': fields.Nested(idir_user_detail_model),
'last_logon': fields.DateTime,
})
class CoreUserListResource(Resource, UserMixin):
@api.marshal_with(core_user_model, envelope='results', code=200, as_list=True)
from app.extensions import api
from flask_restplus import fields
COMPLIANCE_ARTICLE_MODEL = api.model(
'ComplianceArticle', {
'compliance_article_id': fields.Integer,
'article_act_code': fields.String,
'section': fields.String,
'sub_section': fields.String,
'paragraph': fields.String,
'sub_paragraph': fields.String,
'description': fields.String,
'long_description': fields.String,
'effective_date': fields.Date,
'expiry_date': fields.Date
})
from app.extensions import api
from flask_restplus import fields
MINE_INCIDENT_CATEGORY_MODEL = api.model(
'Mine Incident Category', {
'mine_incident_category_code': fields.String,
'description': fields.String,
'display_order': fields.Integer,
'active_ind': fields.Boolean
})
MINE_INCIDENT_DETERMINATION_TYPE_MODEL = api.model(
'Mine Incident Determination Type', {
'mine_incident_determination_type_code': fields.String,
'description': fields.String
})
MINE_INCIDENT_FOLLOWUP_INVESTIGATION_TYPE_MODEL = api.model(
'Mine Incident Followup Investigation Type', {
'mine_incident_followup_investigation_type_code': fields.String,
'description': fields.String
})
MINE_INCIDENT_STATUS_CODE_MODEL = api.model(
'Mine Incident Status Codes', {
'mine_incident_status_code': fields.String,
'description': fields.String
})
MINE_INCIDENT_DOCUMENT_TYPE_CODE_MODEL = api.model(
'Mine Incident Document Type Codes', {
from app.extensions import api
from flask_restplus import fields
WELL = api.model(
'Well', {
'operator_name': fields.String,
'operator_id': fields.Integer,
'well_auth_number': fields.Integer,
'well_name': fields.String,
'dormant_status': fields.String,
'current_status': fields.String,
'well_dormancy_date': fields.Date,
'site_dormancy_date': fields.Date,
'site_dormancy_type': fields.String,
'site_dormant_status': fields.String,
'surface_location': fields.String,
'field': fields.String,
'abandonment_date': fields.Date,
'last_spud_date': fields.Date,
'last_rig_rels_date': fields.Date,
'last_completion_date': fields.Date,
'last_active_production_year': fields.Date,
'last_active_inj_display_year': fields.Date,
'wellsite_dormancy_declaration_date': fields.Date,
'multi_well': fields.String
})
from datetime import datetime
from app.extensions import db, api
from flask_restplus import fields
from sqlalchemy.orm import validates
from sqlalchemy.ext.associationproxy import association_proxy
from app.nris.utils.base_model import Base
NONCOMPLIANCE_LEGISLATION_RESPONSE_MODEL = api.model(
'noncompliance_legislation', {
'estimated_incident_date': fields.DateTime,
'noncompliant_description': fields.String,
'parent_act': fields.String,
'section': fields.String,
'compliance_article_comments': fields.String,
})
class NonComplianceLegislation(Base):
__tablename__ = "noncompliance_legislation"
noncompliance_legislation_id = db.Column(db.Integer, primary_key=True)
order_stop_detail_id = db.Column(
db.Integer, db.ForeignKey('order_stop_detail.order_stop_detail_id'))
estimated_incident_date = db.Column(db.DateTime)
noncompliant_description = db.Column(db.String(256))
parent_act_id = db.Column(
db.Integer, db.ForeignKey('legislation_act.legislation_act_id'))
legislation_act_section_id = db.Column(
db.ForeignKey('legislation_act_section.legislation_act_section_id'))
compliance_article_id = db.Column(
db.Integer,
db.ForeignKey(
NOMINATED_WELL_SITE = api.model(
'NominatedWellSiteListResource', {
'operator_name':
fields.String(attribute='operator'),
'operator_id':
fields.Integer(attribute='ba_id'),
'well_auth_number':
fields.Integer(attribute='wa_number'),
'well_name':
fields.String,
'dormant_status':
fields.String(attribute='well_dormant_status'),
'current_status':
fields.String(attribute='current_status'),
'well_dormancy_date':
fields.DateTime,
'site_dormancy_date':
fields.DateTime,
'site_dormancy_type':
fields.String,
'site_dormant_status':
fields.String,
'surface_location':
fields.String,
'field':
fields.String,
'abandonment_date':
fields.DateTime,
'last_spud_date':
fields.DateTime,
'last_active_production_year':
fields.DateTime(attribute='last_active_production_yr'),
'wellsite_dormancy_declaration_date':
fields.DateTime,
'multi_well':
fields.String
})
