def _resolve_rulesets()

in src/lambdas/custodian_api_handler/handlers/job_handler.py [0:0]

• 41 lines of code
• 7 McCabe index (conditional complexity)

    def _resolve_rulesets(self, tenant: Tenant, domain: RuleDomain,
                          ruleset_names: set[RulesetName],
                          licenses: tuple[License, ...]
                          ) -> tuple[list[RulesetName], License | None, list[RulesetName]]:
        """
        :param tenant:
        :param domain:
        :param ruleset_names:
        :param licenses:
        :return:
        """
        if not ruleset_names and not licenses:
            # or use all local rulesets
            _LOG.warning('No rulesets were provided and no licenses '
                         'are activated')
            raise ResponseFactory(HTTPStatus.BAD_REQUEST).message(
                f'No licenses are activated for tenant {tenant.name} and '
                f'not ruleset names provided. '
                f'Specify ruleset names to use local rulesets or activate '
                f'a license'
            ).exc()
        if not ruleset_names:  # but licenses
            _LOG.info('No rulesets were provided but some licenses are '
                      'activated. Resolving all rulesets from license')
            standard_rulesets = []
            lic, licensed_rulesets = self._resolve_all_from_licenses(
                tenant=tenant,
                domain=domain,
                licenses=licenses
            )
        elif not licenses:  # but ruleset names
            _LOG.info('No licenses are activated but some rulesets were '
                      'provided. Resolving local rulesets')
            standard_rulesets = self._resolve_local(
                tenant=tenant,
                domain=domain,
                ruleset_names=ruleset_names
            )
            lic, licensed_rulesets = None, []
        else:  # both ruleset names and licenses
            _LOG.info('Some licenses are activated and rulesets were '
                      'provided.')
            standard_rulesets, lic, licensed_rulesets = self._resolve_from_names_and_licenses(
                tenant=tenant,
                domain=domain,
                ruleset_names=ruleset_names,
                licenses=licenses
            )
        return standard_rulesets, lic, licensed_rulesets