@studyportals/fawkes 8.0.1-0 → 8.0.1-2

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

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+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)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,38 @@
+import { FilterKey } from '@studyportals/search-filters';
+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 {
+    name = 'Special Programmes Policy';
+    description = 'Controls indexing of pages filtered by special programmes like Erasmus Mundus or Joint Programmes.';
+    filterKeys = [FilterKey.SPECIAL_PROGRAMMES];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.SPECIAL_PROGRAMMES),
+        new OnlyFiltersSelectedRule([FilterKey.SPECIAL_PROGRAMMES]),
+        new ErasmusOrJointSpecialProgrammesRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const specialProgrammeFragments = SpecialProgrammesPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const specialProgramme of specialProgrammeFragments) {
+                const filterKeyValues = new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(specialProgramme.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.SPECIAL_PROGRAMMES;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+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 TuitionFee 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/TuitionFee.js

@@ -0,0 +1,32 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
+export class TuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Tuition Fee Policy';
+    description = 'Controls indexing of pages filtered by tuition fee.';
+    filterKeys = [FilterKey.TUITION_FEE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
+        new OnlyFiltersSelectedRule([FilterKey.TUITION_FEE])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const tuitionFee of tuitionFeeFragments) {
+                paths.push(this.getPathWithPageNumber(tuitionFee.path, pageNumber));
+            }
+        }
+        return Promise.resolve(paths);
+    }
+    get filterCombination() {
+        return FilterCombinations.TUITION_FEE;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { NoFiltersSelectedRule } from '../../common/rules/NoFiltersSelectedRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class Unfiltered extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: never[];
+    protected readonly rules: NoFiltersSelectedRule[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,19 @@
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { NoFiltersSelectedRule } from '../../common/rules/NoFiltersSelectedRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+export class Unfiltered extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Unfiltered Policy';
+    description = 'Defines indexability rules for unfiltered pages, managing crawl budget by ensuring only high-value aggregate pages are included in the sitemap.';
+    filterKeys = [];
+    rules = [new NoFiltersSelectedRule()];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        return Promise.resolve(['']);
+    }
+    get filterCombination() {
+        return FilterCombinations.UNFILTERED;
+    }
+}

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

@@ -0,0 +1,34 @@
+export * from './Area';
+export * from './Attendance';
+export * from './AttendanceDegree';
+export * from './Continent';
+export * from './ContinentTuitionFee';
+export * from './Country';
+export * from './CountryAttendance';
+export * from './CountryAttendanceDegree';
+export * from './CountryDegree';
+export * from './CountryDuration';
+export * from './CountryDurationDegree';
+export * from './CountryEducationalForm';
+export * from './CountryFormat';
+export * from './CountryTuitionFee';
+export * from './DegreeAttendanceDiscipline';
+export * from './DegreeCountryAttendance';
+export * from './DegreeCountryDiscipline';
+export * from './DegreeCountryTuitionFee';
+export * from './DisciplineDegree';
+export * from './Discipline';
+export * from './DisciplineArea';
+export * from './DisciplineAttendance';
+export * from './DisciplineContinent';
+export * from './DisciplineCountry';
+export * from './DisciplineCountryEducationalForm';
+export * from './DisciplineDegree';
+export * from './DisciplineDuration';
+export * from './DisciplineEducationalForm';
+export * from './DisciplineFormat';
+export * from './DisciplineTuitionFee';
+export * from './DisciplineTuitionFeeAttendance';
+export * from './SpecialProgrammes';
+export * from './TuitionFee';
+export * from './Unfiltered';

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

@@ -0,0 +1,34 @@
+export * from './Area';
+export * from './Attendance';
+export * from './AttendanceDegree';
+export * from './Continent';
+export * from './ContinentTuitionFee';
+export * from './Country';
+export * from './CountryAttendance';
+export * from './CountryAttendanceDegree';
+export * from './CountryDegree';
+export * from './CountryDuration';
+export * from './CountryDurationDegree';
+export * from './CountryEducationalForm';
+export * from './CountryFormat';
+export * from './CountryTuitionFee';
+export * from './DegreeAttendanceDiscipline';
+export * from './DegreeCountryAttendance';
+export * from './DegreeCountryDiscipline';
+export * from './DegreeCountryTuitionFee';
+export * from './DisciplineDegree';
+export * from './Discipline';
+export * from './DisciplineArea';
+export * from './DisciplineAttendance';
+export * from './DisciplineContinent';
+export * from './DisciplineCountry';
+export * from './DisciplineCountryEducationalForm';
+export * from './DisciplineDegree';
+export * from './DisciplineDuration';
+export * from './DisciplineEducationalForm';
+export * from './DisciplineFormat';
+export * from './DisciplineTuitionFee';
+export * from './DisciplineTuitionFeeAttendance';
+export * from './SpecialProgrammes';
+export * from './TuitionFee';
+export * from './Unfiltered';

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

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

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

