async def test_correction_filing(app, session):
"""Assert we can process a correction filing."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1111111'
correction_filing_comment = 'We need to fix directors'
# get a fixed datetime to use in comparisons, in "local" (Pacific) timezone
local_timezone = pytz.timezone('US/Pacific')
correction_filing_date = \
datetime.datetime(2019, 9, 17, 0, 0).replace(tzinfo=datetime.timezone.utc).astimezone(tz=local_timezone)
# setup - create business, staff user, and original filing to be corrected
business_id = create_business(identifier).id
staff_user_id = create_user(username='******').id
original_filing_id = create_filing(payment_id, copy.deepcopy(ANNUAL_REPORT), business_id).id
# setup - create correction filing
filing = copy.deepcopy(CORRECTION_AR)
filing['filing']['header']['identifier'] = identifier
filing['filing']['correction']['comment'] = correction_filing_comment
filing['filing']['correction']['correctedFilingId'] = original_filing_id
correction_filing = create_filing(payment_id, filing, business_id, filing_date=correction_filing_date)
correction_filing.submitter_id = staff_user_id
correction_filing.save()
correction_filing_id = correction_filing.id
filing_msg = {'filing': {'id': correction_filing_id}}
# TEST
await process_filing(filing_msg, app)
# Get modified data
original_filing = Filing.find_by_id(original_filing_id)
correction_filing = Filing.find_by_id(correction_filing_id)
staff_user = User.find_by_username('staff_user')
# check that the correction filing is linked to the original filing
assert original_filing.parent_filing
assert original_filing.parent_filing == correction_filing
# check that the correction comment has been added to the correction filing
assert 0 < len(correction_filing.comments.all())
assert correction_filing_comment == correction_filing.comments.all()[-1].comment
assert staff_user.id == correction_filing.comments.all()[-1].staff.id
# check that the correction filing is PENDING_CORRECTION
assert correction_filing.status == 'PENDING_CORRECTION'
# check that the original filing is marked as corrected
# assert True is original_filing.is_corrected
# check that the original filing has the new comment
assert 0 < len(original_filing.comments.all())
assert f'This filing was corrected on {correction_filing_date.date().isoformat()}.' == \
original_filing.comments.all()[-1].comment
assert staff_user.id == original_filing.comments.all()[-1].staff.id
def validate_correction_ia(filing: Dict) -> Optional[Error]:
"""Validate correction of Incorporation Application."""
if not (corrected_filing # pylint: disable=superfluous-parens; needed to pass pylance
:= Filing.find_by_id(
filing['filing']['correction']['correctedFilingId'])):
return Error(
HTTPStatus.BAD_REQUEST,
[{
'error': babel('Missing the id of the filing being corrected.')
}])
async def test_process_coa_filing(app, session):
"""Assert that a COD filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
new_delivery_address = COA_FILING['filing']['changeOfAddress']['offices']['registeredOffice']['deliveryAddress']
new_mailing_address = COA_FILING['filing']['changeOfAddress']['offices']['registeredOffice']['mailingAddress']
# setup
business = create_business(identifier)
business_id = business.id
filing_id = (create_filing(payment_id, COA_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
register_office = business.offices.filter_by(office_type='registeredOffice').one_or_none()
delivery_address = register_office.addresses.filter_by(address_type='delivery').one_or_none().json
compare_addresses(delivery_address, new_delivery_address)
mailing_address = register_office.addresses.filter_by(address_type='mailing').one_or_none().json
compare_addresses(mailing_address, new_mailing_address)
def process(correction_filing: Filing, filing: Dict):
"""Render the correction filing onto the business model objects."""
local_timezone = pytz.timezone('US/Pacific')
# link to original filing
original_filing = Filing.find_by_id(
filing['correction']['correctedFilingId'])
original_filing.parent_filing = correction_filing
# add comment to the original filing
original_filing.comments.append(
Comment(
comment=f'This filing was corrected on '
f'{correction_filing.filing_date.astimezone(local_timezone).date().isoformat()}.',
staff_id=correction_filing.submitter_id))
# add comment to the correction filing
correction_filing.comments.append(
Comment(comment=filing['correction']['comment'],
staff_id=correction_filing.submitter_id))
if not any('incorporationApplication' in x
for x in correction_filing.legal_filings()):
# set correction filing to PENDING_CORRECTION, for manual intervention
# - include flag so that listener in Filing model does not change state automatically to COMPLETE
correction_filing._status = Filing.Status.PENDING_CORRECTION.value # pylint: disable=protected-access
setattr(correction_filing, 'skip_status_listener', True)
original_filing.save_to_session()
return correction_filing
def test_post_colin_filing(session, client, jwt):
"""Assert that colin filing can be posted to legal api."""
# SETUP
# Create business
identifier = 'CP7654321'
business = factory_business(identifier, founding_date=(datetime.utcnow() - datedelta.YEAR))
factory_business_mailing_address(business)
# Create an AR filing for the business
ar = copy.deepcopy(ANNUAL_REPORT)
ar['filing']['annualReport']['annualReportDate'] = datetime.utcnow().date().isoformat()
ar['filing']['annualReport']['annualGeneralMeetingDate'] = datetime.utcnow().date().isoformat()
ar['filing']['header']['colinIds'] = [1230]
ar['filing']['header']['date'] = datetime.utcnow().date().isoformat()
ar['filing']['header']['source'] = Filing.Source.COLIN.value
ar['filing']['business']['identifier'] = identifier
# POST the AR
rv = client.post(
f'/api/v1/businesses/{identifier}/filings',
json=ar,
headers=create_header(jwt, [COLIN_SVC_ROLE], 'coops-updater-job')
)
# Assure that the filing was accepted
assert rv.status_code == HTTPStatus.CREATED
# Check filing
filing = Filing.find_by_id(rv.json['filing']['id'])
assert filing.source == Filing.Source.COLIN.value
assert filing.status in [Filing.Status.PAID.value, Filing.Status.COMPLETED.value]
async def test_worker_alteration_court_order(app, session):
"""Assert the worker process calls the alteration correctly."""
identifier = 'BC1234567'
business = create_business(identifier, legal_type='BC')
file_number: Final = '#1234-5678/90'
order_date: Final = '2021-01-30T09:56:01+08:00'
effect_of_order: Final = 'hasPlan'
filing = copy.deepcopy(FILING_HEADER)
filing['filing']['alteration'] = {'courtOrder':
{
'fileNumber': file_number,
'orderDate': order_date,
'effectOfOrder': effect_of_order
}
}
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing_id = (create_filing(payment_id, filing, business_id=business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# Test
await process_filing(filing_msg, app)
# Check outcome
final_filing = Filing.find_by_id(filing_id)
assert file_number == final_filing.court_order_file_number
assert datetime.fromisoformat(order_date) == final_filing.court_order_date
assert effect_of_order == final_filing.court_order_effect_of_order
async def test_process_ar_filing_no_agm(app, session):
"""Assert that a no agm AR filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# setup
business = create_business(identifier)
business_id = business.id
now = datetime.date(2020, 9, 17)
ar_date = datetime.date(2020, 8, 5)
agm_date = None
ar = copy.deepcopy(ANNUAL_REPORT)
ar['filing']['business']['identifier'] = identifier
ar['filing']['annualReport']['annualReportDate'] = ar_date.isoformat()
ar['filing']['annualReport']['annualGeneralMeetingDate'] = None
# TEST
with freeze_time(now):
filing = create_filing(payment_id, ar, business.id)
filing_id = filing.id
filing_msg = {'filing': {'id': filing_id}}
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert business.last_agm_date == agm_date
assert datetime.datetime.date(business.last_ar_date) == ar_date
def validate(business: Business, filing: Dict) -> Error:
"""Validate the Correction filing."""
if not business or not filing:
return Error(
HTTPStatus.BAD_REQUEST,
[{
'error': _('A valid business and filing are required.')
}])
msg = []
# confirm corrected filing ID is a valid complete filing
corrected_filing = Filing.find_by_id(
filing['filing']['correction']['correctedFilingId'])
if not corrected_filing or corrected_filing.status != Filing.Status.COMPLETED.value:
path = '/filing/correction/correctedFilingId'
msg.append({
'error': _('Corrected filing is not a valid filing.'),
'path': path
})
# confirm that this business owns the corrected filing
elif not business.id == corrected_filing.business_id:
path = '/filing/correction/correctedFilingId'
msg.append({
'error':
_('Corrected filing is not a valid filing for this business.'),
'path':
path
})
if msg:
return Error(HTTPStatus.BAD_REQUEST, msg)
return None
def validate(business: Business, filing: Dict) -> Error:
"""Validate the Correction filing."""
if not business or not filing:
return Error(
HTTPStatus.BAD_REQUEST,
[{
'error': _('A valid business and filing are required.')
}])
msg = []
# confirm corrected filing ID is a valid complete filing
corrected_filing = Filing.find_by_id(
filing['filing']['correction']['correctedFilingId'])
if not corrected_filing or corrected_filing.status != Filing.Status.COMPLETED.value:
path = '/filing/correction/correctedFilingId'
msg.append({
'error': _('Corrected filing is not a valid filing.'),
'path': path
})
# confirm that this business owns the corrected filing
elif not business.id == corrected_filing.business_id:
path = '/filing/correction/correctedFilingId'
msg.append({
'error':
_('Corrected filing is not a valid filing for this business.'),
'path':
path
})
if err := has_at_least_one_share_class(filing, 'incorporationApplication'):
msg.append({
'error': _(err),
'path': '/filing/incorporationApplication/shareStructure'
})
def test_payment_header(session, client, jwt):
"""Assert that a filing can be completed up to payment."""
from legal_api.models import Filing
identifier = 'CP7654321'
payment_account = '12345'
business = factory_business(identifier,
founding_date=(datetime.utcnow() -
datedelta.YEAR))
factory_business_mailing_address(business)
data = copy.deepcopy(FILING_HEADER)
data['filing']['header']['name'] = 'specialResolution'
data['filing']['specialResolution'] = SPECIAL_RESOLUTION
rv = client.post(f'/api/v2/businesses/{identifier}/filings',
json=data,
headers=create_header(jwt, [STAFF_ROLE], identifier,
**{'accountID': payment_account}))
# check return
assert rv.status_code == HTTPStatus.CREATED
assert not rv.json.get('errors')
assert rv.json['filing']['header']['filingId']
# check stored filing
filing = Filing.find_by_id(rv.json['filing']['header']['filingId'])
assert filing
assert filing.payment_account == payment_account
async def test_transition_filing(app, session):
"""Assert we can create a business based on transition filing."""
filing_data = copy.deepcopy(TRANSITION_FILING_TEMPLATE)
business = create_business(filing_data['filing']['business']['identifier'])
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = (create_filing(payment_id, filing_data, business.id))
filing_msg = {'filing': {'id': filing.id}}
# Test
await process_filing(filing_msg, app)
# Check outcome
filing = Filing.find_by_id(filing.id)
business = Business.find_by_internal_id(filing.business_id)
filing_json = filing.filing_json
assert business
assert filing
assert filing.status == Filing.Status.COMPLETED.value
assert business.restriction_ind is False
assert len(business.share_classes.all()) == len(
filing_json['filing']['transition']['shareStructure']['shareClasses'])
assert len(business.offices.all()) == len(
filing_json['filing']['transition']['offices'])
assert len(business.aliases.all()) == len(
filing_json['filing']['transition']['nameTranslations'])
assert len(business.resolutions.all()) == len(
filing_json['filing']['transition']['shareStructure']
['resolutionDates'])
assert len(PartyRole.get_parties_by_role(business.id, 'director')) == 2
def patch(filing_id):
"""Patch the colin_event_id for a filing."""
# check authorization
try:
if not jwt.validate_roles([COLIN_SVC_ROLE]):
return jsonify({'message': 'You are not authorized to update the colin id'}), HTTPStatus.UNAUTHORIZED
json_input = request.get_json()
if not json_input:
return None, None, {'message': f'No filing json data in body of patch for {filing_id}.'}, \
HTTPStatus.BAD_REQUEST
colin_ids = json_input['colinIds']
filing = Filing.find_by_id(filing_id)
if not filing:
return {'message': f'{filing_id} no filings found'}, HTTPStatus.NOT_FOUND
for colin_id in colin_ids:
try:
colin_event_id_obj = ColinEventId()
colin_event_id_obj.colin_event_id = colin_id
filing.colin_event_ids.append(colin_event_id_obj)
filing.save()
except BusinessException as err:
current_app.logger.Error(f'Error adding colin event id {colin_id} to filing with id {filing_id}')
return None, None, {'message': err.error}, err.status_code
return jsonify(filing.json), HTTPStatus.ACCEPTED
except Exception as err:
current_app.logger.Error(f'Error patching colin event id for filing with id {filing_id}')
raise err
def test_process_incorporation_parties(app, session):
"""Assert we successfully add parties in incorporation filing."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = copy.deepcopy(INCORP_FILING)
schema_incorp = copy.deepcopy(INCORPORATION)
filing['filing']['incorporationApplication']['parties'] = schema_incorp['parties']
identifier = filing['filing']['incorporationApplication']['nameRequest']['nrNumber']
business = create_business(identifier)
filing_id = (create_filing(payment_id, filing, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
process_filing(filing_msg, app)
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(filing.business_id)
assert len(PartyRole.get_parties_by_role(business.id, 'director')) == 1
assert len(PartyRole.get_parties_by_role(business.id, 'incorporator')) == 1
assert len(PartyRole.get_parties_by_role(business.id, 'completing_party')) == 1
director = (PartyRole.get_parties_by_role(business.id, 'director'))[0]
incorporator = (PartyRole.get_parties_by_role(business.id, 'incorporator'))[0]
completing_party = (PartyRole.get_parties_by_role(business.id, 'completing_party'))[0]
assert director.appointment_date
assert incorporator.appointment_date
assert completing_party.appointment_date
def test_process_filing_completed(app, session):
"""Assert that an AR filling status is set to completed once processed."""
from entity_filer.worker import process_filing
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# setup
business = create_business(identifier)
business_id = business.id
filing_id = (create_filing(payment_id, AR_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert filing.transaction_id
assert business.last_agm_date
assert business.last_ar_date
def _basic_checks(identifier, filing_id, client_request) -> Tuple[dict, int]:
"""Perform basic checks to ensure put can do something."""
json_input = client_request.get_json()
if client_request.method == 'POST' and not json_input:
return ({
'message':
f'No filing json data in body of post for {identifier}.'
}, HTTPStatus.BAD_REQUEST)
if client_request.method == 'GET' and identifier.startswith('T'):
filing_model = Filing.get_temp_reg_filing(identifier)
business = Business.find_by_internal_id(filing_model.business_id)
else:
business = Business.find_by_identifier(identifier)
filing = Filing.find_by_id(filing_id)
if not business:
return ({'message': f'{identifier} not found'}, HTTPStatus.NOT_FOUND)
# check that filing belongs to this business
if not filing or filing.business_id != business.id:
return ({
'message': f'Filing {filing_id} not found'
}, HTTPStatus.NOT_FOUND)
return (None, None)
def patch(filing_id):
"""Patch the colin_event_id for a filing."""
# check authorization
if not jwt.validate_roles([COLIN_SVC_ROLE]):
return jsonify({
'message':
'You are not authorized to update the colin id'
}), HTTPStatus.UNAUTHORIZED
json_input = request.get_json()
if not json_input:
return None, None, {'message': f'No filing json data in body of patch for {filing_id}.'}, \
HTTPStatus.BAD_REQUEST
colin_id = json_input['colinId']
filing = Filing.find_by_id(filing_id)
if not filing:
return {
'message': f'{filing_id} no filings found'
}, HTTPStatus.NOT_FOUND
try:
filing.colin_event_id = colin_id
filing.save()
except BusinessException as err:
return None, None, {'message': err.error}, err.status_code
return jsonify(filing.json), HTTPStatus.ACCEPTED
def test_process_coa_filing(app, session):
"""Assert that an AR filling can be applied to the model correctly."""
from entity_filer.worker import process_filing
from legal_api.models import Business, Filing
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
new_delivery_address = COA_FILING['filing']['changeOfAddress'][
'deliveryAddress']
new_mailing_address = COA_FILING['filing']['changeOfAddress'][
'mailingAddress']
# setup
business = create_business(identifier)
business_id = business.id
filing_id = (create_filing(payment_id, COA_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
delivery_address = business.delivery_address.one_or_none().json
compare_addresses(delivery_address, new_delivery_address)
mailing_address = business.mailing_address.one_or_none().json
compare_addresses(mailing_address, new_mailing_address)
def _set_dates(self, filing):
# Filing Date
filing_datetime = LegislationDatetime.as_legislation_timezone(self._filing.filing_date)
hour = filing_datetime.strftime('%I').lstrip('0')
filing['filing_date_time'] = filing_datetime.strftime(f'%B %-d, %Y at {hour}:%M %p Pacific Time')
# Effective Date
effective_date = filing_datetime if self._filing.effective_date is None \
else LegislationDatetime.as_legislation_timezone(self._filing.effective_date)
effective_hour = effective_date.strftime('%I').lstrip('0')
filing['effective_date_time'] = effective_date.strftime(f'%B %-d, %Y at {effective_hour}:%M %p Pacific Time')
filing['effective_date'] = effective_date.strftime('%B %-d, %Y')
# Recognition Date
if self._business:
recognition_datetime = LegislationDatetime.as_legislation_timezone(self._business.founding_date)
recognition_hour = recognition_datetime.strftime('%I').lstrip('0')
filing['recognition_date_time'] = \
recognition_datetime.strftime(f'%B %-d, %Y at {recognition_hour}:%M %p Pacific Time')
# For Annual Report - Set AGM date as the effective date
if self._filing.filing_type == 'annualReport':
agm_date_str = filing.get('annualReport', {}).get('annualGeneralMeetingDate', None)
if agm_date_str:
agm_date = datetime.fromisoformat(agm_date_str)
filing['agm_date'] = agm_date.strftime('%B %-d, %Y')
# for AR, the effective date is the AGM date
filing['effective_date'] = agm_date.strftime('%B %-d, %Y')
else:
filing['agm_date'] = 'No AGM'
if filing.get('correction'):
original_filing = Filing.find_by_id(filing.get('correction').get('correctedFilingId'))
original_filing_datetime = LegislationDatetime.as_legislation_timezone(original_filing.filing_date)
original_filing_hour = original_filing_datetime.strftime('%I').lstrip('0')
filing['original_filing_date_time'] = original_filing_datetime. \
strftime(f'%B %-d, %Y at {original_filing_hour}:%M %p Pacific Time')
async def test_process_filing_completed(app, session, mocker):
"""Assert that an AR filling status is set to completed once processed."""
from entity_filer.worker import publish_email_message
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
# mock out the email sender and event publishing
mocker.patch('entity_filer.worker.publish_email_message',
return_value=None)
mocker.patch('entity_filer.worker.publish_event', return_value=None)
# setup
business = create_business(identifier, legal_type='CP')
business_id = business.id
filing_id = (create_filing(payment_id, AR_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
await process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
assert filing.transaction_id
assert business.last_agm_date
assert business.last_ar_date
def test_process_cod_filing(app, session):
"""Assert that an AR filling can be applied to the model correctly."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
identifier = 'CP1234567'
end_date = datetime.datetime.utcnow().date()
# prep director for no change
filing_data = copy.deepcopy(COD_FILING)
director1 = create_director(
filing_data['filing']['changeOfDirectors']['directors'][0])
# prep director for name change
director2 = filing_data['filing']['changeOfDirectors']['directors'][1]
director2['officer']['firstName'] = director2['officer']['prevFirstName']
director2['officer']['middleInitial'] = director2['officer'][
'prevMiddleInitial']
director2['officer']['lastName'] = director2['officer']['prevLastName']
director2 = create_director(director2)
# prep director for cease
director3 = create_director(
filing_data['filing']['changeOfDirectors']['directors'][2])
director_ceased_id = director3.id
# prep director for address change
director4 = filing_data['filing']['changeOfDirectors']['directors'][3]
director4['deliveryAddress']['streetAddress'] = 'should get changed'
director4 = create_director(director4)
# list of active/ceased directors in test filing
ceased_directors, active_directors = active_ceased_lists(COD_FILING)
# setup
business = create_business(identifier)
business.directors.append(director1)
business.directors.append(director2)
business.directors.append(director3)
business.directors.append(director4)
business.save()
# check that adding the director during setup was successful
directors = Director.get_active_directors(business.id, end_date)
assert len(directors) == 4
# create filing
business_id = business.id
filing_id = (create_filing(payment_id, COD_FILING, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
# TEST
process_filing(filing_msg, app)
# Get modified data
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(business_id)
# check it out
assert filing.transaction_id
assert filing.business_id == business_id
assert filing.status == Filing.Status.COMPLETED.value
directors = Director.get_active_directors(business.id, end_date)
check_directors(business, directors, director_ceased_id, ceased_directors,
active_directors)
def process_filing(filing_msg: Dict, flask_app: Flask):
"""Render the filings contained in the submission."""
if not flask_app:
raise QueueException('Flask App not available.')
with flask_app.app_context():
filing_submission = Filing.find_by_id(filing_msg['filing']['id'])
if not filing_submission:
raise QueueException
if filing_submission.status == Filing.Status.COMPLETED.value:
logger.warning('QueueFiler: Attempting to reprocess business.id=%s, filing.id=%s filing=%s',
filing_submission.business_id, filing_submission.id, filing_msg)
return
legal_filings = filing_submission.legal_filings()
if legal_filings:
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
business = Business.find_by_internal_id(filing_submission.business_id)
for filing in legal_filings:
if filing.get('annualReport'):
annual_report.process(business, filing)
elif filing.get('changeOfAddress'):
change_of_address.process(business, filing)
elif filing.get('changeOfDirectors'):
filing['colinIds'] = filing_submission.colin_event_ids
change_of_directors.process(business, filing)
elif filing.get('changeOfName'):
change_of_name.process(business, filing)
elif filing.get('specialResolution'):
pass # nothing to do here
elif filing.get('voluntaryDissolution'):
voluntary_dissolution.process(business, filing)
elif filing.get('incorporationApplication'):
incorporation_filing.process(business, filing, flask_app)
filing_submission.transaction_id = transaction.id
filing_submission.set_processed()
db.session.add(business)
db.session.add(filing_submission)
db.session.commit()
publish_event(business, filing_submission)
return
def get_incorporation_application_reports(self, filing: dict):
"""Return incorporation application meta object(s)."""
is_fed = LegislationDatetime.is_future(
filing['filing']['header']['effectiveDate'])
# return FED instead of PAID or COMPLETED
if is_fed:
return [
self.create_report_object(
'Incorporation Application - Future Effective Incorporation',
self.get_general_filename(
'Incorporation Application (Future Effective)'))
]
if self.is_paid():
return [
self.create_report_object(
'Incorporation Application - Pending',
self.get_general_filename(
'Incorporation Application (Pending)'))
]
filing_data = Filing.find_by_id(filing['filing']['header']['filingId'])
has_corrected = filing_data.parent_filing_id is not None # Identify whether it is corrected
label_original = ' (Original)' if has_corrected else ''
label_certificate_original = ' (Original)' if has_corrected and NameXService.\
has_correction_changed_name(Filing.find_by_id(filing_data.parent_filing_id).json) else ''
# else status is COMPLETED
return [
self.create_report_object(
f'Incorporation Application{label_original}',
self.get_general_filename(
f'Incorporation Application{label_original}')),
self.create_report_object(
DocumentMetaService.NOTICE_OF_ARTICLES,
self.get_general_filename(
DocumentMetaService.NOTICE_OF_ARTICLES),
DocumentMetaService.ReportType.NOTICE_OF_ARTICLES.value),
self.create_report_object(
f'Certificate{label_certificate_original}',
self.get_general_filename(
f'Certificate{label_certificate_original}'),
DocumentMetaService.ReportType.CERTIFICATE.value)
]
def has_new_nr_for_correction(filing: dict):
"""Return whether a correction filing has new NR."""
new_nr_number = filing.get('filing').get('incorporationApplication').get('nameRequest').get('nrNumber', None)
if new_nr_number:
corrected_filing = Filing.find_by_id(filing['filing']['correction']['correctedFilingId'])
corrected_filing_json = corrected_filing.filing_json
old_nr_number = corrected_filing_json.get('filing').get('incorporationApplication').\
get('nameRequest').get('nrNumber', None)
return old_nr_number != new_nr_number
return False
def _set_registrar_info(self, filing):
if filing.get('correction'):
original_filing = Filing.find_by_id(filing.get('correction').get('correctedFilingId'))
original_registrar = {**RegistrarInfo.get_registrar_info(original_filing.effective_date)}
filing['registrarInfo'] = original_registrar
current_registrar = {**RegistrarInfo.get_registrar_info(self._filing.effective_date)}
if original_registrar['name'] != current_registrar['name']:
filing['currentRegistrarInfo'] = current_registrar
else:
filing['registrarInfo'] = {**RegistrarInfo.get_registrar_info(self._filing.effective_date)}
def get_business_revision_before_filing(filing_id, business_id) -> dict:
"""Consolidates the business info of the previous filing."""
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id < filing.transaction_id) \
.filter(business_version.operation_type != 2) \
.filter(business_version.id == business.id) \
.order_by(business_version.transaction_id.desc()).first()
return VersionedBusinessDetailsService.business_revision_json(
business_revision, business.json())
def get_business_revision_after_filing(filing_id, business_id) -> dict:
"""Consolidates the business info as of a particular transaction."""
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id > filing.transaction_id) \
.filter(business_version.operation_type != 2) \
.filter(business_version.id == business.id) \
.order_by(business_version.transaction_id).one_or_none()
return VersionedBusinessDetailsService.business_revision_json(
business_revision, business.json())
def test_delete_bootstrap_draft_filing(client, jwt, session):
"""Assert that a draft IA filing can be retrieved."""
account_id = 26
identifier, filing_id = setup_bootstrap_ia_minimal(jwt, session, client,
account_id)
#
# Test that we can get the filing
#
rv = client.delete(f'/api/v1/businesses/{identifier}/filings/{filing_id}',
headers=create_header(jwt, [STAFF_ROLE], None))
assert rv.status_code == HTTPStatus.OK
assert not Filing.find_by_id(filing_id)
assert not RegistrationBootstrap.find_by_identifier(identifier)
def get_filing_info(filing_id: str) -> (Filing, dict, dict, str, str):
"""Get filing info for the email."""
filing = Filing.find_by_id(filing_id)
business = (filing.json)['filing']['business']
filing_date = datetime.fromisoformat(filing.filing_date.isoformat())
leg_tmz_filing_date = LegislationDatetime.as_legislation_timezone(filing_date)
hour = leg_tmz_filing_date.strftime('%I').lstrip('0')
leg_tmz_filing_date = leg_tmz_filing_date.strftime(f'%B %d, %Y {hour}:%M %p Pacific Time')
effective_date = datetime.fromisoformat(filing.effective_date.isoformat())
leg_tmz_effective_date = LegislationDatetime.as_legislation_timezone(effective_date)
hour = leg_tmz_effective_date.strftime('%I').lstrip('0')
leg_tmz_effective_date = leg_tmz_effective_date.strftime(f'%B %d, %Y {hour}:%M %p Pacific Time')
return filing, business, leg_tmz_filing_date, leg_tmz_effective_date
def test_incorporation_filing(app, session):
"""Assert we can retrieve a new corp number from COLIN and incorporate a business."""
# vars
payment_id = str(random.SystemRandom().getrandbits(0x58))
filing = copy.deepcopy(INCORP_FILING)
identifier = filing['filing']['incorporationApplication']['nameRequest'][
'nrNumber']
business = create_business(identifier)
filing_id = (create_filing(payment_id, filing, business.id)).id
filing_msg = {'filing': {'id': filing_id}}
assert business.identifier == 'NR 1234567'
process_filing(filing_msg, app)
filing = Filing.find_by_id(filing_id)
business = Business.find_by_internal_id(filing.business_id)
assert business.identifier != 'NR 1234567'
def get_company_details_revision(filing_id, business_id) -> dict:
"""Consolidates company details upto the given transaction id of a filing."""
company_profile_json = {}
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
company_profile_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
company_profile_json['parties'] = \
VersionedBusinessDetailsService.get_party_role_revision(filing.transaction_id, business_id)
company_profile_json['offices'] = \
VersionedBusinessDetailsService.get_office_revision(filing.transaction_id, business_id)
company_profile_json['shareClasses'] = \
VersionedBusinessDetailsService.get_share_class_revision(filing.transaction_id, business_id)
company_profile_json['nameTranslations'] = \
VersionedBusinessDetailsService.get_name_translations_revision(filing.transaction_id, business_id)
company_profile_json['resolutions'] = \
VersionedBusinessDetailsService.get_resolution_dates_revision(filing.transaction_id, business_id)
return company_profile_json
