def post()

in src/lambdas/r8s_api_handler/processors/shape_rule_processor.py [0:0]
86 lines of code
10 McCabe index (conditional complexity)

    def post(self, event):
        _LOG.debug(f'Create shape rule event: {event}')
        validate_params(event, (PARENT_ID_ATTR, RULE_ACTION_ATTR,
                                CONDITION_ATTR,
                                FIELD_ATTR, VALUE_ATTR))

        parent_id = event.get(PARENT_ID_ATTR)
        parent = self.parent_service.get_parent_by_id(
            parent_id=parent_id
        )
        _LOG.debug(f'Validating parent.')
        self._validate_parent(parent=parent)
        applications = self.application_service.resolve_application(
            event=event)
        if not applications:
            _LOG.warning(f'No application found matching given query.')
            return build_response(
                code=RESPONSE_BAD_REQUEST_CODE,
                content=f'No application found matching given query.'
            )
        app_ids = [app.application_id for app in applications]
        if not parent or parent.application_id not in app_ids:
            _LOG.warning(f'No parent found matching given query.')
            return build_response(
                code=RESPONSE_BAD_REQUEST_CODE,
                content=f'No parent found matching given query.'
            )

        cloud = None
        if parent.cloud:
            cloud = parent.cloud
        elif parent.tenant_name:
            tenant = self.tenant_service.get(tenant_name=parent.tenant_name)
            if not tenant:
                _LOG.debug(f'Tenant {parent.tenant_name} linked to '
                           f'parent {parent.parent_id} does not exist.')
                return build_response(
                    code=RESPONSE_BAD_REQUEST_CODE,
                    content=f'Tenant {parent.tenant_name} linked to '
                            f'parent {parent.parent_id} does not exist.'
                )
            cloud = tenant.cloud

        if not cloud:
            _LOG.error(f'Parent {parent.parent_id} must have either '
                       f'SPECIFIC of ALL#CLOUD scope')
            return build_response(
                code=RESPONSE_BAD_REQUEST_CODE,
                content=f'Parent {parent.parent_id} must have either '
                        f'SPECIFIC of ALL#CLOUD scope'
            )

        shape_rule = self.parent_service.create_shape_rule(
            action=event.get(RULE_ACTION_ATTR, '').lower(),
            cloud=parent.cloud.upper(),
            condition=event.get(CONDITION_ATTR, '').lower(),
            field=event.get(FIELD_ATTR, '').lower(),
            value=event.get(VALUE_ATTR, '').lower()
        )
        _LOG.debug(f'Shape rule created: {shape_rule.as_dict()}')

        errors = self._validate(shape_rule=shape_rule)
        if errors:
            _LOG.error(f'Shape rule is invalid: {", ".join(errors)}')
            return build_response(
                code=RESPONSE_BAD_REQUEST_CODE,
                content=f'Shape rule is invalid: {", ".join(errors)}'
            )

        parent_meta = self.parent_service.get_parent_meta(
            parent=parent)
        _LOG.debug(f'Parent \'{parent.parent_id}\' '
                   f'meta extracted')
        self.parent_service.add_shape_rule_to_meta(
            parent_meta=parent_meta,
            shape_rule=shape_rule
        )
        _LOG.debug(f'Shape rule added to parent '
                   f'\'{parent.parent_id}\' meta')
        self.parent_service.set_parent_meta(
            parent=parent,
            meta=parent_meta
        )

        self.parent_service.save(parent=parent)
        _LOG.debug(f'Parent \'{parent.parent_id}\' saved')

        shape_rule_dto = self.parent_service.get_shape_rule_dto(
            shape_rule=shape_rule)

        _LOG.debug(f'Response: {shape_rule_dto}')

        return build_response(
            code=RESPONSE_OK_CODE,
            content=shape_rule_dto
        )