Пример #1
0
    def get():
        name = get_query_param_str('name')
        location = get_query_param_str('location')
        entity_type = get_query_param_str('entity_type_cd')
        request_action = get_query_param_str('request_action_cd')

        service = None

        if not validate_name_request(location, entity_type, request_action):
            return  # TODO: Return invalid response! What is it?

        valid_location = location in [
            ValidLocations.CA_NOT_BC.value, ValidLocations.INTL.value
        ]
        valid_entity_type = entity_type in XproUnprotectedNameEntityTypes.list(
        )

        try:
            if valid_location and valid_entity_type and request_action in (
                    AnalysisRequestActions.NEW.value,
                    AnalysisRequestActions.AML.value,
                    AnalysisRequestActions.CHG.value,
                    AnalysisRequestActions.ASSUMED.value,
                    AnalysisRequestActions.REN.value,
                    AnalysisRequestActions.REH.value):

                # Use UnprotectedNameAnalysisService
                service = XproNameAnalysisService()
                builder = NameAnalysisBuilder(service)

            else:
                raise Exception('Invalid scenario')

            if not service:
                raise ValueError('Invalid service provided')
            if not builder:
                raise ValueError('Invalid builder provided')

            # Register and initialize the builder
            service.use_builder(builder)  # Required step! TODO: Enforce this!
            service.set_entity_type(
                entity_type)  # Required step! TODO: Enforce this!
            service.set_name(name)  # Required step! TODO: Enforce this!

        except Exception as err:
            print('Error initializing XproNameAnalysis service: ' +
                  repr(err.with_traceback(None)))
            raise

        # Perform the name analysis - execute analysis using the supplied builder
        # @:return an array of ProcedureResult[]
        analysis = service.execute_analysis()

        # Build the appropriate response for the analysis result
        analysis_response = AnalysisResponse(service, analysis)
        payload = analysis_response.build_response().to_json()

        response = make_response(payload, 200)
        return response
Пример #2
0
    def get(self):
        try:
            filters = []

            # Validate the request
            if len(request.args) == 0:
                raise InvalidInputError(
                    message='No query parameters were specified in the request'
                )

            nr_num_query_str = get_query_param_str('nrNum')
            email_address_query_str = get_query_param_str('emailAddress')
            phone_number_query_str = get_query_param_str('phoneNumber')

            if not nr_num_query_str:
                raise InvalidInputError(message='An nrNum must be provided')
            else:
                if not email_address_query_str and not phone_number_query_str:
                    raise InvalidInputError(
                        message=
                        'Either an emailAddress or phoneNumber must be provided'
                    )

            # Continue
            nr_num = parse_nr_num(nr_num_query_str)
            email_address = email_address_query_str

            phone_number = get_query_param_str('phoneNumber')
            # Filter on addresses
            # address_line = get_query_param_str('addrLine1')

            if nr_num:
                filters.append(func.lower(Request.nrNum) == nr_num.lower())
            if phone_number:
                strip_phone_number_chars_regex = r"[^0-9]"
                filters.append(
                    Request.applicants.any(
                        func.regexp_replace(
                            Applicant.phoneNumber,
                            strip_phone_number_chars_regex, '', 'g').contains(
                                re.sub(strip_phone_number_chars_regex, '',
                                       phone_number))))

            if email_address:
                filters.append(
                    Request.applicants.any(
                        func.lower(Applicant.emailAddress).startswith(
                            email_address.lower())))
            '''
            Filter on addresses
            if address_line:
                filters.append(
                    Request.applicants.any(
                        func.lower(Applicant.addrLine1).startswith(address_line.lower())
                    )
                )
            '''

            criteria = RequestQueryCriteria(nr_num=nr_num, filters=filters)

            results = Request.find_by_criteria(criteria)

            if not results:
                results = []

        except InvalidInputError as err:
            return handle_exception(err, err.message, 400)
        except Exception as err:
            return handle_exception(err,
                                    'Error retrieving the NR from the db.',
                                    500)

        if nr_num and len(results) == 1:
            nr_model = results[0]

            if nr_model.requestTypeCd and (not nr_model.entity_type_cd
                                           or not nr_model.request_action_cd):
                # If requestTypeCd is set, but a request_entity (entity_type_cd) and a request_action (request_action_cd)
                # are not, use get_mapped_entity_and_action_code to map the values from the requestTypeCd
                entity_type, request_action = get_mapped_entity_and_action_code(
                    nr_model.requestTypeCd)
                nr_model.entity_type_cd = entity_type
                nr_model.request_action_cd = request_action

            response_data = nr_model.json()
            # Add the list of valid Name Request actions for the given state to the response
            response_data['actions'] = get_nr_state_actions(
                results[0].stateCd, results[0])
            return jsonify(response_data), 200
        elif len(results) > 0:
            # We won't add the list of valid Name Request actions for the given state to the response if we're sending back a list
            # If the user / client accessing this data needs the Name Request actions, GET the individual record using NameRequest.get
            # This method, NameRequests.get is for Existing NR Search
            return jsonify(list(map(lambda result: result.json(),
                                    results))), 200

        # We won't add the list of valid Name Request actions for the given state to the response if we're sending back a list
        # If the user / client accessing this data needs the Name Request actions, GET the individual record using NameRequest.get
        # This method, NameRequests.get is for Existing NR Search
        return jsonify(results), 200
