@studyportals/fawkes 8.1.2-2 → 8.1.2-3

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

@@ -0,0 +1,40 @@
+import { DurationFilterOptionValue, FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DurationPresenter } from '../../presenters/DurationPresenter';
+import { OneOrTwoYearDurationRule } from '../rules/OneOrTwoYearDurationRule';
+export class Duration extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Duration Policy';
+    description = 'Governs indexing of duration-level filtered pages. (1 year - 2 year)';
+    filterKeys = [FilterKey.DURATION];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DURATION),
+        new OnlyFiltersSelectedRule([FilterKey.DURATION]),
+        new OneOrTwoYearDurationRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const durationFragments = DurationPresenter.getInstance().getFragments();
+        const allowedDurationIds = [DurationFilterOptionValue.ONE_YEAR, DurationFilterOptionValue.TWO_YEARS];
+        const allowedDurations = durationFragments.filter(duration => allowedDurationIds.includes(duration.id));
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const duration of allowedDurations) {
+                const filterKeyValues = new Map([[FilterKey.DURATION, [duration.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(duration.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DURATION;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class Format extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,38 @@
+import { FilterKey, FormatFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { FormatPresenter } from '../../presenters/FormatPresenter';
+export class Format extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Format Policy';
+    description = 'Governs indexing of format-level filtered pages.';
+    filterKeys = [FilterKey.ATTENDANCE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.ATTENDANCE),
+        new OnlyFiltersSelectedRule([FilterKey.ATTENDANCE])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const formatFragments = FormatPresenter.getInstance().getFragments();
+        const allowedFormatIds = [FormatFilterOptionValue.PART_TIME, FormatFilterOptionValue.FULL_TIME];
+        const allowedFormats = formatFragments.filter(format => allowedFormatIds.includes(format.id));
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const format of allowedFormats) {
+                const filterKeyValues = new Map([[FilterKey.ATTENDANCE, [format.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(format.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.FORMAT;
+    }
+}

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

@@ -2,14 +2,13 @@ import { FilterKey } from '@studyportals/search-filters/server-side';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ErasmusOrJointSpecialProgrammesRule } from '../rules/ErasmusOrJointSpecialProgrammesRule';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
 export declare class SpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     readonly filterKeys: FilterKey[];
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | ErasmusOrJointSpecialProgrammesRule)[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
     constructor(dependencies: IProgrammeSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;

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

@@ -2,7 +2,6 @@ import { FilterKey } from '@studyportals/search-filters/server-side';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ErasmusOrJointSpecialProgrammesRule } from '../rules/ErasmusOrJointSpecialProgrammesRule';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { SpecialProgrammesPresenter } from '../../presenters/SpecialProgrammesPresenter';
 export class SpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
@@ -12,7 +11,6 @@ export class SpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.SPECIAL_PROGRAMMES),
         new OnlyFiltersSelectedRule([FilterKey.SPECIAL_PROGRAMMES]),
-        new ErasmusOrJointSpecialProgrammesRule()
     ];
     constructor(dependencies) {
         super(dependencies);

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

@@ -18,7 +18,6 @@ export * from './DegreeCountryDiscipline';
 export * from './DegreeCountryTuitionFee';
 export * from './DisciplineDegree';
 export * from './Discipline';
-export * from './DisciplineArea';
 export * from './DisciplineAttendance';
 export * from './DisciplineContinent';
 export * from './DisciplineCountry';
@@ -32,3 +31,30 @@ export * from './DisciplineTuitionFeeAttendance';
 export * from './SpecialProgrammes';
 export * from './TuitionFee';
 export * from './Unfiltered';
+export * from './Format';
+export * from './DegreeFormat';
+export * from './DegreeAttendanceTuitionFee';
+export * from './DegreeArea';
+export * from './DegreeTuitionFee';
+export * from './DegreeAttendanceTuitionFee';
+export * from './DegreeContinent';
+export * from './AttendanceTuitionFee';
+export * from './Duration';
+export * from './AttendanceDuration';
+export * from './DegreeAreaTuitionFee';
+export * from './DisciplineContinentAttendance';
+export * from './DegreeContinentTuitionFee';
+export * from './AttendanceFormat';
+export * from './ContinentFormat';
+export * from './AttendanceContinent';
+export * from './DegreeDuration';
+export * from './ContinentSpecialProgrammes';
+export * from './CountrySpecialProgrammes';
+export * from './AttendanceArea';
+export * from './DegreeFormatTuitionFee';
+export * from './ContinentDuration';
+export * from './DegreeAttendanceFormat';
+export * from './DisciplineCountryAttendance';
+export * from './DisciplineCountryFormat';
+export * from './DegreeSpecialProgrammes';
+export * from './Degree';

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

@@ -18,7 +18,6 @@ export * from './DegreeCountryDiscipline';
 export * from './DegreeCountryTuitionFee';
 export * from './DisciplineDegree';
 export * from './Discipline';
-export * from './DisciplineArea';
 export * from './DisciplineAttendance';
 export * from './DisciplineContinent';
 export * from './DisciplineCountry';
@@ -32,3 +31,30 @@ export * from './DisciplineTuitionFeeAttendance';
 export * from './SpecialProgrammes';
 export * from './TuitionFee';
 export * from './Unfiltered';
+export * from './Format';
+export * from './DegreeFormat';
+export * from './DegreeAttendanceTuitionFee';
+export * from './DegreeArea';
+export * from './DegreeTuitionFee';
+export * from './DegreeAttendanceTuitionFee';
+export * from './DegreeContinent';
+export * from './AttendanceTuitionFee';
+export * from './Duration';
+export * from './AttendanceDuration';
+export * from './DegreeAreaTuitionFee';
+export * from './DisciplineContinentAttendance';
+export * from './DegreeContinentTuitionFee';
+export * from './AttendanceFormat';
+export * from './ContinentFormat';
+export * from './AttendanceContinent';
+export * from './DegreeDuration';
+export * from './ContinentSpecialProgrammes';
+export * from './CountrySpecialProgrammes';
+export * from './AttendanceArea';
+export * from './DegreeFormatTuitionFee';
+export * from './ContinentDuration';
+export * from './DegreeAttendanceFormat';
+export * from './DisciplineCountryAttendance';
+export * from './DisciplineCountryFormat';
+export * from './DegreeSpecialProgrammes';
+export * from './Degree';

package/dist/src/programmes/rules/AtLeastSevenResultsRule.d.ts

@@ -0,0 +1,15 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { ISearchApiClient } from '../../sitemap-generator/ISearchApiClient';
+import { IProgrammeRule } from '../IProgrammeRule';
+export declare class AtLeastSevenResultsRule implements IProgrammeRule {
+    private readonly minimumResultsCount;
+    private readonly maximumPageSize;
+    private readonly searchApiClient?;
+    constructor(searchApiClient?: ISearchApiClient);
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/AtLeastSevenResultsRule.js

@@ -0,0 +1,30 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class AtLeastSevenResultsRule {
+    minimumResultsCount = 7;
+    maximumPageSize = 20;
+    searchApiClient;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const resultCount = applicationState.getNumberOfResults();
+        return Promise.resolve(resultCount >= this.minimumResultsCount);
+    }
+    async forSitemapGeneratorWithPageNumber(filterKeyValues, pageNumber) {
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
+        }
+        const count = await this.searchApiClient.getProgrammeCount(filterKeyValues);
+        return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
+    }
+    forSitemapGenerator() {
+        throw new Error('Method not implemented.');
+    }
+    getName() {
+        return 'AtLeastSevenResultsRule';
+    }
+    getDescription() {
+        return 'Is indexable if there are at least 7 results.';
+    }
+}

package/dist/src/programmes/rules/BlendedOrOnlineAttendanceRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class BlendedOrOnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/BlendedOrOnlineAttendanceRule.js

@@ -0,0 +1,18 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { AttendanceFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class BlendedOrOnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DELIVERY_METHOD,
+                [AttendanceFilterOptionValue.BLENDED, AttendanceFilterOptionValue.ONLINE]
+            ]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'BlendedOrOnlineAttendanceRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected delivery method is blended or online.';
+    }
+}

package/dist/src/programmes/rules/DegreeAttendanceSpecificRule.d.ts

@@ -0,0 +1,10 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class DegreeAttendanceSpecificRule extends BaseProgrammeRule {
+    private readonly validCombinations;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/DegreeAttendanceSpecificRule.js

@@ -0,0 +1,42 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceSpecificRule extends BaseProgrammeRule {
+    validCombinations = {
+        'master-of-science': ['online'], // MSc with online attendance
+        'master-of-arts': ['online'], // MA with online attendance
+        'master-of-business-administration': ['online'] // MBA with online attendance
+    };
+    getName() {
+        return 'DegreeAttendanceSpecificRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science (online); master-of-arts (online); master-of-business-administration (online)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (!degreeTypeValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        const allowedAttendance = this.validCombinations[degreeTypeValue];
+        if (!allowedAttendance) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedAttendance.includes(attendanceValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        const allowedAttendance = this.validCombinations[degreeTypeValue];
+        if (!allowedAttendance) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedAttendance.includes(attendanceValue));
+    }
+}

package/dist/src/programmes/rules/DegreeCountrySpecificRule.d.ts

@@ -0,0 +1,10 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class DegreeCountrySpecificRule extends BaseProgrammeRule {
+    private readonly validCombinations;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/DegreeCountrySpecificRule.js

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountrySpecificRule extends BaseProgrammeRule {
+    validCombinations = {
+        [DegreeTypeFilterOptionValue.MSC]: ['82', '56', '11', '30'],
+        [DegreeTypeFilterOptionValue.MBA]: ['82', '30'],
+        [DegreeTypeFilterOptionValue.MED]: ['202', '56']
+    };
+    getName() {
+        return 'DegreeCountrySpecificRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science (USA, Canada, Germany, UK); master-of-business-administration (USA, UK); master-of-education (Australia, Canada)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        if (!degreeTypeValue || !countryValue) {
+            return Promise.resolve(false);
+        }
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        if (!degreeTypeValues?.length || !countryValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+}

package/dist/src/programmes/rules/DegreeCountryTuitionFeeRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class DegreeCountryTuitionFeeRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly tuitionFeeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/DegreeCountryTuitionFeeRule.js

@@ -0,0 +1,40 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountryTuitionFeeRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-business-administration';
+    tuitionFeeValue = TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED;
+    getName() {
+        return 'DegreeCountryTuitionFeeRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-business-administration + all countries + affordable tuition (0-2500)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const tuitionFeeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.TUITION_FEE, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !tuitionFeeValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(tuitionFeeValue === this.tuitionFeeValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const tuitionFeeValues = filterKeyValues.get(FilterKey.TUITION_FEE);
+        if (!degreeTypeValues?.length || !countryValues?.length || !tuitionFeeValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const tuitionFeeValue = tuitionFeeValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(tuitionFeeValue === this.tuitionFeeValue);
+    }
+}

package/dist/src/programmes/rules/ErasmusOrExecutiveSpecialProgrammeRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class ErasmusOrExecutiveSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/ErasmusOrExecutiveSpecialProgrammeRule.js

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class ErasmusOrExecutiveSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.SPECIAL_PROGRAMMES,
+                [SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS, SpecialProgrammesFilterOptionValue.EXECUTIVE_PROGRAMMES]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'ErasmusOrExecutiveSpecialProgrammeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected special programme is Erasmus Mundus or Executive Programmes.';
+    }
+}

package/dist/src/programmes/rules/ErasmusOrJointSpecialProgrammesRule.js

@@ -1,5 +1,5 @@
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { FilterKey } from '@studyportals/search-filters';
+import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters';
 import { BaseProgrammeRule } from '../BaseProgrammeRule';
 export class ErasmusOrJointSpecialProgrammesRule extends BaseProgrammeRule {
     forSearch(dependencies) {

package/dist/src/programmes/rules/ErasmusSpecialProgrammeRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class ErasmusSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/ErasmusSpecialProgrammeRule.js

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class ErasmusSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.SPECIAL_PROGRAMMES,
+                [SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'ErasmusSpecialProgrammeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected special programme is Erasmus Mundus.';
+    }
+}

package/dist/src/programmes/rules/ExecutiveSpecialProgrammeRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class ExecutiveSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/ExecutiveSpecialProgrammeRule.js

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class ExecutiveSpecialProgrammeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.SPECIAL_PROGRAMMES,
+                [SpecialProgrammesFilterOptionValue.EXECUTIVE_PROGRAMMES]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'ExecutiveSpecialProgrammeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected special programme is Executive.';
+    }
+}

package/dist/src/programmes/rules/MBACountryAttendanceRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MbaCountryAttendanceRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly attendanceValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MBACountryAttendanceRule.js

@@ -0,0 +1,40 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MbaCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = DegreeTypeFilterOptionValue.MBA;
+    attendanceValue = 'online';
+    getName() {
+        return 'MbaCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-business-administration + all countries + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(attendanceValue === this.attendanceValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfArtsDisciplineRule.d.ts

@@ -0,0 +1,10 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfArtsDisciplineRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}