def _validate_localizations()

in experimenter/experimenter/experiments/api/v5/serializers.py [0:0]
67 lines of code
13 McCabe index (conditional complexity)

    def _validate_localizations(self, data):
        is_localized = data.get("is_localized")
        if not is_localized:
            return data

        application = data.get("application")
        if application != NimbusExperiment.Application.DESKTOP:
            raise serializers.ValidationError(
                {
                    "application": [
                        "Localized experiments are only supported for Firefox Desktop."
                    ]
                }
            )

        min_version = data.get("firefox_min_version", "")
        supported_version = NimbusExperiment.Version.parse(
            NimbusConstants.LOCALIZATION_SUPPORTED_VERSION[application]
        )
        if min_version == "" or (
            NimbusExperiment.Version.parse(min_version) < supported_version
        ):
            raise serializers.ValidationError(
                {
                    "firefox_min_version": [
                        NimbusConstants.ERROR_DESKTOP_LOCALIZATION_VERSION,
                    ],
                }
            )

        experiment_locales = data.get("locales")
        if not experiment_locales:
            raise serializers.ValidationError(
                {"locales": ["Locales must not be empty for a localized experiment."]}
            )

        localizations_json = data.get("localizations")
        try:
            localizations = json.loads(localizations_json)
        except json.decoder.JSONDecodeError as e:
            raise serializers.ValidationError(
                {"localizations": [f"Invalid JSON: {e}"]}
            ) from e

        try:
            ExperimentLocalizations.model_validate(localizations)
        except Exception as e:
            raise serializers.ValidationError(
                {"localizations": [f"Localization schema validation error: {e}"]}
            ) from e

        experiment_locale_codes = [locale.code for locale in experiment_locales]
        for locale_code in experiment_locale_codes:
            if locale_code not in localizations:
                raise serializers.ValidationError(
                    {
                        "localizations": [
                            f"Experiment locale {locale_code} not present in "
                            f"localizations."
                        ]
                    }
                )

        for localization in localizations:
            if localization not in experiment_locale_codes:
                raise serializers.ValidationError(
                    {
                        "localizations": [
                            f"Localization locale {localization} does not exist in "
                            f"experiment locales."
                        ]
                    }
                )

        return data