Пример #3
0
    def get():
        """Get structure analysis for a name."""
        name = get_query_param_str('name')
        allowed_special_chars = [
            '/', '[', ']', '^', '*', '+', '=', '&', '(', ')', ',', '”', '’',
            '#', '@', '!', '?', ';', ':'
        ]
        for special_char in allowed_special_chars:
            name = name.replace(special_char, ' ')
        location = get_query_param_str('location')
        entity_type = get_query_param_str('entity_type_cd')
        request_action = get_query_param_str('request_action_cd')
        designation_only = get_query_param_str('analysis_type') in [
            'designation', None
        ]
        # TODO: take out xpro flow entirely (not used in name analysis flow anymore)
        xpro = get_query_param_str('jurisdiction') not in ['BC', None]
        if xpro:
            return jsonify(
                message=['xpro not supported']), HTTPStatus.NOT_IMPLEMENTED
        service = None

        errors = bc_validate_name_request(location, entity_type,
                                          request_action)  # \
        # if not xpro else xpro_validate_name_request(location, entity_type, request_action)
        if errors:
            return jsonify(message=errors), HTTPStatus.BAD_REQUEST

        # # used for BC
        # valid_protected_entity_type = None
        # valid_unprotected_entity_type = None
        # is_protected_action = None
        # is_unprotected_action = None
        # # used for XPRO
        # valid_xpro_action = None
        # # used for both
        # valid_location = None
        # valid_entity_type = None
        # if xpro:
        #     valid_location = location in [ValidLocations.CA_NOT_BC.value, ValidLocations.INTL.value]
        #     valid_entity_type = entity_type in XproUnprotectedNameEntityTypes.list()
        #     valid_xpro_action = request_action in [
        #         AnalysisRequestActions.NEW.value,
        #         AnalysisRequestActions.AML.value,
        #         AnalysisRequestActions.CHG.value,
        #         AnalysisRequestActions.ASSUMED.value,
        #         AnalysisRequestActions.REN.value,
        #         AnalysisRequestActions.REH.value,
        #         AnalysisRequestActions.MVE.value
        #     ]
        # else:
        #     valid_location = location == ValidLocations.CA_BC.value
        #     valid_protected_entity_type = entity_type in BCProtectedNameEntityTypes.list()
        #     valid_unprotected_entity_type = entity_type in BCUnprotectedNameEntityTypes.list()
        #     is_protected_action = request_action in [
        #         AnalysisRequestActions.NEW.value,
        #         AnalysisRequestActions.CHG.value,
        #         AnalysisRequestActions.MVE.value
        #     ]
        #     is_unprotected_action = request_action in [AnalysisRequestActions.NEW.value]

        try:
            # if xpro:
            #     if valid_location and valid_entity_type and valid_xpro_action:
            #         service = ProtectedNameAnalysisService() \
            #             if request_action == AnalysisRequestActions.MVE.value else XproNameAnalysisService()
            #         builder = NameAnalysisBuilder(service)
            #     else:
            #         return jsonify(message=['Invalid scenario']), HTTPStatus.BAD_REQUEST

            # else:
            # if valid_location and valid_protected_entity_type:  # and is_protected_action:
            #  # Use ProtectedNameAnalysisService
            service = ProtectedNameAnalysisService()
            builder = NameAnalysisBuilder(service)
            # else:  # valid_location and valid_unprotected_entity_type:  # and is_unprotected_action:
            # Use UnprotectedNameAnalysisService
            # service = UnprotectedNameAnalysisService()
            # builder = NameAnalysisBuilder(service)
            # else:
            #     return jsonify(message=['Invalid scenario']), HTTPStatus.BAD_REQUEST

            if not service:
                return jsonify(message=['Failed to initialize service'
                                        ]), HTTPStatus.INTERNAL_SERVER_ERROR
            if not builder:
                return jsonify(message=['Failed to initialize builder'
                                        ]), HTTPStatus.INTERNAL_SERVER_ERROR

            # Register and initialize the builder
            service.use_builder(builder)  # Required step! TODO: Enforce this!
            service.set_entity_type(
                entity_type)  # Required step! TODO: Enforce this!
            service.set_name(
                name, designation_only)  # Required step! TODO: Enforce this!

        except Exception as err:
            current_app.logger.error(
                'Error initializing NameAnalysis service: ' +
                repr(err.with_traceback(None)))
            raise

        # Perform the name analysis - execute analysis using the supplied builder
        # @:return an array of ProcedureResult[]
        analysis = service.execute_analysis(designation_only)

        # Build the appropriate response for the analysis result
        analysis_response = BcAnalysisResponse(service, analysis)  # \
        # if not xpro else XproAnalysisResponse(service, analysis)

        # Remove issues for end designation more than once if they are not duplicates
        valid_issues = []
        for issue in analysis_response.issues:
            if issue.issue_type == AnalysisIssueCodes.END_DESIGNATION_MORE_THAN_ONCE:
                valid_name_actions = []
                seen_designations = []
                for name_action in issue.name_actions:
                    if name_action.word in seen_designations:
                        valid_name_actions.append(name_action)
                    else:
                        seen_designations.append(name_action.word)
                if len(valid_name_actions) > 0:
                    issue.name_actions = valid_name_actions
                    valid_issues.append(issue)
                # else ^ this issue will not be added to the response
            else:
                valid_issues.append(issue)

        analysis_response.issues = valid_issues
        payload = analysis_response.build_response().to_json()
        response = make_response(payload, HTTPStatus.OK)
        return response