def requires()

in servicecatalog_puppet/workflow/manifest/generate_manifest_with_ids_task.py [0:0]


    def requires(self):
        requirements = dict()
        regions = config.get_regions(self.puppet_account_id)
        for launch_name, launch_details in self.manifest.get_launches_items():
            portfolio = launch_details.get("portfolio")
            for region in regions:
                if requirements.get(region) is None:
                    requirements[region] = dict()

                regional_details = requirements[region]
                if regional_details.get(portfolio) is None:
                    regional_details[portfolio] = dict(products=dict())

                portfolio_details = regional_details[portfolio]
                if portfolio_details.get("details") is None:
                    portfolio_details[
                        "details"
                    ] = get_portfolio_by_portfolio_name_task.GetPortfolioByPortfolioName(
                        manifest_file_path=self.manifest_file_path,
                        portfolio=portfolio,
                        puppet_account_id=self.puppet_account_id,
                        account_id=self.puppet_account_id,
                        region=region,
                    )

                product = launch_details.get("product")
                products = portfolio_details.get("products")
                if products.get(product) is None:
                    products[
                        product
                    ] = get_products_and_provisioning_artifacts_task.GetProductsAndProvisioningArtifactsTask(
                        manifest_file_path=self.manifest_file_path,
                        region=region,
                        portfolio=portfolio,
                        puppet_account_id=self.puppet_account_id,
                    )

        params = dict()
        parameter_by_paths = dict()
        requirements["parameters"] = params
        requirements["parameter_by_paths"] = parameter_by_paths
        home_region = config.get_home_region(self.puppet_account_id)
        for section in constants.SECTION_NAMES_THAT_SUPPORTS_PARAMETERS:
            for item_name, item_details in self.manifest.get(section, {}).items():
                if item_details.get("execution") == constants.EXECUTION_MODE_SPOKE:
                    for parameter_name, parameter_details in item_details.get(
                        "parameters", {}
                    ).items():
                        if parameter_details.get("ssm") and str(
                            parameter_details.get("ssm").get("account_id", "")
                        ) == str(self.puppet_account_id):
                            r = parameter_details.get("ssm").get(
                                "region", config.get_home_region(self.puppet_account_id)
                            )
                            name = parameter_details.get("ssm").get("name")
                            path = parameter_details.get("ssm").get("path", "")

                            if path == "":
                                accounts_and_regions = self.manifest.get_account_ids_and_regions_used_for_section_item(
                                    self.puppet_account_id, section, item_name
                                )
                                for account_id, regions in accounts_and_regions.items():
                                    for region in regions:
                                        n = name.replace(
                                            "${AWS::AccountId}", account_id
                                        ).replace("${AWS::Region}", region)

                                        params[
                                            f"{parameter_name}||{n}||{r}"
                                        ] = get_ssm_param_task.GetSSMParamTask(
                                            parameter_name=parameter_name,
                                            name=n,
                                            region=r,
                                            path=parameter_details.get("ssm").get(
                                                "path", ""
                                            ),
                                            recursive=parameter_details.get("ssm").get(
                                                "recursive", True
                                            ),
                                            depends_on=parameter_details.get("ssm").get(
                                                "depends_on", []
                                            ),
                                            manifest_file_path=self.manifest_file_path,
                                            puppet_account_id=self.puppet_account_id,
                                            spoke_account_id=self.puppet_account_id,
                                            spoke_region=r,
                                        )
                            else:
                                parameter_by_paths[
                                    path
                                ] = get_ssm_param_task.GetSSMParamByPathTask(
                                    path=parameter_details.get("ssm").get("path", ""),
                                    recursive=parameter_details.get("ssm").get(
                                        "recursive", True
                                    ),
                                    region=parameter_details.get("ssm").get(
                                        "recursive", home_region
                                    ),
                                    depends_on=parameter_details.get("ssm").get(
                                        "depends_on", []
                                    ),
                                    manifest_file_path=self.manifest_file_path,
                                    puppet_account_id=self.puppet_account_id,
                                    spoke_account_id=self.puppet_account_id,
                                    spoke_region=home_region,
                                )

        return requirements