def yield_licensed_rulesets()

in src/handlers/ruleset_handler.py [0:0]

• 33 lines of code
• 11 McCabe index (conditional complexity)

    def yield_licensed_rulesets(
            self, customer: Optional[str] = None, name: Optional[str] = None,
            version: Optional[str] = None, cloud: Optional[str] = None,
            ) -> Generator[Ruleset, None, None]:

        def _check(ruleset: Ruleset) -> bool:
            """
            We currently don't have names and version for licensed
            rule-sets. Just their id
            :param ruleset:
            :return:
            """
            if name and ruleset.name != name:
                return False
            if version and ruleset.version != version:
                return False
            if cloud and ruleset.cloud != cloud.upper():
                return False
            return True

        if not customer:  # SYSTEM
            # TODO probably remove
            yield from self.ruleset_service.iter_licensed(
                name=name,
                version=version,
                cloud=cloud,
            )
            return
        applications = self.application_service.list(
            customer=customer,
            _type=ApplicationType.CUSTODIAN_LICENSES.value,
            deleted=False
        )

        licenses = tuple(self.license_service.to_licenses(applications))
        license_keys = {_license.license_key for _license in licenses}

        ids = chain.from_iterable(
            _license.ruleset_ids for _license in licenses
        )
        source = self.ruleset_service.iter_by_lm_id(ids)
        # source contains rule-sets from applications, now we
        # just filter them by input params
        for rs in filter(_check, source):
            rs.license_keys = list(set(rs.license_keys) & license_keys)
            yield rs