@studyportals/fawkes 8.0.1-0 → 8.0.1-1

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

@@ -0,0 +1,62 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountryTuitionFeeSpecificRule extends BaseProgrammeRule {
+    validDegreeValues = [DegreeTypeFilterOptionValue.MBA, DegreeTypeFilterOptionValue.LLM];
+    tuitionFeeValue = TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED;
+    validCombinations = {
+        [DegreeTypeFilterOptionValue.LLM]: ['82', '30', '108', '56']
+    };
+    getName() {
+        return 'DegreeCountryTuitionFeeSpecificRule';
+    }
+    getDescription() {
+        return 'Indexes: mba & llm + 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 (!countryValue || !tuitionFeeValue || !degreeTypeValue) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MBA && tuitionFeeValue === this.tuitionFeeValue) {
+            return Promise.resolve(true);
+        }
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        if (allowedCountries.includes(countryValue) && this.validDegreeValues.includes(degreeTypeValue) && tuitionFeeValue === this.tuitionFeeValue) {
+            return Promise.resolve(tuitionFeeValue === this.tuitionFeeValue);
+        }
+        return Promise.resolve(false);
+    }
+    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];
+        const countryValue = countryValues[0];
+        if (!countryValue || !tuitionFeeValue || !degreeTypeValue) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MBA && tuitionFeeValue === this.tuitionFeeValue) {
+            return Promise.resolve(true);
+        }
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        if (allowedCountries.includes(countryValue) && this.validDegreeValues.includes(degreeTypeValue) && tuitionFeeValue === this.tuitionFeeValue) {
+            return Promise.resolve(tuitionFeeValue === this.tuitionFeeValue);
+        }
+        return Promise.resolve(false);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class DegreeDisciplineRule extends BaseProgrammeRule {
+    private readonly degreesAcceptingAllDisciplines;
+    private readonly allIndexableDegrees;
+    private readonly lawDisciplineIds;
+    private readonly masterOfPhilosophyDisciplineIds;
+    private readonly educationDisciplineIds;
+    private readonly engineeringDisciplineIds;
+    private readonly postgraduateDiplomaDisciplineIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,189 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeDisciplineRule extends BaseProgrammeRule {
+    degreesAcceptingAllDisciplines = [
+        DegreeTypeFilterOptionValue.MA,
+        DegreeTypeFilterOptionValue.MSC,
+        DegreeTypeFilterOptionValue.MBA
+    ];
+    allIndexableDegrees = [
+        DegreeTypeFilterOptionValue.MA,
+        DegreeTypeFilterOptionValue.MSC,
+        DegreeTypeFilterOptionValue.MBA,
+        DegreeTypeFilterOptionValue.LLM,
+        DegreeTypeFilterOptionValue.MPHIL,
+        DegreeTypeFilterOptionValue.MED,
+        DegreeTypeFilterOptionValue.MENG,
+        DegreeTypeFilterOptionValue.POSTGRADIP
+    ];
+    lawDisciplineIds = [
+        '6', // Law (main discipline)
+        '219', // Business Law
+        '114', // Civil & Private Law
+        '341', // Criminal Justice
+        '109', // Criminal Law
+        '48', // European Law
+        '85', // International Law
+        '220', // Legal Studies
+        '221', // Master of Laws (LLM)
+        '49', // Patent & Intellectual Property Law
+        '115', // Public Law
+        '247',
+        '278',
+        '87',
+        '323',
+        '108',
+        '362',
+        '241',
+        '127'
+    ];
+    masterOfPhilosophyDisciplineIds = [
+        '118',
+        '23',
+        '335',
+        '71',
+        '281',
+        '4',
+        '8',
+        '293',
+        '272',
+        '330',
+        '87',
+        '111',
+        '6',
+        '332',
+        '40',
+        '308',
+        '224',
+        '113',
+        '84',
+        '38',
+        '79',
+        '278',
+        '80'
+    ];
+    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
+    ];
+    engineeringDisciplineIds = [
+        '7', // Engineering & Technology (main discipline)
+        '24', // Computer Science & IT
+        '37', // Aerospace Engineering
+        '250', // Automotive Engineering
+        '30', // Bio & Biomedical Engineering
+        '32', // Chemical Engineering
+        '29', // Civil Engineering & Construction
+        '340', // Communications Engineering
+        '34', // Electrical Engineering
+        '83', // Electronics & Embedded Technology
+        '94', // Energy Engineering
+        '28', // Environmental Engineering
+        '251', // General Engineering & Technology
+        '26', // Industrial & Systems Engineering
+        '252', // Marine Engineering
+        '33', // Materials Science
+        '39', // Mechanical Engineering
+        '253', // Mechatronics
+        '254', // Mining, Oil & Gas
+        '367', // Nuclear Engineering
+        '255', // Robotics
+        '350', // Sound Engineering
+        '256', // Sustainable Energy
+        '257', // Transportation Engineering
+        '397', // Production and Manufacturing Engineering
+        '399' // Structural Engineering
+    ];
+    postgraduateDiplomaDisciplineIds = [
+        '362', '241', '108', '133', '373', '356', '282', '311', '113', '79'
+    ];
+    getName() {
+        return 'DegreeDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-arts, master-of-science, master-of-business-administration + all disciplines; master-of-laws + law disciplines only; master-of-philosophy + specific disciplines only; master-of-education + education & training disciplines only; master-of-engineering + engineering & technology disciplines only; postgraduate-diploma + specific disciplines only';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (!degreeTypeValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        if (!this.allIndexableDegrees.includes(degreeTypeValue)) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.LLM) {
+            return Promise.resolve(this.lawDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MPHIL) {
+            return Promise.resolve(this.masterOfPhilosophyDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MENG) {
+            return Promise.resolve(this.engineeringDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.POSTGRADIP) {
+            return Promise.resolve(this.postgraduateDiplomaDisciplineIds.includes(disciplineValue));
+        }
+        if (this.degreesAcceptingAllDisciplines.includes(degreeTypeValue)) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const disciplineValue = disciplineValues[0];
+        if (!degreeTypeValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        if (!this.allIndexableDegrees.includes(degreeTypeValue)) {
+            return Promise.resolve(false);
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.LLM) {
+            return Promise.resolve(this.lawDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MPHIL) {
+            return Promise.resolve(this.masterOfPhilosophyDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.MENG) {
+            return Promise.resolve(this.engineeringDisciplineIds.includes(disciplineValue));
+        }
+        if (degreeTypeValue === DegreeTypeFilterOptionValue.POSTGRADIP) {
+            return Promise.resolve(this.postgraduateDiplomaDisciplineIds.includes(disciplineValue));
+        }
+        if (this.degreesAcceptingAllDisciplines.includes(degreeTypeValue)) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(true);
+    }
+}

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

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

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

@@ -0,0 +1,28 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class ErasmusOrJointSpecialProgrammesRule extends BaseProgrammeRule {
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedSpecialProgramme = seoInfoBase.getFilterOptionValueBy(FilterKey.SPECIAL_PROGRAMMES, filterState);
+        if (!selectedSpecialProgramme) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(selectedSpecialProgramme === SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS ||
+            selectedSpecialProgramme === SpecialProgrammesFilterOptionValue.JOINT_PROGRAMMES);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedSpecialProgramme] = filterKeyValues.get(FilterKey.SPECIAL_PROGRAMMES);
+        if (!selectedSpecialProgramme) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(selectedSpecialProgramme === SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS ||
+            selectedSpecialProgramme === SpecialProgrammesFilterOptionValue.JOINT_PROGRAMMES);
+    }
+    getName() {
+        return 'ErasmusOrJointSpecialProgrammesRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected special programme is Erasmus Mundus or Joint Programmes.';
+    }
+}

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

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

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

@@ -0,0 +1,53 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class IndexableDegreeRule extends BaseProgrammeRule {
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDegree = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        if (!selectedDegree) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.indexableDegreeTypes.includes(selectedDegree);
+        return Promise.resolve(isIndexable);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDegree] = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        if (!selectedDegree) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.indexableDegreeTypes.includes(selectedDegree);
+        return Promise.resolve(isIndexable);
+    }
+    getName() {
+        return 'IndexableDegreeRule';
+    }
+    getDescription() {
+        return `Indexable if the selected degree type is one of the following: ${this.indexableDegreeTypes.join(', ')}`;
+    }
+    get indexableDegreeTypes() {
+        return [
+            DegreeTypeFilterOptionValue.DOCTORATE,
+            DegreeTypeFilterOptionValue.DBA,
+            DegreeTypeFilterOptionValue.PHD,
+            DegreeTypeFilterOptionValue.MSC,
+            DegreeTypeFilterOptionValue.MA,
+            DegreeTypeFilterOptionValue.MBA,
+            DegreeTypeFilterOptionValue.LLM,
+            DegreeTypeFilterOptionValue.MPHIL,
+            DegreeTypeFilterOptionValue.MED,
+            DegreeTypeFilterOptionValue.MENG,
+            DegreeTypeFilterOptionValue.POSTGRADIP,
+            DegreeTypeFilterOptionValue.POSTGRADCERT,
+            DegreeTypeFilterOptionValue.PREMASTER,
+            DegreeTypeFilterOptionValue.BSC,
+            DegreeTypeFilterOptionValue.BA,
+            DegreeTypeFilterOptionValue.BBA,
+            DegreeTypeFilterOptionValue.ASSOCIATE_DEGREE,
+            DegreeTypeFilterOptionValue.GRADUATE_CERTTIFICATE,
+            DegreeTypeFilterOptionValue.GRADUATE_DIPLOMA,
+            DegreeTypeFilterOptionValue.PREBACHELOR,
+            DegreeTypeFilterOptionValue.CERTIFICATE
+        ];
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+import { DurationPresenter } from '../../presenters/DurationPresenter';
+export class IndexableDurationRule extends BaseProgrammeRule {
+    durationPresenter;
+    constructor() {
+        super();
+        this.durationPresenter = DurationPresenter.getInstance();
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDuration = seoInfoBase.getFilterOptionValueBy(FilterKey.DURATION, filterState);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.isIndexable(selectedDuration);
+        return Promise.resolve(isIndexable);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDuration] = filterKeyValues.get(FilterKey.DURATION);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.isIndexable(selectedDuration);
+        return Promise.resolve(isIndexable);
+    }
+    getName() {
+        return 'IndexableDurationRule';
+    }
+    getDescription() {
+        return `Indexable if duration is 1 year, 2 years, 3 years, or 4 years.`;
+    }
+    isIndexable(value) {
+        return this.durationPresenter.getFragments()
+            .some(fragment => fragment.id === value);
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { EducationalFormFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class IndexableEducationalFormRule extends BaseProgrammeRule {
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedEducationalForm = seoInfoBase.getFilterOptionValueBy(FilterKey.EDUCATIONAL_FORM, filterState);
+        if (!selectedEducationalForm) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.isIndexable(selectedEducationalForm);
+        return Promise.resolve(isIndexable);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedEducationalForm] = filterKeyValues.get(FilterKey.EDUCATIONAL_FORM);
+        if (!selectedEducationalForm) {
+            return Promise.resolve(false);
+        }
+        const isIndexable = this.isIndexable(selectedEducationalForm);
+        return Promise.resolve(isIndexable);
+    }
+    getName() {
+        return 'IndexableEducationalFormRule';
+    }
+    getDescription() {
+        return `Indexable if educational form is Academic Course, Summer School, Semester Study Abroad, or Skill Professional Course.`;
+    }
+    isIndexable(value) {
+        return (value === EducationalFormFilterOptionValue.ACADEMIC_COURSE ||
+            value === EducationalFormFilterOptionValue.SUMMER_SCHOOL ||
+            value === EducationalFormFilterOptionValue.SEMESTER_STUDY_ABROAD ||
+            value === EducationalFormFilterOptionValue.SKILL_PROFESSIONAL_COURSE);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { IProgrammeSearchDependencies } from '../types/IProgrammeSearchDependencies';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class IndexablePageNumberRule extends BaseProgrammeRule {
+    private commonRule;
+    forSearch(dependencies: IProgrammeSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,17 @@
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+import { IndexablePageNumberRule as CommonIndexablePageNumberRule } from '../../common/rules/IndexablePageNumberRule';
+export class IndexablePageNumberRule extends BaseProgrammeRule {
+    commonRule = new CommonIndexablePageNumberRule();
+    forSearch(dependencies) {
+        return this.commonRule.forSearch(dependencies);
+    }
+    forSitemapGenerator() {
+        return this.commonRule.forSitemapGenerator();
+    }
+    getName() {
+        return this.commonRule.getName();
+    }
+    getDescription() {
+        return this.commonRule.getDescription();
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class MbaDegreeRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.DEGREE_TYPE, [DegreeTypeFilterOptionValue.MBA]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'MbaDegreeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected degree type is MBA.';
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MbaOrMscDegreeRule extends BaseProgrammeRule {
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDegree = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        if (!selectedDegree) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(selectedDegree === DegreeTypeFilterOptionValue.MSC || selectedDegree === DegreeTypeFilterOptionValue.MBA);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDegree] = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        if (!selectedDegree) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(selectedDegree === DegreeTypeFilterOptionValue.MSC || selectedDegree === DegreeTypeFilterOptionValue.MBA);
+    }
+    getName() {
+        return 'MbaOrMscDegreeRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected degree type is MBA or MSc.';
+    }
+}

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

@@ -0,0 +1,11 @@
+import { IProgrammeSearchDependencies } from '../types/IProgrammeSearchDependencies';
+import { PortalType } from '@studyportals/domain-client';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class NotDistanceLearningPortalRule extends BaseProgrammeRule {
+    private readonly portalType;
+    constructor(portalType?: PortalType);
+    forSearch(dependencies: IProgrammeSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,28 @@
+import { PortalType } from '@studyportals/domain-client';
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class NotDistanceLearningPortalRule extends BaseProgrammeRule {
+    portalType;
+    constructor(portalType) {
+        super();
+        this.portalType = portalType;
+    }
+    forSearch(dependencies) {
+        const { portalType } = dependencies;
+        const isDistanceLearning = portalType === PortalType.DISTANCE_LEARNING;
+        return Promise.resolve(!isDistanceLearning);
+    }
+    forSitemapGenerator() {
+        if (!this.portalType) {
+            throw new DependencyMissingError('PortalType');
+        }
+        const isDistanceLearning = this.portalType === PortalType.DISTANCE_LEARNING;
+        return Promise.resolve(!isDistanceLearning);
+    }
+    getName() {
+        return 'NotDistanceLearningPortalRule';
+    }
+    getDescription() {
+        return 'Is indexable if the portal type is not distance learning.';
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DurationFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OneYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.DURATION, [DurationFilterOptionValue.ONE_YEAR]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OneYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is 1 year.';
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { FormatFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class PartTimeFormatRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.ATTENDANCE, [FormatFilterOptionValue.PART_TIME]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'PartTimeFormatRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected format is part-time.';
+    }
+}