@studyportals/fawkes 8.7.2 → 9.0.1-0

package/dist/src/organisations/policies/ranked/RankedCountryAttendance.js

@@ -22,6 +22,7 @@ export class RankedCountryAttendance extends RankedOrganisationsSeoIndexabilityP
         const countryFragments = CountryPresenter.getInstance().getFragments();
         const attendanceFragments = AttendancePresenter.getInstance().getFragments();
         const paths = [];
+        // Process sequentially to respect API rate limits
         for (const country of countryFragments) {
             for (const attendance of attendanceFragments) {
                 const filterKeyValues = new Map([

package/dist/src/organisations/policies/ranked/RankedCountryDiscipline.js

@@ -5,6 +5,7 @@ import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelect
 import { CountryPresenter } from '../../../presenters/CountryPresenter';
 import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
 import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+const DEFAULT_CONCURRENT_REQUESTS = 20; // Maximum number of concurrent requests to avoid rate limiting
 export class RankedCountryDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
     name = 'Ranked Country Discipline Policy';
     description = 'Determines which ranking-sorted pages at the intersection of country and discipline filters qualify for indexing based on search value.';
@@ -17,22 +18,37 @@ export class RankedCountryDiscipline extends RankedOrganisationsSeoIndexabilityP
         super(dependencies);
     }
     async generateUrls() {
-        const countryFragments = CountryPresenter.getInstance().getFragments();
-        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const country of countryFragments) {
-            for (const discipline of disciplineFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.COUNTRY, [country.id]],
-                    [FilterKey.DISCIPLINES, [discipline.id]]
-                ]);
-                const result = await this.checkRulesForSitemap(filterKeyValues);
-                if (result) {
-                    paths.push(this.getPathWithSortingOption(`${country.path}/${discipline.path}`));
-                }
+        try {
+            const countryFragments = CountryPresenter.getInstance().getFragments();
+            const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+            const paths = [];
+            const configuredConcurrency = Number.parseInt(process.env.SITEMAP_COMBINATION_CONCURRENCY
+                || DEFAULT_CONCURRENT_REQUESTS.toString(), 10);
+            const concurrencyLimit = Math.max(1, configuredConcurrency); // Ensure at least 1
+            // Create all combinations
+            const combinations = countryFragments.flatMap(country => disciplineFragments.map(discipline => ({ country, discipline })));
+            // Process in batches to respect API rate limits
+            for (let i = 0; i < combinations.length; i += concurrencyLimit) {
+                const batch = combinations.slice(i, i + concurrencyLimit);
+                const results = await Promise.all(batch.map(async ({ country, discipline }) => {
+                    const filterKeyValues = new Map([
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DISCIPLINES, [discipline.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemap(filterKeyValues);
+                    if (result) {
+                        return this.getPathWithSortingOption(`${country.path}/${discipline.path}`);
+                    }
+                    return null;
+                }));
+                paths.push(...results.filter((path) => path !== null));
             }
+            return paths;
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedCountryDiscipline:', error);
+            return [];
         }
-        return paths;
     }
     get filterCombination() {
         return FilterCombinations.RANKED_DISCIPLINE_COUNTRY;

package/dist/src/organisations/policies/ranked/RankedDiscipline.js

@@ -15,16 +15,22 @@ export class RankedDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
         super(dependencies);
     }
     async generateUrls() {
-        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
-        const paths = [];
-        for (const discipline of disciplineFragments) {
-            const filterKeyValues = new Map([[FilterKey.DISCIPLINES, [discipline.id]]]);
-            const result = await this.checkRulesForSitemap(filterKeyValues);
-            if (result) {
-                paths.push(this.getPathWithSortingOption(discipline.path));
+        try {
+            const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+            const paths = [];
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([[FilterKey.DISCIPLINES, [discipline.id]]]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(discipline.path));
+                }
             }
+            return paths;
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedDiscipline:', error);
+            return [];
         }
-        return paths;
     }
     get filterCombination() {
         return FilterCombinations.RANKED_DISCIPLINE;

package/dist/src/organisations/policies/ranked/RankedUnfiltered.js

@@ -9,11 +9,17 @@ export class RankedUnfiltered extends RankedOrganisationsSeoIndexabilityPolicy {
         super(dependencies);
     }
     async generateUrls() {
-        const filterKeyValues = new Map([]);
-        if (await this.checkRulesForSitemap(filterKeyValues)) {
-            return [this.getPathWithSortingOption('')];
+        try {
+            const filterKeyValues = new Map([]);
+            if (await this.checkRulesForSitemap(filterKeyValues)) {
+                return [this.getPathWithSortingOption('')];
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('Error generating URLs for RankedUnfiltered:', error);
+            return [];
         }
-        return [];
     }
     get filterCombination() {
         return FilterCombinations.RANKED_UNFILTERED;

package/dist/src/organisations/rules/MinimumAmountOfRankedResultsRule.d.ts

@@ -1,11 +1,10 @@
 import { IRule } from '../../common/IRule';
 import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
-import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
-import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+import { FilterKeyValuesMap, ISearchApiClient } from '../../../sitemap-generator-seo';
 export declare class MinimumAmountOfRankedResultsRule implements IRule {
     private readonly minimumRankedResultsCount;
-    private readonly rankingApiClient?;
-    constructor(rankingApiClient?: IRankingApiClient);
+    private readonly searchApiClient?;
+    constructor(searchApiClient?: ISearchApiClient);
     forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
     forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
     getName(): string;

package/dist/src/organisations/rules/MinimumAmountOfRankedResultsRule.js

@@ -1,9 +1,9 @@
 import { DependencyMissingError } from '../../errors/DependencyMissingError';
 export class MinimumAmountOfRankedResultsRule {
-    minimumRankedResultsCount = 7;
-    rankingApiClient;
-    constructor(rankingApiClient) {
-        this.rankingApiClient = rankingApiClient;
+    minimumRankedResultsCount = 4;
+    searchApiClient;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
     }
     forSearch(dependencies) {
         const { applicationState } = dependencies;
@@ -11,14 +11,18 @@ export class MinimumAmountOfRankedResultsRule {
         return Promise.resolve(rankedResultsCount >= this.minimumRankedResultsCount);
     }
     async forSitemapGenerator(filterKeyValues) {
-        if (!this.rankingApiClient) {
-            throw new DependencyMissingError('RankingApiClient');
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
         }
-        const rankedResultsCount = await this.rankingApiClient.getRankedOrganisationCount(filterKeyValues);
+        if (!this.searchApiClient.getCountWithRankings) {
+            const filterKeys = [...filterKeyValues.keys()];
+            throw new DependencyMissingError(`CountwithRankings ${filterKeys.join(',')}`);
+        }
+        const rankedResultsCount = await this.searchApiClient.getCountWithRankings(filterKeyValues);
         return rankedResultsCount >= this.minimumRankedResultsCount;
     }
     getName() {
-        return 'AtLeastTwoRankedResultsRule';
+        return 'AtLeastFourRankedResultsRule';
     }
     getDescription() {
         return `At least ${this.minimumRankedResultsCount} ranked results are available`;

package/dist/src/organisations/types/IOrganisationsSitemapDependencies.d.ts

@@ -1,9 +1,7 @@
 import { ISitemapDependencies } from '../../common/ISitemapDependencies';
-import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
 import { PortalType } from '@studyportals/domain-client';
 import { IOrganisationsClient } from '../../sitemap-generator/IOrganisationsClient';
 export interface IOrganisationsSitemapDependencies extends ISitemapDependencies {
     organisationsClient: IOrganisationsClient;
     portalType: PortalType;
-    rankingApiClient: IRankingApiClient;
 }

package/dist/src/programmes/policies/CountryAttendanceDegree.js

@@ -10,7 +10,7 @@ import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 import { DegreePresenter } from '../../presenters/DegreePresenter';
 export class CountryAttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Attendance Degree Policy';
-    description = `Determines indexing rules for pages filtered by country,
+    description = `Determines indexing rules for pages filtered by country,
 		study format (online, on-campus, etc.), and degree type.`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
     rules = [

package/dist/src/programmes/policies/CountryDurationDegree.js

@@ -10,7 +10,7 @@ import { DegreePresenter } from '../../presenters/DegreePresenter';
 import { DurationPresenter } from '../../presenters/DurationPresenter';
 export class CountryDurationDegree extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Duration Degree Policy';
-    description = `Determines indexing rules for pages filtered by country,
+    description = `Determines indexing rules for pages filtered by country,
 		duration (1 year, 2 years, etc.), and degree type.`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.DURATION, FilterKey.DEGREE_TYPE];
     rules = [

package/dist/src/programmes/policies/CountryEducationalForm.js

@@ -8,7 +8,7 @@ import { CountryPresenter } from '../../presenters/CountryPresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class CountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by both country,
+    description = `Determines indexing rules for pages filtered by both country,
 		and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM];
     rules;

package/dist/src/programmes/policies/DegreeAttendanceTuitionFee.d.ts

@@ -3,7 +3,7 @@ import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
 import { IRule } from '../../common/IRule';
-export declare class DegreeAttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+export declare class DegreeTuitionFeeAttendance extends ProgrammesBaseIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     readonly filterKeys: FilterKey[];

package/dist/src/programmes/policies/DegreeAttendanceTuitionFee.js

@@ -10,19 +10,19 @@ import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
 import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
 import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
-export class DegreeAttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+export class DegreeTuitionFeeAttendance extends ProgrammesBaseIndexabilityPolicy {
     name = 'Tuition Fee Attendance Degree Policy';
     description = 'Determines indexing rules for pages filtered by tuition fee, attendance, and degree type.';
-    filterKeys = [FilterKey.TUITION_FEE, FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.DELIVERY_METHOD];
     rules;
     constructor(dependencies) {
         super(dependencies);
         const portalType = dependencies.portalType;
         this.rules = [
             new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
-            new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
             new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
-            new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.TUITION_FEE]),
+            new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+            new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.DELIVERY_METHOD]),
             new IndexableDegreeRule(portalType),
             new OnlineAttendanceRule(),
             new AffordableTuitionFeeRule()
@@ -42,9 +42,9 @@ export class DegreeAttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy
             for (const degree of degreeFragments) {
                 for (const attendance of attendanceFragments) {
                     const filterKeyValues = new Map([
-                        [FilterKey.DELIVERY_METHOD, [attendance.id]],
                         [FilterKey.DEGREE_TYPE, [degree.id]],
-                        [FilterKey.TUITION_FEE, [affordableTuition.id]]
+                        [FilterKey.TUITION_FEE, [affordableTuition.id]],
+                        [FilterKey.DELIVERY_METHOD, [attendance.id]]
                     ]);
                     const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
                     if (result) {

package/dist/src/programmes/policies/DegreeContinentTuitionFee.d.ts

@@ -3,7 +3,7 @@ import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
 import { IRule } from '../../common/IRule';
-export declare class DegreeContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+export declare class DegreeTuitionFeeContinent extends ProgrammesBaseIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     readonly filterKeys: FilterKey[];

package/dist/src/programmes/policies/DegreeContinentTuitionFee.js

@@ -7,10 +7,10 @@ import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityP
 import { DegreePresenter } from '../../presenters/DegreePresenter';
 import { ContinentPresenter } from '../../presenters/ContinentPresenter';
 import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
-export class DegreeContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy {
-    name = 'Degree Continent Tuition Fee Policy';
-    description = 'Determines indexing rules for pages filtered by degree type, continent, and tuition fee.';
-    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.CONTINENT, FilterKey.TUITION_FEE];
+export class DegreeTuitionFeeContinent extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Tuition Fee Continent Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, tuition fee, and continent.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.CONTINENT];
     rules;
     constructor(dependencies) {
         super(dependencies);
@@ -19,7 +19,7 @@ export class DegreeContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy
             new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
             new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
             new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
-            new OnlyFiltersSelectedRule([FilterKey.CONTINENT, FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE]),
+            new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.CONTINENT]),
             new IndexableDegreeRule(portalType)
         ];
         this.initateBaseRules();
@@ -34,9 +34,9 @@ export class DegreeContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy
                 for (const degree of degreeFragments) {
                     for (const tuitionFee of tuitionFeeFragments) {
                         const filterKeyValues = new Map([
-                            [FilterKey.CONTINENT, [continent.id]],
                             [FilterKey.DEGREE_TYPE, [degree.id]],
                             [FilterKey.TUITION_FEE, [tuitionFee.id]],
+                            [FilterKey.CONTINENT, [continent.id]],
                         ]);
                         const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
                         if (result) {

package/dist/src/programmes/policies/DegreeFormatTuitionFee.js

@@ -12,16 +12,16 @@ import { PartTimeFormatRule } from '../rules/PartTimeFormatRule';
 export class DegreeFormatTuitionFee extends ProgrammesBaseIndexabilityPolicy {
     name = 'Degree Format Tuition Fee Policy';
     description = 'Determines indexing rules for pages filtered by degree type, format and tuition fee.';
-    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.ATTENDANCE, FilterKey.TUITION_FEE];
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.ATTENDANCE];
     rules;
     constructor(dependencies) {
         super(dependencies);
         const portalType = dependencies.portalType;
         this.rules = [
-            new SingleValueSelectedForFilterRule(FilterKey.ATTENDANCE),
             new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
             new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
-            new OnlyFiltersSelectedRule([FilterKey.ATTENDANCE, FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE]),
+            new SingleValueSelectedForFilterRule(FilterKey.ATTENDANCE),
+            new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE, FilterKey.ATTENDANCE]),
             new IndexableDegreeRule(portalType),
             new AffordableTuitionFeeRule(),
             new PartTimeFormatRule()
@@ -38,9 +38,9 @@ export class DegreeFormatTuitionFee extends ProgrammesBaseIndexabilityPolicy {
                 for (const degree of degreeFragments) {
                     for (const tuitionFee of tuitionFeeFragments) {
                         const filterKeyValues = new Map([
-                            [FilterKey.ATTENDANCE, [format.id]],
                             [FilterKey.DEGREE_TYPE, [degree.id]],
-                            [FilterKey.TUITION_FEE, [tuitionFee.id]]
+                            [FilterKey.TUITION_FEE, [tuitionFee.id]],
+                            [FilterKey.ATTENDANCE, [format.id]],
                         ]);
                         const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
                         if (result) {

package/dist/src/programmes/policies/DisciplineCountryEducationalForm.js

@@ -9,7 +9,7 @@ import { CountryPresenter } from '../../presenters/CountryPresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class DisciplineCountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Discipline Country Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by discipline,
+    description = `Determines indexing rules for pages filtered by discipline,
 		country, and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.DISCIPLINES, FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM];
     rules;

package/dist/src/programmes/policies/DisciplineEducationalForm.js

@@ -8,7 +8,7 @@ import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class DisciplineEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Discipline Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by both discipline,
+    description = `Determines indexing rules for pages filtered by both discipline,
 		and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.DISCIPLINES, FilterKey.EDUCATIONAL_FORM];
     rules;

package/dist/src/scholarships/SearchIndexabilityManager.d.ts

@@ -3,9 +3,10 @@ import { ISeoInfoBase } from '../common/ISeoInfoBase';
 import { ISeoFilterState } from '../common/ISeoFilterState';
 import { ISearchApplicationState } from '../common/ISearchApplicationState';
 import { ISearchIndexabilityManager } from '../common/ISearchIndexabilityManager';
+import { PortalType } from '@studyportals/domain-client';
 export declare class SearchIndexabilityManager implements ISearchIndexabilityManager {
     private policies;
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: ISearchApplicationState);
+    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: ISearchApplicationState, portalType?: PortalType);
     shouldIndex(): Promise<boolean>;
     getPolicies(): ISeoIndexabilityPolicy[];
 }

package/dist/src/scholarships/SearchIndexabilityManager.js

@@ -7,12 +7,13 @@ import { Unfiltered } from './policies/Unfiltered';
 import { DependencyTypes } from '../enums/DependencyTypes';
 export class SearchIndexabilityManager {
     policies;
-    constructor(seoInfoBase, filterState, applicationState) {
+    constructor(seoInfoBase, filterState, applicationState, portalType) {
         const dependencies = {
             dependencyType: DependencyTypes.SEARCH,
             seoInfoBase,
             filterState,
-            applicationState
+            applicationState,
+            portalType
         };
         this.policies = [
             new Area(dependencies),

package/dist/src/scholarships/policies/Area.d.ts

@@ -1,13 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ExceptAustraliaAreasRule } from '../rules/ExceptAustaliaAreasRule';
-import { SearchVolumeAreasRule } from '../rules/SearchVolumeAreasRule';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class Area extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (ExceptAustraliaAreasRule | SearchVolumeAreasRule | SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: IRule[];
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/Area.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ExceptAustraliaAreasRule } from '../rules/ExceptAustaliaAreasRule';
@@ -9,13 +11,18 @@ import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedR
 export class Area extends ScholarshipSeoIndexabilityPolicy {
     name = 'Area Policy';
     description = 'Controls indexing of pages filtered by geographic areas, ensuring only SEO-valuable regional content with sufficient search volume is indexed while respecting country associations.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.AREA),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
-        new ExceptAustraliaAreasRule(),
-        new SearchVolumeAreasRule()
-    ];
+    baseRules;
+    constructor(dependencies) {
+        super(dependencies);
+        this.baseRules = [
+            new NotOnPortalsRule([PortalType.BACHELOR, PortalType.PHD], this.portalType),
+            new SingleValueSelectedForFilterRule(FilterKey.AREA),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
+            new ExceptAustraliaAreasRule(),
+            new SearchVolumeAreasRule()
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.AREA;
     }

package/dist/src/scholarships/policies/DisciplineCountry.d.ts

@@ -1,12 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { SearchVolumeCountriesDisciplinesRule } from '../rules/SearchVolumeCountriesDisciplinesRule';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class DisciplineCountry extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeCountriesDisciplinesRule)[];
+    protected readonly baseRules: IRule[];
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/DisciplineCountry.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { SearchVolumeCountriesDisciplinesRule } from '../rules/SearchVolumeCountriesDisciplinesRule';
@@ -6,15 +8,22 @@ import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { OnlyCountriesDisciplineCountryRule } from '../rules/OnlyCountriesDisciplineCountryRule';
 export class DisciplineCountry extends ScholarshipSeoIndexabilityPolicy {
     name = 'Discipline Policy';
     description = 'Determines which discipline-filtered pages qualify for indexing based on search volume thresholds and content availability within specific academic fields.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.DISCIPLINES, FilterKey.COUNTRY]),
-        new SearchVolumeCountriesDisciplinesRule()
-    ];
+    baseRules;
+    constructor(dependencies) {
+        super(dependencies);
+        this.baseRules = [
+            new NotOnPortalsRule([PortalType.BACHELOR, PortalType.PHD], this.portalType),
+            new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.DISCIPLINES, FilterKey.COUNTRY]),
+            new SearchVolumeCountriesDisciplinesRule(),
+            new OnlyCountriesDisciplineCountryRule()
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.DISCIPLINE_COUNTRY;
     }

package/dist/src/scholarships/policies/ScholarshipSeoIndexabilityPolicy.d.ts

@@ -1,7 +1,9 @@
 import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
 import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { IRule } from '../../common/IRule';
+import { PortalType } from '@studyportals/domain-client';
 export declare abstract class ScholarshipSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IScholarshipSeoDependencies> {
     protected abstract readonly baseRules: IRule[];
+    protected get portalType(): PortalType;
     protected get rules(): IRule[];
 }

package/dist/src/scholarships/policies/ScholarshipSeoIndexabilityPolicy.js

@@ -1,6 +1,10 @@
 import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
 import { IndexablePageNumberRule } from '../../common/rules/IndexablePageNumberRule';
+import { PortalType } from '@studyportals/domain-client';
 export class ScholarshipSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    get portalType() {
+        return this.dependencies.portalType ?? PortalType.MASTER;
+    }
     get rules() {
         return [...this.baseRules, new IndexablePageNumberRule()];
     }

package/dist/src/scholarships/policies/UniversityCountry.d.ts

@@ -1,11 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IScholarshipSeoDependencies } from '../types/IScholarshipSeoDependencies';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ScholarshipSeoIndexabilityPolicy } from './ScholarshipSeoIndexabilityPolicy';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 export declare class UniversityCountry extends ScholarshipSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: IRule[];
+    private readonly portalRule;
+    constructor(dependencies: IScholarshipSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/scholarships/policies/UniversityCountry.js

@@ -1,3 +1,5 @@
+import { NotOnPortalsRule } from '../rules/NotOnPortalsRule';
+import { PortalType } from '@studyportals/domain-client';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { CountryPresenter } from '../../presenters/CountryPresenter';
@@ -7,15 +9,25 @@ import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedR
 export class UniversityCountry extends ScholarshipSeoIndexabilityPolicy {
     name = 'University Country Policy';
     description = 'Regulates indexing for pages filtered by both university and country, prioritizing institution-specific content within national boundaries that meets SEO criteria.';
-    baseRules = [
-        new SingleValueSelectedForFilterRule(FilterKey.ORGANISATIONS),
-        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.ORGANISATIONS, FilterKey.COUNTRY])
-    ];
+    baseRules;
+    portalRule;
+    constructor(dependencies) {
+        super(dependencies);
+        this.portalRule = new NotOnPortalsRule([PortalType.BACHELOR], this.portalType);
+        this.baseRules = [
+            this.portalRule,
+            new SingleValueSelectedForFilterRule(FilterKey.ORGANISATIONS),
+            new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+            new OnlyFiltersSelectedRule([FilterKey.ORGANISATIONS, FilterKey.COUNTRY])
+        ];
+    }
     get filterCombination() {
         return FilterCombinations.UNIVERSITY_COUNTRY;
     }
     async generateUrls() {
+        if (!(await this.portalRule.forSitemapGenerator())) {
+            return [];
+        }
         const { searchApiClient, organisationsClient } = this.dependencies;
         try {
             const organisationIds = await searchApiClient.getOrganisationIds();

package/dist/src/scholarships/rules/NotOnPortalsRule.d.ts

@@ -0,0 +1,12 @@
+import { IRule } from '../../common/IRule';
+import { PortalType } from '@studyportals/domain-client';
+export declare class NotOnPortalsRule implements IRule {
+    private readonly blockedPortals;
+    private readonly portalType;
+    constructor(blockedPortals: PortalType[], portalType?: PortalType);
+    getName(): string;
+    forSearch(): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    private isAllowedOnPortal;
+    getDescription(): string;
+}

package/dist/src/scholarships/rules/NotOnPortalsRule.js

@@ -0,0 +1,24 @@
+import { PortalType } from '@studyportals/domain-client';
+export class NotOnPortalsRule {
+    blockedPortals;
+    portalType;
+    constructor(blockedPortals, portalType = PortalType.MASTER) {
+        this.blockedPortals = blockedPortals;
+        this.portalType = portalType;
+    }
+    getName() {
+        return 'NotOnPortalsRule';
+    }
+    forSearch() {
+        return Promise.resolve(this.isAllowedOnPortal());
+    }
+    forSitemapGenerator() {
+        return Promise.resolve(this.isAllowedOnPortal());
+    }
+    isAllowedOnPortal() {
+        return !this.blockedPortals.includes(this.portalType);
+    }
+    getDescription() {
+        return `Is indexable if the portal type is not one of: ${this.blockedPortals.join(', ')}.`;
+    }
+}