def test_generate_f_rows_naics_desc(database, monkeypatch):
    """The NAICS description should be retireved from an AwardProcurement"""
    sub = SubmissionFactory()
    database.session.add(sub)
    database.session.commit()

    award = AwardProcurementFactory(submission_id=sub.submission_id,
                                    awarding_sub_tier_agency_c='1234')
    other_aps = [
        AwardProcurementFactory(submission_id=award.submission_id,
                                awarding_sub_tier_agency_c='1234')
        for _ in range(3)
    ]
    proc = FSRSProcurementFactory(
        contract_number=award.piid,
        idv_reference_number=award.parent_award_id,
        subawards=[FSRSSubcontractFactory(naics=award.naics)],
        contracting_office_aid='1234')

    database.session.add_all([award, proc] + other_aps)
    database.session.commit()

    actual = {
        result['NAICS_Description']
        for result in fileF.generate_f_rows(award.submission_id)
    }
    assert actual == {award.naics_description}
Ejemplo n.º 2
0
def generate_f_file(sess, job, is_local):
    """Write rows from fileF.generate_f_rows to an appropriate CSV.

        Args:
            sess: database session
            job: upload Job
            is_local: True if in local development, False otherwise
    """
    log_data = {
        'message': 'Starting file F generation',
        'message_type': 'ValidatorInfo',
        'job_id': job.job_id,
        'submission_id': job.submission_id,
        'file_type': 'sub_award'
    }
    logger.info(log_data)

    rows_of_dicts = fileF.generate_f_rows(job.submission_id)
    header = [key for key in fileF.mappings]  # keep order
    body = []
    for row in rows_of_dicts:
        body.append([row[key] for key in header])

    log_data['message'] = 'Writing file F CSV'
    logger.info(log_data)
    write_csv(job.original_filename, job.filename, is_local, header, body)

    log_data['message'] = 'Finished file F generation'
    logger.info(log_data)
def generate_f_file(submission_id, job_id, timestamped_name, upload_file_name,
                    is_local):
    """Write rows from fileF.generate_f_rows to an appropriate CSV.

        Args:
            submission_id - Submission ID for generation
            job_id - Job ID for upload job
            timestamped_name - Version of filename without user ID
            upload_file_name - Filename to use on S3
            is_local - True if in local development, False otherwise
    """
    log_data = {
        'message': 'Starting file F generation',
        'message_type': 'BrokerInfo',
        'submission_id': submission_id,
        'job_id': job_id,
        'file_type': 'sub_award'
    }
    logger.info(log_data)

    with job_context(job_id):
        rows_of_dicts = fileF.generate_f_rows(submission_id)
        header = [key for key in fileF.mappings]  # keep order
        body = []
        for row in rows_of_dicts:
            body.append([row[key] for key in header])

        log_data['message'] = 'Writing file F CSV'
        logger.info(log_data)
        write_csv(timestamped_name, upload_file_name, is_local, header, body)

    log_data['message'] = 'Finished file F generation'
    logger.info(log_data)
    def generate_f_file(self):
        """ Write rows from fileF.generate_f_rows to an appropriate CSV. """
        log_data = {'message': 'Starting file F generation', 'message_type': 'ValidatorInfo', 'job_id': self.job.job_id,
                    'submission_id': self.job.submission_id, 'file_type': 'sub_award'}
        logger.info(log_data)

        rows_of_dicts = fileF.generate_f_rows(self.job.submission_id)
        header = [key for key in fileF.mappings]    # keep order
        body = []
        for row in rows_of_dicts:
            body.append([row[key] for key in header])

        log_data['message'] = 'Writing file F CSV'
        logger.info(log_data)

        write_csv(self.job.original_filename, self.job.filename, self.is_local, header, body)
def generate_f_file(submission_id, job_id, timestamped_name, upload_file_name, is_local):
    """Write rows from fileF.generate_f_rows to an appropriate CSV."""

    logger.debug('Starting file F generation')

    with job_context(job_id):
        logger.debug('Calling genearte_f_rows')
        rows_of_dicts = fileF.generate_f_rows(submission_id)
        header = [key for key in fileF.mappings]    # keep order
        body = []
        for row in rows_of_dicts:
            body.append([row[key] for key in header])

        logger.debug('Writing file F CSV')
        write_csv(timestamped_name, upload_file_name, is_local, header, body)

    logger.debug('Finished file F generation')
