@studyportals/fawkes 8.1.1 → 8.1.2-0

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

@@ -0,0 +1,69 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfEducationCountryDisciplineRule 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
+    ];
+    // Australia (202), Canada (32)
+    allowedCountryIds = ['202', '32'];
+    getName() {
+        return 'MasterOfEducationCountryDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-education (Australia, Canada) + education disciplines only';
+    }
+    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 !== DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+    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];
+        if (degreeTypeValue !== DegreeTypeFilterOptionValue.MED.valueOf()) {
+            return Promise.resolve(true);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+}

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

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

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

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '32', '108'];
+    getName() {
+        return 'MasterOfLawsCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

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

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

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

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryTuitionFeeRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    allowedCountryIds = ['82', '30', '32', '108']; // USA, UK, Canada, India
+    tuitionFeeValue = TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED;
+    getName() {
+        return 'MasterOfLawsCountryTuitionFeeRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + affordable tuition (0-2500)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const tuitionFeeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.TUITION_FEE, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !tuitionFeeValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const tuitionFeeValues = filterKeyValues.get(FilterKey.TUITION_FEE);
+        if (!degreeTypeValues?.length || !countryValues?.length || !tuitionFeeValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const tuitionFeeValue = tuitionFeeValues[0];
+        // This rule only applies to Master of Laws
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must be in allowed countries and have affordable tuition
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+}

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

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

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

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfPhilosophyCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-philosophy';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '108']; // USA, UK, India
+    getName() {
+        return 'MasterOfPhilosophyCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-philosophy (USA, UK, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

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

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

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

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfScienceDisciplineRule extends BaseProgrammeRule {
+    // Master of Science accepts all disciplines
+    degreeValue = 'master-of-science';
+    getName() {
+        return 'MasterOfScienceDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Master of Science accepts all disciplines
+        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];
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Master of Science accepts all disciplines
+        return Promise.resolve(true);
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OneOrTwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DURATION,
+                [DurationFilterOptionValue.ONE_YEAR, DurationFilterOptionValue.TWO_YEARS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OneOrTwoYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is one or two years.';
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class OneYearOnlyRule extends BaseProgrammeRule {
+    constructor() {
+        super();
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDuration = seoInfoBase.getFilterOptionValueBy(FilterKey.DURATION, filterState);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDuration] = filterKeyValues.get(FilterKey.DURATION);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    getName() {
+        return 'OneYearOnlyRule';
+    }
+    getDescription() {
+        return 'Indexable only if duration is exactly 1 year ([360,360]).';
+    }
+    isOneYear(value) {
+        return value === DurationFilterOptionValue.ONE_YEAR;
+    }
+}

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

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

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

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

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

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

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

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

package/dist/src/sitemap-generator/BaseSitemapUrlGeneratorManager.js

@@ -3,7 +3,6 @@ export class BaseSitemapUrlGeneratorManager {
     async generateUrls() {
         const map = new Map();
         for (const policy of this.policies) {
-            console.debug(`Generating sitemap urls for policy: ${policy.filterCombination}`); // eslint-disable-line no-console
             const filterCombination = policy.filterCombination;
             const urls = await policy.generateSitemapUrls();
             console.debug(`Generated ${urls.length} urls for policy: ${filterCombination}`); // eslint-disable-line no-console

package/dist/src/sitemap-generator/IPageNumberProvider.d.ts

@@ -0,0 +1,3 @@
+export interface IPageNumberProvider {
+    getPageNumber(): number;
+}

package/dist/src/sitemap-generator/IPageNumberProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/src/sitemap-generator/ProgrammesSitemapUrlGeneratorManager.js

@@ -1,6 +1,64 @@
 import { DependencyTypes } from '../enums/DependencyTypes';
 import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
-import { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, Discipline, SpecialProgrammes, TuitionFee, Unfiltered, CountryAttendanceDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, DisciplineArea, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, CountryDegree } from '../programmes/policies';
+import { 
+// Area,
+// Attendance,
+AttendanceDegree, 
+// Continent,
+// ContinentTuitionFee,
+// Country,
+// CountryAttendance,
+// Discipline,
+SpecialProgrammes, 
+// TuitionFee,
+Unfiltered, 
+// CountryAttendanceDegree,
+// CountryDuration,
+// CountryDurationDegree,
+// CountryEducationalForm,
+// CountryFormat,
+// CountryTuitionFee,
+// DegreeAttendanceDiscipline,
+// DegreeCountryAttendance,
+// DegreeCountryDiscipline,
+// DegreeCountryTuitionFee,
+// Format,
+// DisciplineAttendance,
+// DisciplineContinent,
+// DisciplineCountry,
+// DisciplineCountryEducationalForm,
+// DisciplineDegree,
+DisciplineDuration, 
+// DisciplineEducationalForm,
+// DisciplineFormat,
+// DisciplineTuitionFee,
+// DisciplineTuitionFeeAttendance,
+// CountryDegree,
+// DegreeFormat,
+// DegreeContinent,
+// DegreeAttendanceTuitionFee,
+// DegreeArea,
+// DegreeTuitionFee,
+// AttendanceTuitionFee,
+Duration, 
+// AttendanceDuration,
+// DegreeAreaTuitionFee,
+// DisciplineContinentAttendance,
+// DegreeContinentTuitionFee,
+// AttendanceFormat,
+// ContinentFormat,
+// AttendanceContinent,
+// DegreeDuration,
+ContinentSpecialProgrammes, CountrySpecialProgrammes,
+// AttendanceArea,
+// DegreeFormatTuitionFee,
+// ContinentDuration,
+// DegreeAttendanceFormat,
+// DisciplineCountryAttendance,
+// DisciplineCountryFormat,
+// DegreeSpecialProgrammes,
+// Degree
+ } from '../programmes/policies';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { AreaPresenter } from '../presenters/AreaPresenter';
 import { AttendancePresenter } from '../presenters/AttendancePresenter';
@@ -13,7 +71,8 @@ import { SpecialProgrammesPresenter } from '../presenters/SpecialProgrammesPrese
 import { DurationPresenter } from '../presenters/DurationPresenter';
 import { EducationalFormPresenter } from '../presenters/EducationalFormPresenter';
 import { FormatPresenter } from '../presenters/FormatPresenter';
-import { Degree } from '../programmes/policies/Degree';
+// import { DisciplineSpecialProgrammes } from '../programmes/policies/DisciplineSpecialProgrammes';
+// import { DegreeAttendanceSpecialProgrammes } from '../programmes/policies/DegreeAttendanceSpecialProgrammes';
 export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
     portalType;
     policies;
@@ -27,40 +86,66 @@ export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGenerato
             portalType
         };
         this.policies = [
-            new Area(dependencies),
-            new Attendance(dependencies),
+            // new Area(dependencies),
+            // new Attendance(dependencies),
             new AttendanceDegree(dependencies),
-            new Continent(dependencies),
-            new ContinentTuitionFee(dependencies),
-            new Country(dependencies),
-            new CountryAttendance(dependencies),
-            new Discipline(dependencies),
-            new Degree(dependencies),
+            // new AttendanceDuration(dependencies),
+            // new AttendanceContinent(dependencies),
+            // new Continent(dependencies),
+            // new ContinentTuitionFee(dependencies),
+            // new Country(dependencies),
+            // new CountryAttendance(dependencies),
+            // new Discipline(dependencies),
+            // new Degree(dependencies),
             new SpecialProgrammes(dependencies),
-            new TuitionFee(dependencies),
+            // new TuitionFee(dependencies),
             new Unfiltered(dependencies),
-            new CountryAttendanceDegree(dependencies),
-            new CountryDegree(dependencies),
-            new CountryDuration(dependencies),
-            new CountryDurationDegree(dependencies),
-            new CountryEducationalForm(dependencies),
-            new CountryFormat(dependencies),
-            new CountryTuitionFee(dependencies),
-            new DegreeAttendanceDiscipline(dependencies),
-            new DegreeCountryAttendance(dependencies),
-            new DegreeCountryDiscipline(dependencies),
-            new DegreeCountryTuitionFee(dependencies),
-            new DisciplineArea(dependencies),
-            new DisciplineAttendance(dependencies),
-            new DisciplineContinent(dependencies),
-            new DisciplineCountry(dependencies),
-            new DisciplineCountryEducationalForm(dependencies),
-            new DisciplineDegree(dependencies),
+            new Duration(dependencies),
+            // new CountryAttendanceDegree(dependencies),
+            // new CountryDegree(dependencies),
+            // new CountryDuration(dependencies),
+            // new CountryDurationDegree(dependencies),
+            // new CountryEducationalForm(dependencies),
+            // new CountryFormat(dependencies),
+            // new CountryTuitionFee(dependencies),
+            new CountrySpecialProgrammes(dependencies),
+            // new ContinentFormat(dependencies),
+            new ContinentSpecialProgrammes(dependencies),
+            // new ContinentDuration(dependencies),
+            // new DegreeAttendanceDiscipline(dependencies),
+            // new DegreeCountryAttendance(dependencies),
+            // new DegreeCountryDiscipline(dependencies),
+            // new DegreeCountryTuitionFee(dependencies),
+            // new DegreeFormat(dependencies),
+            // new DegreeContinent(dependencies),
+            // new DegreeAttendanceTuitionFee(dependencies),
+            // new DegreeArea(dependencies),
+            // new DegreeTuitionFee(dependencies),
+            // new DegreeAreaTuitionFee(dependencies),
+            // new DegreeContinentTuitionFee(dependencies),
+            // new DegreeDuration(dependencies),
+            // new DegreeFormatTuitionFee(dependencies),
+            // new DegreeAttendanceFormat(dependencies),
+            // new DegreeSpecialProgrammes(dependencies),
+            // new DegreeAttendanceSpecialProgrammes(dependencies),
+            // new Format(dependencies),
+            // new DisciplineAttendance(dependencies),
+            // new DisciplineContinent(dependencies),
+            // new DisciplineCountry(dependencies),
+            // new DisciplineCountryEducationalForm(dependencies),
+            // new DisciplineDegree(dependencies),
             new DisciplineDuration(dependencies),
-            new DisciplineEducationalForm(dependencies),
-            new DisciplineFormat(dependencies),
-            new DisciplineTuitionFee(dependencies),
-            new DisciplineTuitionFeeAttendance(dependencies)
+            // new DisciplineEducationalForm(dependencies),
+            // new DisciplineFormat(dependencies),
+            // new DisciplineTuitionFee(dependencies),
+            // new DisciplineTuitionFeeAttendance(dependencies),
+            // new DisciplineContinentAttendance(dependencies),
+            // new DisciplineCountryAttendance(dependencies),
+            // new DisciplineCountryFormat(dependencies),
+            // new DisciplineSpecialProgrammes(dependencies),
+            // new AttendanceTuitionFee(dependencies),
+            // new AttendanceFormat(dependencies),
+            // new AttendanceArea(dependencies)
         ];
         this.presenters.set(FilterKey.AREA, AreaPresenter.getInstance());
         this.presenters.set(FilterKey.DELIVERY_METHOD, AttendancePresenter.getInstance());