@studyportals/fawkes 8.1.2-2 → 8.1.2-3

package/dist/src/common/IPolicyMetaData.d.ts

@@ -0,0 +1,6 @@
+import { IRule } from "./IRule";
+export interface IPolicyMetaData {
+    getAllRules(): IRule[];
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/common/rules/BaseFilterKeyValueRule.js

@@ -16,11 +16,18 @@ export class BaseFilterKeyValueRule {
     forSitemapGenerator(filterKeyValues) {
         for (const [key, values] of this.expectedFilterKeyValues) {
             const filterValues = filterKeyValues.get(key);
-            if (!filterValues || filterValues.length !== values.length) {
+            if (!filterValues || filterValues.length === 0) {
                 return Promise.resolve(false);
             }
-            if (!values.every((value) => filterValues.includes(value))) {
-                return Promise.resolve(false);
+            if (values.length === 1) {
+                if (filterValues.length !== 1 || filterValues[0] !== values[0]) {
+                    return Promise.resolve(false);
+                }
+            }
+            else {
+                if (!values.some((value) => filterValues.includes(value))) {
+                    return Promise.resolve(false);
+                }
             }
         }
         return Promise.resolve(true);

package/dist/src/enums/FilterCombinations.d.ts

@@ -4,6 +4,8 @@ export declare enum FilterCombinations {
     AREA_DISCIPLINE = "areaDiscipline",
     COUNTRY = "country",
     DEGREE = "degree",
+    DURATION = "duration",
+    FORMAT = "format",
     COUNTRY_DEGREE = "countryDegree",
     COUNTRY_DURATION = "countryDuration",
     COUNTRY_FORMAT = "countryFormat",
@@ -11,6 +13,10 @@ export declare enum FilterCombinations {
     COUNTRY_EDUCATIONAL_FORM = "countryEducationalForm",
     COUNTRY_ATTENDANCE_DEGREE = "countryAttendanceDegree",
     COUNTRY_DURATION_DEGREE = "countryDurationDegree",
+    COUNTRY_SPECIAL_PROGRAMMES = "countrySpecialProgrammes",
+    CONTINENT_FORMAT = "continentFormat",
+    CONTINENT_DURATION = "continentDuration",
+    CONTINENT_SPECIAL_PROGRAMMES = "continentSpecialProgrammes",
     DISCIPLINE_AREA = "disciplineArea",
     DISCIPLINE_ATTENDANCE = "disciplineAttendance",
     DISCIPLINE_COUNTRY = "disciplineCountry",
@@ -22,16 +28,35 @@ export declare enum FilterCombinations {
     DISCIPLINE_EDUCATIONAL_FORM = "disciplineEducationalForm",
     DISCIPLINE_TUITION_FEE_ATTENDANCE = "disciplineTuitionFeeAttendance",
     DISCIPLINE_COUNTRY_EDUCATIONAL_FORM = "disciplineCountryEducationalForm",
+    DISCIPLINE_CONTINENT_ATTENDANCE = "disciplineContinentAttendance",
+    DISCIPLINE_SPECIAL_PROGRAMMES = "disciplineSpecialProgrammes",
+    DISCIPLINE_COUNTRY_ATTENDANCE = "disciplineCountryAttendance",
     DEGREE_COUNTRY_DISCIPLINE = "degreeCountryDiscipline",
     DEGREE_ATTENDANCE_DISCIPLINE = "degreeAttendanceDiscipline",
     DEGREE_COUNTRY_TUITION_FEE = "degreeCountryTuitionFee",
     DEGREE_COUNTRY_ATTENDANCE = "degreeCountryAttendance",
+    DEGREE_TUITION_FEE = "degreeTuitionFee",
+    DEGREE_ATTENDANCE_TUITION_FEE = "degreeAttendanceTuitionFee",
+    DEGREE_ATTENDANCE_FORMAT = "degreeAttendanceFormat",
+    DEGREE_AREA = "degreeArea",
+    DEGREE_FORMAT = "degreeFormat",
+    DEGREE_CONTINENT = "degreeContinent",
+    DEGREE_AREA_TUITION_FEE = "degreeAreaTuitionFee",
+    DEGREE_CONTINENT_TUITION_FEE = "degreeContinentTuitionFee",
+    DEGREE_DURATION = "degreeDuration",
+    DEGREE_FORMAT_TUITION_FEE = "degreeFormatTuitionFee",
+    DEGREE_SPECIAL_PROGRAMMES = "degreeSpecialProgrammes",
+    DEGREE_ATTENDANCE_SPECIAL_PROGRAMMES = "degreeAttendanceSpecialProgrammes",
     DISCIPLINE = "discipline",
     UNFILTERED = "unfiltered",
     UNIVERSITY_COUNTRY = "universityCountry",
     ATTENDANCE_DISCIPLINE = "attendancedDiscipline",
     ATTENDANCE_DEGREE = "attendanceDegree",
-    CONTINENT_ATTENDANCE = "continentAttendance",
+    ATTENDANCE_TUITION_FEE = "attendanceTuitionFee",
+    ATTENDANCE_DURATION = "attendanceDuration",
+    ATTENDANCE_FORMAT = "attendanceFormat",
+    ATTENDANCE_AREA = "attendanceArea",
+    ATTENDANCE_CONTINENT = "attendanceContinent",
     COUNTRY_ATTENDANCE = "countryAttendance",
     ATTENDANCE = "attendance",
     CONTINENT = "continent",

package/dist/src/enums/FilterCombinations.js

@@ -5,6 +5,8 @@ export var FilterCombinations;
     FilterCombinations["AREA_DISCIPLINE"] = "areaDiscipline";
     FilterCombinations["COUNTRY"] = "country";
     FilterCombinations["DEGREE"] = "degree";
+    FilterCombinations["DURATION"] = "duration";
+    FilterCombinations["FORMAT"] = "format";
     FilterCombinations["COUNTRY_DEGREE"] = "countryDegree";
     FilterCombinations["COUNTRY_DURATION"] = "countryDuration";
     FilterCombinations["COUNTRY_FORMAT"] = "countryFormat";
@@ -12,6 +14,10 @@ export var FilterCombinations;
     FilterCombinations["COUNTRY_EDUCATIONAL_FORM"] = "countryEducationalForm";
     FilterCombinations["COUNTRY_ATTENDANCE_DEGREE"] = "countryAttendanceDegree";
     FilterCombinations["COUNTRY_DURATION_DEGREE"] = "countryDurationDegree";
+    FilterCombinations["COUNTRY_SPECIAL_PROGRAMMES"] = "countrySpecialProgrammes";
+    FilterCombinations["CONTINENT_FORMAT"] = "continentFormat";
+    FilterCombinations["CONTINENT_DURATION"] = "continentDuration";
+    FilterCombinations["CONTINENT_SPECIAL_PROGRAMMES"] = "continentSpecialProgrammes";
     FilterCombinations["DISCIPLINE_AREA"] = "disciplineArea";
     FilterCombinations["DISCIPLINE_ATTENDANCE"] = "disciplineAttendance";
     FilterCombinations["DISCIPLINE_COUNTRY"] = "disciplineCountry";
@@ -23,16 +29,35 @@ export var FilterCombinations;
     FilterCombinations["DISCIPLINE_EDUCATIONAL_FORM"] = "disciplineEducationalForm";
     FilterCombinations["DISCIPLINE_TUITION_FEE_ATTENDANCE"] = "disciplineTuitionFeeAttendance";
     FilterCombinations["DISCIPLINE_COUNTRY_EDUCATIONAL_FORM"] = "disciplineCountryEducationalForm";
+    FilterCombinations["DISCIPLINE_CONTINENT_ATTENDANCE"] = "disciplineContinentAttendance";
+    FilterCombinations["DISCIPLINE_SPECIAL_PROGRAMMES"] = "disciplineSpecialProgrammes";
+    FilterCombinations["DISCIPLINE_COUNTRY_ATTENDANCE"] = "disciplineCountryAttendance";
     FilterCombinations["DEGREE_COUNTRY_DISCIPLINE"] = "degreeCountryDiscipline";
     FilterCombinations["DEGREE_ATTENDANCE_DISCIPLINE"] = "degreeAttendanceDiscipline";
     FilterCombinations["DEGREE_COUNTRY_TUITION_FEE"] = "degreeCountryTuitionFee";
     FilterCombinations["DEGREE_COUNTRY_ATTENDANCE"] = "degreeCountryAttendance";
+    FilterCombinations["DEGREE_TUITION_FEE"] = "degreeTuitionFee";
+    FilterCombinations["DEGREE_ATTENDANCE_TUITION_FEE"] = "degreeAttendanceTuitionFee";
+    FilterCombinations["DEGREE_ATTENDANCE_FORMAT"] = "degreeAttendanceFormat";
+    FilterCombinations["DEGREE_AREA"] = "degreeArea";
+    FilterCombinations["DEGREE_FORMAT"] = "degreeFormat";
+    FilterCombinations["DEGREE_CONTINENT"] = "degreeContinent";
+    FilterCombinations["DEGREE_AREA_TUITION_FEE"] = "degreeAreaTuitionFee";
+    FilterCombinations["DEGREE_CONTINENT_TUITION_FEE"] = "degreeContinentTuitionFee";
+    FilterCombinations["DEGREE_DURATION"] = "degreeDuration";
+    FilterCombinations["DEGREE_FORMAT_TUITION_FEE"] = "degreeFormatTuitionFee";
+    FilterCombinations["DEGREE_SPECIAL_PROGRAMMES"] = "degreeSpecialProgrammes";
+    FilterCombinations["DEGREE_ATTENDANCE_SPECIAL_PROGRAMMES"] = "degreeAttendanceSpecialProgrammes";
     FilterCombinations["DISCIPLINE"] = "discipline";
     FilterCombinations["UNFILTERED"] = "unfiltered";
     FilterCombinations["UNIVERSITY_COUNTRY"] = "universityCountry";
     FilterCombinations["ATTENDANCE_DISCIPLINE"] = "attendancedDiscipline";
     FilterCombinations["ATTENDANCE_DEGREE"] = "attendanceDegree";
-    FilterCombinations["CONTINENT_ATTENDANCE"] = "continentAttendance";
+    FilterCombinations["ATTENDANCE_TUITION_FEE"] = "attendanceTuitionFee";
+    FilterCombinations["ATTENDANCE_DURATION"] = "attendanceDuration";
+    FilterCombinations["ATTENDANCE_FORMAT"] = "attendanceFormat";
+    FilterCombinations["ATTENDANCE_AREA"] = "attendanceArea";
+    FilterCombinations["ATTENDANCE_CONTINENT"] = "attendanceContinent";
     FilterCombinations["COUNTRY_ATTENDANCE"] = "countryAttendance";
     FilterCombinations["ATTENDANCE"] = "attendance";
     FilterCombinations["CONTINENT"] = "continent";

package/dist/src/organisations/OrganisationsRuleBasedIndexabilityPolicy.d.ts

@@ -0,0 +1,11 @@
+import { PortalType } from '@studyportals/domain-client';
+import { IOrganisationsSeoDependencies } from './types/IOrganisationsSeoDependencies';
+import { SortingOptions } from '../enums/SortingOptions';
+import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
+export declare abstract class OrganisationsRuleBasedIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IOrganisationsSeoDependencies> {
+    protected readonly indexablePortalTypes: PortalType[];
+    protected abstract readonly sortingOption: SortingOptions;
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected isIndexable(): Promise<boolean>;
+    private matchesSortingOption;
+}

package/dist/src/organisations/OrganisationsRuleBasedIndexabilityPolicy.js

@@ -0,0 +1,19 @@
+import { PortalType } from '@studyportals/domain-client';
+import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
+export class OrganisationsRuleBasedIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    indexablePortalTypes = [PortalType.MASTER];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async isIndexable() {
+        const isIndexable = await super.isIndexable();
+        if (!isIndexable) {
+            return false;
+        }
+        return this.indexablePortalTypes.includes(this.dependencies.portalType) && this.matchesSortingOption();
+    }
+    matchesSortingOption() {
+        const dependencies = this.dependencies;
+        return dependencies.sortingState.getSelectedOption() === this.sortingOption;
+    }
+}

package/dist/src/organisations/rules/AtLeastTwoRankedResultsRule.d.ts

@@ -0,0 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+export declare class AtLeastTwoRankedResultsRule implements IRule {
+    private readonly minimumRankedResultsCount;
+    private readonly rankingApiClient?;
+    constructor(rankingApiClient?: IRankingApiClient);
+    forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/organisations/rules/AtLeastTwoRankedResultsRule.js

@@ -0,0 +1,26 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class AtLeastTwoRankedResultsRule {
+    minimumRankedResultsCount = 2;
+    rankingApiClient;
+    constructor(rankingApiClient) {
+        this.rankingApiClient = rankingApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const rankedResultsCount = applicationState.getRankedResultsCount();
+        return Promise.resolve(rankedResultsCount >= this.minimumRankedResultsCount);
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        if (!this.rankingApiClient) {
+            throw new DependencyMissingError('RankingApiClient');
+        }
+        const rankedResultsCount = await this.rankingApiClient.getRankedOrganisationCount(filterKeyValues);
+        return rankedResultsCount >= this.minimumRankedResultsCount;
+    }
+    getName() {
+        return 'AtLeastTwoRankedResultsRule';
+    }
+    getDescription() {
+        return `At least ${this.minimumRankedResultsCount} ranked results are available`;
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseFilterKeyValueRule } from '../../common/rules/BaseFilterKeyValueRule';
+export class OnlineAttendanceRule extends BaseFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, ['online']]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OnlineAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexable if attendance is online';
+    }
+}

package/dist/src/presenters/AttendancePresenter.js

@@ -8,6 +8,10 @@ export class AttendancePresenter {
             {
                 id: 'online',
                 path: 'online'
+            },
+            {
+                id: 'blended',
+                path: 'blended'
             }
         ];
     }

package/dist/src/presenters/FormatPresenter.js

@@ -4,11 +4,14 @@ export class FormatPresenter {
     static instance;
     fragments;
     constructor() {
-        // Part-time is the only indexable format according to PartTimeFormatRule
         this.fragments = [
             {
                 id: FormatFilterOptionValue.PART_TIME,
                 path: 'part-time'
+            },
+            {
+                id: FormatFilterOptionValue.FULL_TIME,
+                path: 'full-time'
             }
         ];
     }

package/dist/src/presenters/SpecialProgrammesPresenter.js

@@ -12,6 +12,10 @@ export class SpecialProgrammesPresenter {
             {
                 id: SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS,
                 path: 'erasmus-mundus'
+            },
+            {
+                id: SpecialProgrammesFilterOptionValue.EXECUTIVE_PROGRAMMES,
+                path: 'executive-programmes'
             }
         ];
     }

package/dist/src/programmes/IProgrammeSearchApplicationState.d.ts

@@ -0,0 +1,4 @@
+import { ISearchApplicationState } from '../common';
+export interface IProgrammeSearchApplicationState extends ISearchApplicationState {
+    getPageNumber(): number;
+}

package/dist/src/programmes/IProgrammeSearchApplicationState.js

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

package/dist/src/programmes/IProgrammeSearchDependencies.d.ts

@@ -0,0 +1,7 @@
+import { ISearchDependencies } from '../common/ISearchDependencies';
+import { IProgrammeSearchApplicationState } from './IProgrammeSearchApplicationState';
+import { PortalType } from '@studyportals/domain-client';
+export interface IProgrammeSearchDependencies extends ISearchDependencies {
+    portalType: PortalType;
+    applicationState: IProgrammeSearchApplicationState;
+}

package/dist/src/programmes/IProgrammeSearchDependencies.js

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

package/dist/src/programmes/IProgrammesSeoDependencies.d.ts

@@ -0,0 +1,2 @@
+import { IProgrammeSearchDependencies } from "./IProgrammeSearchDependencies";
+export type IProgrammesSeoDependencies = IProgrammeSearchDependencies;

package/dist/src/programmes/IProgrammesSeoDependencies.js

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

package/dist/src/programmes/SearchIndexabilityManager.js

@@ -1,6 +1,8 @@
-import { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, CountryAttendanceDegree, CountryDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, Discipline, DisciplineArea, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, SpecialProgrammes, TuitionFee, Unfiltered } from './policies';
+import { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, CountryAttendanceDegree, CountryDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, Discipline, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, SpecialProgrammes, TuitionFee, Unfiltered, AttendanceArea, AttendanceContinent, AttendanceDuration, AttendanceFormat, AttendanceTuitionFee, ContinentDuration, ContinentFormat, ContinentSpecialProgrammes, CountrySpecialProgrammes, DegreeArea, DegreeAreaTuitionFee, DegreeAttendanceFormat, DegreeAttendanceTuitionFee, DegreeContinent, DegreeContinentTuitionFee, DegreeDuration, DegreeFormat, DegreeFormatTuitionFee, DegreeSpecialProgrammes, DegreeTuitionFee, DisciplineContinentAttendance, DisciplineCountryAttendance, DisciplineCountryFormat, Duration, Format } from './policies';
 import { DependencyTypes } from '../enums/DependencyTypes';
 import { Degree } from './policies/Degree';
+import { DisciplineSpecialProgrammes } from './policies/DisciplineSpecialProgrammes';
+import { DegreeAttendanceSpecialProgrammes } from './policies/DegreeAttendanceSpecialProgrammes';
 export class SearchIndexabilityManager {
     policies;
     constructor(portalType, seoInfoBase, filterState, applicationState) {
@@ -31,8 +33,8 @@ export class SearchIndexabilityManager {
             new DegreeCountryAttendance(dependencies),
             new DegreeCountryDiscipline(dependencies),
             new DegreeCountryTuitionFee(dependencies),
+            new DegreeAttendanceSpecialProgrammes(dependencies),
             new Discipline(dependencies),
-            new DisciplineArea(dependencies),
             new DisciplineAttendance(dependencies),
             new DisciplineContinent(dependencies),
             new DisciplineCountry(dependencies),
@@ -44,8 +46,34 @@ export class SearchIndexabilityManager {
             new DisciplineTuitionFee(dependencies),
             new DisciplineTuitionFeeAttendance(dependencies),
             new SpecialProgrammes(dependencies),
+            new DisciplineSpecialProgrammes(dependencies),
             new TuitionFee(dependencies),
-            new Unfiltered(dependencies)
+            new Unfiltered(dependencies),
+            new CountrySpecialProgrammes(dependencies),
+            new DegreeArea(dependencies),
+            new DegreeAreaTuitionFee(dependencies),
+            new DegreeAttendanceFormat(dependencies),
+            new DegreeAttendanceTuitionFee(dependencies),
+            new DegreeContinent(dependencies),
+            new DegreeContinentTuitionFee(dependencies),
+            new DegreeDuration(dependencies),
+            new DegreeFormat(dependencies),
+            new DegreeFormatTuitionFee(dependencies),
+            new DegreeSpecialProgrammes(dependencies),
+            new DegreeTuitionFee(dependencies),
+            new DisciplineContinentAttendance(dependencies),
+            new DisciplineCountryAttendance(dependencies),
+            new DisciplineCountryFormat(dependencies),
+            new Duration(dependencies),
+            new Format(dependencies),
+            new AttendanceArea(dependencies),
+            new AttendanceContinent(dependencies),
+            new AttendanceDuration(dependencies),
+            new AttendanceFormat(dependencies),
+            new AttendanceTuitionFee(dependencies),
+            new ContinentDuration(dependencies),
+            new ContinentFormat(dependencies),
+            new ContinentSpecialProgrammes(dependencies),
         ];
     }
     getPolicies() {

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

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export declare class AttendanceArea 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/AttendanceArea.js

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

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

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export declare class AttendanceContinent 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/AttendanceContinent.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { ContinentPresenter } from '../../presenters/ContinentPresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+export class AttendanceContinent extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Attendance Continent Policy';
+    description = 'Determines indexing rules for pages filtered by tuition fee and attendance.';
+    filterKeys = [FilterKey.CONTINENT, FilterKey.DELIVERY_METHOD];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.CONTINENT]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const attendance of attendanceFragments) {
+                for (const continent of continentFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                        [FilterKey.CONTINENT, [continent.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${attendance.path}/${continent.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.ATTENDANCE_CONTINENT;
+    }
+}

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

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

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

@@ -2,21 +2,21 @@ import { FilterKey } from '@studyportals/search-filters/server-side';
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
-import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
-import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
 import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
+import { BlendedOrOnlineAttendanceRule } from '../rules/BlendedOrOnlineAttendanceRule';
 export class AttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
     name = 'Attendance Degree Type Policy';
-    description = 'Determines indexing rules for pages filtered by both study format (online, on-campus, etc.), and degree type prioritizing degrees and formats with demonstrated search demand.';
+    description = 'Determines indexing rules for pages filtered by both study format (online, blended, on-campus, etc.), and degree type prioritizing degrees and formats with demonstrated search demand.';
     filterKeys = [FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
         new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
         new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE]),
         new IndexableDegreeRule(),
-        new OnlineAttendanceRule()
+        new BlendedOrOnlineAttendanceRule()
     ];
     constructor(dependencies) {
         super(dependencies);

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

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

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

@@ -0,0 +1,50 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { DurationPresenter } from '../../presenters/DurationPresenter';
+import { OneYearDurationRule } from '../../programmes/rules/OneYearDurationRule';
+export class AttendanceDuration extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Attendance Duration Type Policy';
+    description = 'Determines indexing rules for pages filtered by both study format (online, on-campus, etc.), and duration prioritizing durations and formats with demonstrated search demand.';
+    filterKeys = [FilterKey.DELIVERY_METHOD, FilterKey.DURATION];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.DURATION),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DURATION]),
+        new OnlineAttendanceRule(),
+        new OneYearDurationRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const durationFragments = DurationPresenter.getInstance().getFragments();
+        const paths = [];
+        const allowedDurationIds = ["[360,360]"];
+        const allowedDurations = durationFragments.filter(duration => allowedDurationIds.includes(duration.id));
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const attendance of attendanceFragments) {
+                for (const duration of allowedDurations) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                        [FilterKey.DURATION, [duration.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${attendance.path}/${duration.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.ATTENDANCE_DURATION;
+    }
+}