def test_generate_f_rows_false(database, monkeypatch):
    """Make sure we're converting False to a string"""
    sub = SubmissionFactory()
    database.session.add(sub)
    database.session.commit()

    award = AwardProcurementFactory(submission_id=sub.submission_id,
                                    awarding_sub_tier_agency_c='1234')
    proc = FSRSProcurementFactory(contract_number=award.piid,
                                  idv_reference_number=award.parent_award_id,
                                  subawards=[
                                      FSRSSubcontractFactory(
                                          recovery_model_q1=False,
                                          recovery_model_q2=None)
                                  ],
                                  contracting_office_aid='1234')

    database.session.add_all([award, proc])
    database.session.commit()

    results = list(fileF.generate_f_rows(award.submission_id))
    assert results[0]['RecModelQuestion1'] == 'False'
    assert results[0]['RecModelQuestion2'] == ''
def test_generate_f_rows(database, monkeypatch):
    """generate_f_rows should find and convert subaward data relevant to a
    specific submission id. We'll compare the resulting DUNs values for
    uniqueness"""
    # Setup - create awards, procurements/grants, subawards
    sess = database.session
    sub_1 = SubmissionFactory()
    sub_2 = SubmissionFactory()
    sess.add_all([sub_1, sub_2])
    sess.commit()

    awards = [
        AwardProcurementFactory(submission_id=sub_1.submission_id,
                                piid='PIID1',
                                parent_award_id='PIID1',
                                awarding_sub_tier_agency_c='1234'),
        AwardProcurementFactory(submission_id=sub_1.submission_id,
                                piid='PIID2',
                                parent_award_id='PIID2',
                                awarding_sub_tier_agency_c='1234'),
        AwardFinancialAssistanceFactory(submission_id=sub_1.submission_id,
                                        fain='FAIN1'),
        AwardFinancialAssistanceFactory(submission_id=sub_1.submission_id,
                                        fain='FAIN2'),
        AwardProcurementFactory(submission_id=sub_2.submission_id,
                                piid='PIID1',
                                parent_award_id='PIID1',
                                awarding_sub_tier_agency_c='1234'),
        AwardFinancialAssistanceFactory(submission_id=sub_2.submission_id,
                                        fain='FAIN1')
    ]
    sess.add_all(awards)
    procurements = {}
    for piid in ('PIID1', 'PIID2', 'PIID3'):
        procurements[piid] = [
            FSRSProcurementFactory(
                contract_number=piid,
                idv_reference_number=piid,
                subawards=[FSRSSubcontractFactory() for _ in range(3)],
                contracting_office_aid='1234'),
            FSRSProcurementFactory(contract_number=piid,
                                   idv_reference_number=piid,
                                   subawards=[],
                                   contracting_office_aid='1234'),
            FSRSProcurementFactory(
                contract_number=piid,
                idv_reference_number=piid,
                subawards=[FSRSSubcontractFactory() for _ in range(2)],
                contracting_office_aid='1234')
        ]
        sess.add_all(procurements[piid])
    grants = {}
    for fain in ('FAIN0', 'FAIN1'):
        grants[fain] = [
            FSRSGrantFactory(fain=fain,
                             subawards=[
                                 FSRSSubgrantFactory() for _ in range(3)
                             ]),
            FSRSGrantFactory(fain=fain, subawards=[]),
            FSRSGrantFactory(
                fain=fain, subawards=[FSRSSubgrantFactory() for _ in range(2)])
        ]
        sess.add_all(grants[fain])
    sess.commit()

    actual = {
        result['SubAwardeeOrRecipientUniqueIdentifier']
        for result in fileF.generate_f_rows(sub_1.submission_id)
    }
    expected = set()
    expected.update(sub.duns for proc in procurements['PIID1']
                    for sub in proc.subawards)
    expected.update(sub.duns for proc in procurements['PIID2']
                    for sub in proc.subawards)
    expected.update(sub.duns for grant in grants['FAIN1']
                    for sub in grant.subawards)
    assert actual == expected