@studyportals/fawkes 7.4.2-2 → 7.4.2-4

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

@@ -1,20 +1,20 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { IndexableDurationRule } from '../rules/IndexableDurationRule';
+import { OneYearOnlyRule } from '../rules/OneYearOnlyRule';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { CountryPresenter } from '../../presenters/CountryPresenter';
 import { DurationPresenter } from '../../presenters/DurationPresenter';
 export class CountryDuration extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Duration Policy';
-    description = 'Determines indexing rules for pages filtered by both country, and duration (1 year, 2 years, etc.).';
+    description = 'Determines indexing rules for pages filtered by both country, and duration (1 year only).';
     filterKeys = [FilterKey.COUNTRY, FilterKey.DURATION];
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
         new SingleValueSelectedForFilterRule(FilterKey.DURATION),
         new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DURATION]),
-        new IndexableDurationRule()
+        new OneYearOnlyRule()
     ];
     constructor(dependencies) {
         super(dependencies);
@@ -23,10 +23,12 @@ export class CountryDuration extends ProgrammesBaseIndexabilityPolicy {
     async generateUrls() {
         const countryFragments = CountryPresenter.getInstance().getFragments();
         const durationFragments = DurationPresenter.getInstance().getFragments();
+        const allowedDurationIds = ["[360,360]"];
+        const allowedDurations = durationFragments.filter(duration => allowedDurationIds.includes(duration.id));
         const paths = [];
         for (const pageNumber of this.indexablePageNumbers) {
             for (const country of countryFragments) {
-                for (const duration of durationFragments) {
+                for (const duration of allowedDurations) {
                     const filterKeyValues = new Map([
                         [FilterKey.COUNTRY, [country.id]],
                         [FilterKey.DURATION, [duration.id]]

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
@@ -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.d.ts

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
@@ -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/CountryFormat.d.ts

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

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

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { SpecialProgrammesPresenter } from '../../presenters/SpecialProgrammesPresenter';
+export class CountrySpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Special Programmes Policy';
+    description = 'Determines indexing rules for pages filtered by country and special programmes (Joint).';
+    filterKeys = [FilterKey.COUNTRY, FilterKey.SPECIAL_PROGRAMMES];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.SPECIAL_PROGRAMMES),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.SPECIAL_PROGRAMMES, FilterKey.COUNTRY]),
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const specialProgrammesFragments = SpecialProgrammesPresenter.getInstance().getFragments();
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = [];
+        const validSpecialProgrammesIds = ['joint'];
+        const validSpecialProgrammes = specialProgrammesFragments.filter(specialProgramme => validSpecialProgrammesIds.includes(specialProgramme.id));
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const specialProgramme of validSpecialProgrammes) {
+                for (const country of countryFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.SPECIAL_PROGRAMMES, [specialProgramme.id]],
+                        [FilterKey.COUNTRY, [country.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${country.path}/${specialProgramme.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_SPECIAL_PROGRAMMES;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

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

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AreaPresenter } from '../../presenters/AreaPresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+export class DegreeArea extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Area Policy';
+    description = 'Controls indexing of pages filtered by geographic areas and degree type.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.AREA];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.DEGREE_TYPE])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const degree of degreeFragments) {
+                for (const area of areaFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.AREA, [area.id]],
+                        [FilterKey.COUNTRY, [area.countryId]],
+                        [FilterKey.DEGREE_TYPE, [degree.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${degree.path}/${area.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_AREA;
+    }
+}

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

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

@@ -0,0 +1,52 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AreaPresenter } from '../../presenters/AreaPresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
+export class DegreeAreaTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Area Tuition fee Policy';
+    description = 'Controls indexing of pages filtered by geographic areas and tuition fees.';
+    filterKeys = [FilterKey.AREA, FilterKey.TUITION_FEE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.DEGREE_TYPE, FilterKey.TUITION_FEE])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const degree of degreeFragments) {
+                for (const area of areaFragments) {
+                    for (const tuitionFee of tuitionFeeFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.AREA, [area.id]],
+                            [FilterKey.COUNTRY, [area.countryId]],
+                            [FilterKey.DEGREE_TYPE, [degree.id]],
+                            [FilterKey.TUITION_FEE, [tuitionFee.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${area.path}/${tuitionFee.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_AREA_TUITION_FEE;
+    }
+}

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

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

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

@@ -1,4 +1,5 @@
-import { FilterKey } from "../../enums/FilterKey";
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters/search_filters_interfaces';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
@@ -7,7 +8,7 @@ import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityP
 import { DegreePresenter } from '../../presenters/DegreePresenter';
 import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
-import { DegreeTypeFilterOptionValue } from "../../enums/DegreeTypeFilterOptionValue";
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
 export class DegreeAttendanceDiscipline extends ProgrammesBaseIndexabilityPolicy {
     name = 'Degree Attendance Discipline Policy';
     description = 'Determines indexing rules for pages filtered by degree type, attendance, and discipline.';
@@ -18,6 +19,7 @@ export class DegreeAttendanceDiscipline extends ProgrammesBaseIndexabilityPolicy
         new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
         new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.DISCIPLINES]),
         new DegreeAttendanceDisciplineSpecificRule(),
+        new OnlineAttendanceRule()
     ];
     constructor(dependencies) {
         super(dependencies);
@@ -33,24 +35,22 @@ export class DegreeAttendanceDiscipline extends ProgrammesBaseIndexabilityPolicy
             DegreeTypeFilterOptionValue.MSC,
             DegreeTypeFilterOptionValue.MBA
         ];
-        const onlineAttendance = attendanceFragments.find(a => a.id === 'online');
-        if (!onlineAttendance) {
-            return paths;
-        }
         for (const pageNumber of this.indexablePageNumbers) {
             for (const degreeId of allowedDegreeIds) {
                 const degree = degreeFragments.find(d => d.id === degreeId);
                 if (!degree)
                     continue;
                 for (const discipline of disciplineFragments) {
-                    const filterKeyValues = new Map([
-                        [FilterKey.DEGREE_TYPE, [degree.id]],
-                        [FilterKey.DELIVERY_METHOD, [onlineAttendance.id]],
-                        [FilterKey.DISCIPLINES, [discipline.id]]
-                    ]);
-                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
-                    if (result) {
-                        paths.push(this.getPathWithPageNumber(`${degree.path}/${onlineAttendance.path}/${discipline.path}`, pageNumber));
+                    for (const attendance of attendanceFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.DEGREE_TYPE, [degree.id]],
+                            [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                            [FilterKey.DISCIPLINES, [discipline.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}/${discipline.path}`, pageNumber));
+                        }
                     }
                 }
             }

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

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

@@ -0,0 +1,52 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { FormatPresenter } from '../../presenters/FormatPresenter';
+export class DegreeAttendanceFormat extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Attendance Format Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, attendance, and format.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.ATTENDANCE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.ATTENDANCE),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.ATTENDANCE]),
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const formatFragments = FormatPresenter.getInstance().getFragments();
+        const paths = [];
+        const allowedFormatIds = ['parttime'];
+        const allowedFormats = formatFragments.filter(f => allowedFormatIds.includes(f.id));
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const degree of degreeFragments) {
+                for (const format of allowedFormats) {
+                    for (const attendance of attendanceFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.DEGREE_TYPE, [degree.id]],
+                            [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                            [FilterKey.ATTENDANCE, [format.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}/${format.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_ATTENDANCE_FORMAT;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+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';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export declare class DegreeAttendanceSpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,56 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { SpecialProgrammesPresenter } from '../../presenters/SpecialProgrammesPresenter';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+export class DegreeAttendanceSpecialProgrammes extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Attendance Special Programmes Policy';
+    description = 'Determines indexing rules for pages filtered by special programmes, attendance(online) and degree type.';
+    filterKeys = [FilterKey.SPECIAL_PROGRAMMES, FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.SPECIAL_PROGRAMMES),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.SPECIAL_PROGRAMMES]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const specialProgrammesFragments = SpecialProgrammesPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        const allowedDegreeIds = ["mba"];
+        const allowedDegrees = degreeFragments.filter(sp => allowedDegreeIds.includes(sp.id));
+        const allowedSpecialProgramIds = ["executive"];
+        const allowedSpecialProgrammes = specialProgrammesFragments.filter(sp => allowedSpecialProgramIds.includes(sp.id));
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const degree of allowedDegrees) {
+                for (const specialProgramme of allowedSpecialProgrammes) {
+                    for (const attendance of attendanceFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.DEGREE_TYPE, [degree.id]],
+                            [FilterKey.SPECIAL_PROGRAMMES, [specialProgramme.id]],
+                            [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}/${specialProgramme.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_SPECIAL_PROGRAMMES;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+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';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export declare class DegreeAttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,55 @@
+import { FilterKey } from '@studyportals/search-filters/search_filters_interfaces';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters/search_filters_interfaces';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export class DegreeAttendanceTuitionFee 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];
+    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 OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
+        const paths = [];
+        const affordableTuition = tuitionFeeFragments.find(t => t.id === TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED);
+        if (!affordableTuition) {
+            return paths;
+        }
+        for (const pageNumber of this.indexablePageNumbers) {
+            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]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}/${affordableTuition.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_ATTENDANCE_TUITION_FEE;
+    }
+}