def test_get_most_recent_filing_by_legal_type_db_field(session):
"""Assert that the most recent legal filing can be retrieved.
Create 3 filings, find the 2 one by the type only.
"""
business = factory_business('CP1234567')
uow = versioning_manager.unit_of_work(session)
transaction = uow.create_transaction(session)
# filing 1
effective_date = '2001-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
base_filing['filing']['header']['effectiveDate'] = effective_date
filing1 = Filing()
filing1._filing_date = completion_date
filing1.business_id = business.id
filing1.filing_json = base_filing
filing1.effective_date = datetime.datetime.fromisoformat(effective_date)
filing1.payment_token = 'token'
filing1.transaction_id = transaction.id
filing1.payment_completion_date = completion_date
filing1.save()
# filing 2 <- target
effective_date = '2002-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(FILING_HEADER)
base_filing['filing']['header']['effectiveDate'] = effective_date
base_filing['filing']['header']['name'] = 'changeOfDirectors'
base_filing['filing']['header']['availableOnPaperOnly'] = True
filing2 = Filing()
filing2._filing_date = completion_date
filing2.business_id = business.id
filing2.filing_json = base_filing
filing2.effective_date = datetime.datetime.fromisoformat(effective_date)
filing2.payment_token = 'token'
filing2.transaction_id = transaction.id
filing2.payment_completion_date = completion_date
filing2.save()
# filing 3
effective_date = '2003-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
base_filing['filing']['header']['effectiveDate'] = effective_date
filing3 = Filing()
filing3._filing_date = completion_date
filing3.business_id = business.id
filing3.filing_json = base_filing
filing3.effective_date = datetime.datetime.fromisoformat(effective_date)
filing3.payment_token = 'token'
filing3.transaction_id = transaction.id
filing3.payment_completion_date = completion_date
filing3.save()
f = Filing.get_most_recent_legal_filing(business.id, 'changeOfDirectors')
assert f.filing_type == 'changeOfDirectors'
assert f.id == filing2.id
def factory_completed_filing(business, data_dict, filing_date=FROZEN_DATETIME, payment_token=None, colin_id=None):
"""Create a completed filing."""
if not payment_token:
payment_token = str(base64.urlsafe_b64encode(uuid.uuid4().bytes)).replace('=', '')
with freeze_time(filing_date):
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.filing_json = data_dict
filing.save()
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing.transaction_id = transaction.id
filing.payment_token = payment_token
filing.effective_date = filing_date
filing.payment_completion_date = filing_date
if colin_id:
colin_event = ColinEventId()
colin_event.colin_event_id = colin_id
colin_event.filing_id = filing.id
colin_event.save()
filing.save()
return filing
def set_effective_date(business: Business, filing: Filing):
"""Set the effective date of the Filing."""
filing_type = filing.filing_json['filing']['header']['name']
if filing_type == Filing.FILINGS['incorporationApplication'].get('name') and \
(fe_date := filing.filing_json['filing']['header'].get('futureEffectiveDate')):
filing.effective_date = datetime.datetime.fromisoformat(fe_date)
filing.save()
def test_get_most_recent_filing_by_legal_type_in_json(session):
"""Assert that the most recent legal filing can be retrieved."""
business = factory_business('CP1234567')
uow = versioning_manager.unit_of_work(session)
transaction = uow.create_transaction(session)
for i in range(1, 5):
effective_date = f'200{i}-07-01T00:00:00+00:00'
completion_date = datetime.datetime.fromisoformat(effective_date)
base_filing = copy.deepcopy(ANNUAL_REPORT)
cod = copy.deepcopy(CHANGE_OF_DIRECTORS)
base_filing['filing']['changeOfDirectors'] = cod
base_filing['filing']['header']['effectiveDate'] = effective_date
filing = Filing()
filing._filing_date = completion_date
filing.business_id = business.id
filing.filing_json = base_filing
filing.effective_date = datetime.datetime.fromisoformat(effective_date)
filing.payment_token = 'token'
filing.transaction_id = transaction.id
filing.payment_completion_date = completion_date
filing.save()
f = Filing.get_most_recent_legal_filing(business.id, 'changeOfDirectors')
assert f.effective_date == datetime.datetime.fromisoformat(effective_date)
assert f.filing_type == 'annualReport'
assert f.id == filing.id
def factory_incorporation_filing(business, data_dict, filing_date=FROZEN_DATETIME, effective_date=FROZEN_DATETIME):
"""Create a filing."""
filing = Filing()
filing.business_id = business.id
filing.filing_date = filing_date
filing.effective_date = effective_date
filing.filing_json = data_dict
filing.save()
return filing
def _set_effective_date(business: Business, filing: Filing):
filing_type = filing.filing_json['filing']['header']['name']
if filing_type == Filing.FILINGS['incorporationApplication'].get(
'name'):
fe_date = filing.filing_json['filing']['header'].get(
'futureEffectiveDate')
if fe_date:
filing.effective_date = datetime.datetime.fromisoformat(
fe_date)
filing.save()
elif business.legal_type != Business.LegalTypes.COOP.value:
if filing_type == 'changeOfAddress':
effective_date = LegislationDatetime.tomorrow_midnight()
filing.filing_json['filing']['header'][
'futureEffectiveDate'] = effective_date
filing.effective_date = effective_date
filing.save()
def _set_effective_date(business: Business, filing: Filing):
filing_type = filing.filing_json['filing']['header']['name']
if business.legal_type != 'CP':
if filing_type == 'changeOfAddress':
effective_date = datetime.datetime.combine(datetime.date.today() + datedelta.datedelta(days=1),
datetime.datetime.min.time())
filing.filing_json['filing']['header']['futureEffectiveDate'] = effective_date
filing.effective_date = effective_date
filing.save()
async def test_publish_event(app, session, stan_server, event_loop, client_id,
entity_stan, future):
"""Assert that filing event is placed on the queue."""
# Call back for the subscription
from entity_queue_common.service import ServiceWorker
from entity_filer.worker import APP_CONFIG, publish_event, qsm
from legal_api.models import Business, Filing
# file handler callback
msgs = []
async def cb_file_handler(msg):
nonlocal msgs
nonlocal future
msgs.append(msg)
if len(msgs) == 1:
future.set_result(True)
event_handler_subject = APP_CONFIG.ENTITY_EVENT_PUBLISH_OPTIONS['subject']
await entity_stan.subscribe(
subject=event_handler_subject,
queue=f'entity_queue.{event_handler_subject}',
durable_name=f'entity_durable_name.{event_handler_subject}',
cb=cb_file_handler)
s = ServiceWorker()
s.sc = entity_stan
qsm.service = s
# Setup
filing = Filing()
filing.id = 101
filing.effective_date = datetime.utcnow().replace(tzinfo=timezone.utc)
filing.filing_json = ANNUAL_REPORT
business = Business()
business.identifier = 'CP1234567'
business.legal_name = 'CP1234567 - Legal Name'
# Test
await publish_event(business, filing)
try:
await asyncio.wait_for(future, 2, loop=event_loop)
except Exception as err:
print(err)
# check it out
assert len(msgs) == 1
event_msg = json.loads(msgs[0].data.decode('utf-8'))
assert event_msg['filing']['filingId'] == 101
assert event_msg['filing']['identifier'] == 'CP1234567'
assert event_msg['filing']['legalFilings'] == ['annualReport']
def load_historic_filings(corp_num: str, business: Business, legal_type: str):
"""Load historic filings for a business."""
try:
# get historic filings
r = requests.get(
f'{COLIN_API}/api/v1/businesses/{legal_type}/{corp_num}/filings/historic',
timeout=TIMEOUT)
if r.status_code != HTTPStatus.OK or not r.json():
print(
f'skipping history for {corp_num} historic filings not found')
else:
for historic_filing in r.json():
uow = versioning_manager.unit_of_work(db.session)
transaction = uow.create_transaction(db.session)
filing = Filing()
filing_date = historic_filing['filing']['header']['date']
filing.filing_date = datetime.datetime.strptime(
filing_date, '%Y-%m-%d')
filing.business_id = business.id
filing.filing_json = historic_filing
for colin_id in filing.filing_json['filing']['header'][
'colinIds']:
colin_event_id = ColinEventId()
colin_event_id.colin_event_id = colin_id
filing.colin_event_ids.append(colin_event_id)
filing.transaction_id = transaction.id
filing._filing_type = historic_filing['filing']['header'][
'name']
filing.paper_only = True
filing.effective_date = datetime.datetime.strptime(
historic_filing['filing']['header']['effectiveDate'],
'%Y-%m-%d')
updater_user = User.find_by_username(UPDATER_USERNAME)
filing.submitter_id = updater_user.id
filing.source = Filing.Source.COLIN.value
db.session.add(filing)
# only commit after all historic filings were added successfully
db.session.commit()
LOADED_FILING_HISTORY.append(corp_num)
except requests.exceptions.Timeout:
print('rolling back partial changes...')
db.session.rollback()
FAILED_FILING_HISTORY.append(corp_num)
print('colin_api request timed out getting historic filings.')
except Exception as err:
print('rolling back partial changes...')
db.session.rollback()
FAILED_FILING_HISTORY.append(corp_num)
raise err
def test_get_filings_by_status__default_order(session):
"""Assert that a filing can be retrieved.
by status and is returned in the default order.
default order is submission_date, and then effective_date.
"""
# setup
base_filing = copy.deepcopy(FILING_HEADER)
base_filing['specialResolution'] = SPECIAL_RESOLUTION
uow = versioning_manager.unit_of_work(session)
business = factory_business('CP1234567')
completion_date = datetime.datetime.utcnow().replace(
tzinfo=datetime.timezone.utc)
# setup - create multiple filings on the same day & time
filing_ids = []
file_counter = -1
with freeze_time(completion_date):
for i in range(0, 5):
transaction = uow.create_transaction(session)
payment_token = str(i)
effective_date = f'200{i}-04-15T00:00:00+00:00'
base_filing['filing']['header']['effectiveDate'] = effective_date
filing = Filing()
filing._filing_date = completion_date
filing.business_id = business.id
filing.filing_json = base_filing
filing.effective_date = datetime.datetime.fromisoformat(
effective_date)
filing.payment_token = payment_token
filing.transaction_id = transaction.id
filing.payment_completion_date = completion_date
filing.save()
filing_ids.append(filing.id)
file_counter += 1
# test
rv = Filing.get_filings_by_status(business.id,
[Filing.Status.COMPLETED.value])
# check
assert rv
# filings should be in newest to oldest effective date order
for filing in rv:
assert filing.id == filing_ids[file_counter]
file_counter -= 1
async def test_publish_email_message(app, session, stan_server, event_loop,
client_id, entity_stan, future):
"""Assert that payment tokens can be retrieved and decoded from the Queue."""
# Call back for the subscription
from entity_queue_common.service import ServiceWorker
from entity_pay.worker import APP_CONFIG, publish_email_message, qsm
from legal_api.models import Filing
# file handler callback
msgs = []
async def cb_file_handler(msg):
nonlocal msgs
nonlocal future
msgs.append(msg)
if len(msgs) == 1:
future.set_result(True)
file_handler_subject = APP_CONFIG.EMAIL_PUBLISH_OPTIONS['subject']
await subscribe_to_queue(entity_stan, file_handler_subject,
f'entity_queue.{file_handler_subject}',
f'entity_durable_name.{file_handler_subject}',
cb_file_handler)
s = ServiceWorker()
s.sc = entity_stan
qsm.service = s
# Test
filing = Filing()
filing.id = 101
filing.filing_type = 'incorporationApplication'
filing_date = datetime.datetime.utcnow()
filing.filing_date = filing_date
filing.effective_date = filing_date
await publish_email_message(filing)
try:
await asyncio.wait_for(future, 2, loop=event_loop)
except Exception as err:
print(err)
# check it out
assert len(msgs) == 1
assert get_data_from_msg(msgs[0], 'id') == filing.id
assert get_data_from_msg(msgs[0], 'type') == filing.filing_type
assert get_data_from_msg(msgs[0], 'option') == 'filed'
def test_get_registrar_for_a_filing(session):
"""Assert that the registrar effective on that date is returned."""
b = factory_business('CP1234567')
filing = Filing()
filing.business_id = b.id
filing.filing_date = datetime.datetime(2012, 6, 6)
filing.effective_date = datetime.datetime(2012, 6, 6)
filing.filing_data = ANNUAL_REPORT
filing.save()
registrar_info = RegistrarInfo.get_registrar_info(filing.effective_date)
assert registrar_info['startDate']
assert registrar_info['endDate']
assert registrar_info['signature']
assert registrar_info['name'] == 'ANGELO COCCO'
assert registrar_info['title'] == 'A/Registrar of Companies'
def _save_filing(
client_request: LocalProxy, # pylint: disable=too-many-return-statements,too-many-branches
business_identifier: str,
user: User,
filing_id: int
) -> Tuple[Union[Business, RegistrationBootstrap], Filing, dict, int]:
"""Save the filing to the ledger.
If not successful, a dict of errors is returned.
Returns: {
Business: business model object found for the identifier provided
Filing: filing model object for the submitted filing
dict: a dict of errors
int: the HTTPStatus error code
@TODO refactor to a set of single putpose routines
}
"""
json_input = client_request.get_json()
if not json_input:
return None, None, {'message':
f'No filing json data in body of post for {business_identifier}.'}, \
HTTPStatus.BAD_REQUEST
if business_identifier.startswith('T'):
# bootstrap filing
bootstrap = RegistrationBootstrap.find_by_identifier(
business_identifier)
business = None
if not bootstrap:
return None, None, {
'message': f'{business_identifier} not found'
}, HTTPStatus.NOT_FOUND
if client_request.method == 'PUT':
rv = db.session.query(Filing). \
filter(Filing.temp_reg == business_identifier). \
filter(Filing.id == filing_id). \
one_or_none()
if not rv:
return None, None, {
'message': f'{business_identifier} no filings found'
}, HTTPStatus.NOT_FOUND
filing = rv
else:
filing = Filing()
filing.temp_reg = bootstrap.identifier
if not json_input['filing'].get('business'):
json_input['filing']['business'] = {}
json_input['filing']['business'][
'identifier'] = bootstrap.identifier
else:
# regular filing for a business
business = Business.find_by_identifier(business_identifier)
if not business:
return None, None, {
'message': f'{business_identifier} not found'
}, HTTPStatus.NOT_FOUND
if client_request.method == 'PUT':
rv = db.session.query(Business, Filing). \
filter(Business.id == Filing.business_id). \
filter(Business.identifier == business_identifier). \
filter(Filing.id == filing_id). \
one_or_none()
if not rv:
return None, None, {
'message': f'{business_identifier} no filings found'
}, HTTPStatus.NOT_FOUND
filing = rv[1]
else:
filing = Filing()
filing.business_id = business.id
try:
filing.submitter_id = user.id
filing.filing_json = json_input
filing.source = filing.filing_json['filing']['header'].get(
'source', Filing.Source.LEAR.value)
if filing.source == Filing.Source.COLIN.value:
try:
filing.filing_date = datetime.datetime.fromisoformat(
filing.filing_json['filing']['header']['date'])
for colin_id in filing.filing_json['filing']['header'][
'colinIds']:
colin_event_id = ColinEventId()
colin_event_id.colin_event_id = colin_id
filing.colin_event_ids.append(colin_event_id)
except KeyError:
current_app.logger.error(
'Business:%s missing filing/header values, unable to save',
business.identifier)
return None, None, {
'message': 'missing filing/header values'
}, HTTPStatus.BAD_REQUEST
else:
filing.filing_date = datetime.datetime.utcnow()
# for any legal type, set effective date as set in json; otherwise leave as default
filing.effective_date = \
datetime.datetime.fromisoformat(filing.filing_json['filing']['header']['effectiveDate']) \
if filing.filing_json['filing']['header'].get('effectiveDate', None) else datetime.datetime.utcnow()
filing.save()
except BusinessException as err:
return None, None, {'error': err.error}, err.status_code
return business or bootstrap, filing, None, None
filing_date, '%Y-%m-%d')
filing.business_id = business.id
filing.filing_json = historic_filing
for colin_id in filing.filing_json['filing'][
'header']['colinIds']:
colin_event_id = ColinEventId()
colin_event_id.colin_event_id = colin_id
filing.colin_event_ids.append(
colin_event_id)
filing.transaction_id = transaction.id
filing_type = historic_filing['filing'][
'header']['name']
filing.paper_only = True
filing.effective_date = datetime.datetime.strptime(
historic_filing['filing']['header']
['effectiveDate'], '%Y-%m-%d')
# set user id to updater-job id (this will ensure that filing source is set to COLIN)
updater_user = User.find_by_username(
UPDATER_USERNAME)
filing.submitter_id = updater_user.id
db.session.add(filing)
db.session.commit()
LOADED_COOPS_HISTORY.append(row["CORP_NUM"])
except requests.exceptions.Timeout as timeout:
LOADED_COOPS_HISTORY.append(row["CORP_NUM"])
print(
def _save_filing(client_request: LocalProxy, business_identifier: str,
user: User,
filing_id: int) -> Tuple[Business, Filing, dict, int]:
"""Save the filing to the ledger.
If not successful, a dict of errors is returned.
Returns: {
Business: business model object found for the identifier provided
Filing: filing model object for the submitted filing
dict: a dict of errors
int: the HTTPStatus error code
}
"""
json_input = client_request.get_json()
if not json_input:
return None, None, {'message':
f'No filing json data in body of post for {business_identifier}.'}, \
HTTPStatus.BAD_REQUEST
business = Business.find_by_identifier(business_identifier)
if not business:
return None, None, {
'message': f'{business_identifier} not found'
}, HTTPStatus.NOT_FOUND
if client_request.method == 'PUT':
rv = db.session.query(Business, Filing). \
filter(Business.id == Filing.business_id). \
filter(Business.identifier == business_identifier). \
filter(Filing.id == filing_id). \
one_or_none()
if not rv:
return None, None, {
'message': f'{business_identifier} no filings found'
}, HTTPStatus.NOT_FOUND
filing = rv[1]
else:
filing = Filing()
filing.business_id = business.id
try:
filing.submitter_id = user.id
filing.filing_json = json_input
if user.username == 'coops-updater-job':
try:
filing.filing_date = datetime.datetime.fromisoformat(
filing.filing_json['filing']['header']['date'])
filing.colin_event_id = filing.filing_json['filing'][
'header']['colinId']
except KeyError:
current_app.logger.error(
'Business:%s missing filing/header values, unable to save',
business.identifier)
return None, None, {
'message': 'missing filing/header values'
}, HTTPStatus.BAD_REQUEST
else:
filing.filing_date = datetime.datetime.utcnow()
# for coops, set effective date as set in json; otherwise leave as default
if business.legal_type == 'CP':
if filing.filing_json['filing']['header'].get(
'effectiveDate', None):
filing.effective_date = \
datetime.datetime.fromisoformat(filing.filing_json['filing']['header']['effectiveDate'])
filing.save()
except BusinessException as err:
return None, None, {'error': err.error}, err.status_code
return business, filing, None, None