@@ -0,0 +1,17 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class AffordableTuitionFeeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([
+            [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'AffordableTuitionFeeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected tuition fee is affordable (between 0 and 2500).';
+    }
+}

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.getCount(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/DegreeAttendanceDisciplineRule.d.ts

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

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

@@ -0,0 +1,44 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceDisciplineRule extends BaseProgrammeRule {
+    allowedDegrees = [
+        DegreeTypeFilterOptionValue.MA,
+        DegreeTypeFilterOptionValue.MSC,
+        DegreeTypeFilterOptionValue.MBA
+    ].map(id => id.valueOf());
+    attendanceValue = 'online';
+    getName() {
+        return 'DegreeAttendanceDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-arts (online) + all disciplines; master-of-science (online) + all disciplines; master-of-business-administration (online) + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (!degreeTypeValue || !attendanceValue || !this.allowedDegrees.includes(degreeTypeValue) || attendanceValue !== this.attendanceValue) {
+            return Promise.resolve(true);
+        }
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !attendanceValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (!degreeTypeValue || !attendanceValue || !this.allowedDegrees.includes(degreeTypeValue) || attendanceValue !== this.attendanceValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(true);
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceDisciplineSpecificRule extends BaseProgrammeRule {
+    allowedDegrees = [
+        DegreeTypeFilterOptionValue.MSC,
+        DegreeTypeFilterOptionValue.MA,
+        DegreeTypeFilterOptionValue.MBA
+    ];
+    allowedAttendance = 'online';
+    getName() {
+        return 'DegreeAttendanceDisciplineSpecificRule';
+    }
+    getDescription() {
+        return 'Only allows MSc, MA, and MBA degrees with online attendance for attendance+discipline combinations';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (!degreeTypeValue || !attendanceValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue) &&
+            attendanceValue === this.allowedAttendance);
+    }
+    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];
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue) &&
+            attendanceValue === this.allowedAttendance);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class DegreeCountryAttendanceSpecificRule extends BaseProgrammeRule {
+    private mba;
+    private readonly countryIdsByDegree;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    private isValidForMbaDegree;
+    private isValidForMphilDegree;
+    private isValidForLlmDegree;
+}

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

@@ -0,0 +1,76 @@
+import { AttendanceFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountryAttendanceSpecificRule extends BaseProgrammeRule {
+    mba = DegreeTypeFilterOptionValue.MBA.valueOf();
+    countryIdsByDegree = {
+        [DegreeTypeFilterOptionValue.LLM.valueOf()]: ['82', '30', '56', '108'],
+        [DegreeTypeFilterOptionValue.MPHIL.valueOf()]: ['82', '30', '108'],
+    };
+    getName() {
+        return 'DegreeCountryAttendanceSpecificRule';
+    }
+    getDescription() {
+        return 'Only allows MBA, LLM, and MPhil degrees for country+attendance combinations';
+    }
+    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 || !countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        if (attendanceValue !== AttendanceFilterOptionValue.ONLINE) {
+            return Promise.resolve(false);
+        }
+        if (this.isValidForMbaDegree(degreeTypeValue)) {
+            return Promise.resolve(true);
+        }
+        if (this.isValidForMphilDegree(degreeTypeValue, countryValue)) {
+            return Promise.resolve(true);
+        }
+        if (this.isValidForLlmDegree(degreeTypeValue, countryValue)) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    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 countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (!degreeTypeValue || !countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        if (attendanceValue !== AttendanceFilterOptionValue.ONLINE) {
+            return Promise.resolve(false);
+        }
+        if (this.isValidForMbaDegree(degreeTypeValue)) {
+            return Promise.resolve(true);
+        }
+        if (this.isValidForMphilDegree(degreeTypeValue, countryValue)) {
+            return Promise.resolve(true);
+        }
+        if (this.isValidForLlmDegree(degreeTypeValue, countryValue)) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    isValidForMbaDegree(degreeTypeValue) {
+        return degreeTypeValue === this.mba;
+    }
+    isValidForMphilDegree(degreeTypeValue, countryValue) {
+        return degreeTypeValue === DegreeTypeFilterOptionValue.MPHIL.valueOf() &&
+            this.countryIdsByDegree[DegreeTypeFilterOptionValue.MPHIL.valueOf()].includes(countryValue);
+    }
+    isValidForLlmDegree(degreeTypeValue, countryValue) {
+        return degreeTypeValue === DegreeTypeFilterOptionValue.LLM.valueOf() &&
+            this.countryIdsByDegree[DegreeTypeFilterOptionValue.LLM.valueOf()].includes(countryValue);
+    }
+}

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

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

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

@@ -0,0 +1,76 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountryDisciplineSpecificRule extends BaseProgrammeRule {
+    educationDisciplineIds = [
+        '289', // Education & Training (main discipline)
+        '290', // Adult Education
+        '360', // Art Education
+        '291', // Coaching
+        '292', // School Counselling
+        '333', // Early Childhood Education
+        '8', // Education
+        '349', // Educational Leadership
+        '293', // Educational Psychology
+        '98', // Educational Research
+        '371', // Health Education
+        '363', // Higher Education
+        '355', // Instructional Design
+        '370', // Literacy Education
+        '348', // Primary Education
+        '97', // Special Education
+        '359', // Secondary Education
+        '345', // STEM Education
+        '295', // Teaching
+        '358' // Teaching English as a Foreign Language
+    ];
+    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);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (!degreeTypeValue || !countryValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(allowedCountries.includes(countryValue) &&
+                this.educationDisciplineIds.includes(disciplineValue));
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !countryValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const disciplineValue = disciplineValues[0];
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(allowedCountries.includes(countryValue) &&
+                this.educationDisciplineIds.includes(disciplineValue));
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+}

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

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