@studyportals/fawkes 6.0.1-0 → 6.0.1-2

package/dist/programmes-seo/index.d.ts

@@ -1,6 +1,6 @@
 import { ISeoFilterState } from '../src/common/ISeoFilterState';
 import { ISeoInfoBase } from '../src/common/ISeoInfoBase';
-import { IProgrammeSearchApplicationState } from '../src/programmes/IProgrammeSearchApplicationState';
+import { IProgrammeSearchApplicationState } from '../src/programmes/types/IProgrammeSearchApplicationState';
 import { ISearchIndexabilityManager } from '../src/common/ISearchIndexabilityManager';
 import { SearchIndexabilityManager } from '../src/programmes/SearchIndexabilityManager';
 export { ISeoFilterState, ISeoInfoBase, ISearchIndexabilityManager, IProgrammeSearchApplicationState, SearchIndexabilityManager };

package/dist/sitemap-generator-seo/index.d.ts

@@ -1,13 +1,13 @@
-import { IOrganisationsClient } from '../src/sitemap-generator/IOrganisationsClient';
-import { IOrganisation } from '../src/sitemap-generator/IOrganisation';
-import { IRankingApiClient } from '../src/sitemap-generator/IRankingApiClient';
-import { ISearchApiClient } from '../src/sitemap-generator/ISearchApiClient';
-import { ISitemapUrlGeneratorManager } from '../src/sitemap-generator/ISitemapUrlGeneratorManager';
-import { OrganisationsSitemapUrlGeneratorManager } from '../src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
-import { ScholarshipsSitemapUrlGeneratorManager } from '../src/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
-import { ProgrammesSitemapUrlGeneratorManager } from '../src/sitemap-generator/ProgrammesSitemapUrlGeneratorManager';
-import { FilterCombinations } from '../src/enums/FilterCombinations';
-import { ISitemapUrlGenerator } from '../src/common/ISitemapUrlGenerator';
-import { FilterKeyValuesMap } from '../src/common/FilterKeyValuesMap';
-import { IPresenter } from '../src/common';
-export { IOrganisationsClient, IOrganisation, IRankingApiClient, ISearchApiClient, ISitemapUrlGeneratorManager, OrganisationsSitemapUrlGeneratorManager, ScholarshipsSitemapUrlGeneratorManager, ProgrammesSitemapUrlGeneratorManager, FilterCombinations, ISitemapUrlGenerator, FilterKeyValuesMap, IPresenter };
+export { IOrganisationsClient } from '../src/sitemap-generator/IOrganisationsClient';
+export { IOrganisation } from '../src/sitemap-generator/IOrganisation';
+export { IRankingApiClient } from '../src/sitemap-generator/IRankingApiClient';
+export { ISearchApiClient } from '../src/sitemap-generator/ISearchApiClient';
+export { ISitemapUrlGeneratorManager } from '../src/sitemap-generator/ISitemapUrlGeneratorManager';
+export { OrganisationsSitemapUrlGeneratorManager } from '../src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
+export { ScholarshipsSitemapUrlGeneratorManager } from '../src/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
+export { ProgrammesSitemapUrlGeneratorManager } from '../src/sitemap-generator/ProgrammesSitemapUrlGeneratorManager';
+export { FilterCombinations } from '../src/enums/FilterCombinations';
+export { ISitemapUrlGenerator } from '../src/common/ISitemapUrlGenerator';
+export { FilterKeyValuesMap } from '../src/common/FilterKeyValuesMap';
+export { IPresenter } from '../src/common';
+export { IProgrammeSitemapUrlGenerator } from '../src/programmes/types/IProgrammeSitemapUrlGenerator';

package/dist/sitemap-generator-seo/index.js

@@ -1,5 +1,4 @@
-import { OrganisationsSitemapUrlGeneratorManager } from '../src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
-import { ScholarshipsSitemapUrlGeneratorManager } from '../src/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
-import { ProgrammesSitemapUrlGeneratorManager } from '../src/sitemap-generator/ProgrammesSitemapUrlGeneratorManager';
-import { FilterCombinations } from '../src/enums/FilterCombinations';
-export { OrganisationsSitemapUrlGeneratorManager, ScholarshipsSitemapUrlGeneratorManager, ProgrammesSitemapUrlGeneratorManager, FilterCombinations };
+export { OrganisationsSitemapUrlGeneratorManager } from '../src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
+export { ScholarshipsSitemapUrlGeneratorManager } from '../src/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
+export { ProgrammesSitemapUrlGeneratorManager } from '../src/sitemap-generator/ProgrammesSitemapUrlGeneratorManager';
+export { FilterCombinations } from '../src/enums/FilterCombinations';

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

@@ -0,0 +1,3 @@
+export interface IRankingApiClient {
+    getFacets(): Promise<string[]>;
+}

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

@@ -1,7 +1,5 @@
 import { IDependencies } from '../common/IDependencies';
 import { ISearchApiClient } from '../sitemap-generator/ISearchApiClient';
-import { IOrganisationsClient } from '../sitemap-generator/IOrganisationsClient';
 export interface ISitemapDependencies extends IDependencies {
     searchApiClient: ISearchApiClient;
-    organisationsClient: IOrganisationsClient;
 }

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

@@ -1,7 +1,7 @@
 import { FilterCombinations } from '../enums/FilterCombinations';
 import { IRule } from './IRule';
 export interface ISitemapUrlGenerator {
-    filterCombination: FilterCombinations;
+    readonly filterCombination: FilterCombinations;
     generateSitemapUrls(): Promise<string[]>;
     getAllRules(): IRule[];
 }

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

@@ -2,5 +2,4 @@ import { BaseFilterKeyValueRule } from '../../common/rules/BaseFilterKeyValueRul
 export declare class OnlineAttendanceRule extends BaseFilterKeyValueRule {
     constructor();
     getName(): string;
-    getDescription(): string;
 }

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

@@ -8,7 +8,4 @@ export class OnlineAttendanceRule extends BaseFilterKeyValueRule {
     getName() {
         return 'OnlineAttendanceRule';
     }
-    getDescription() {
-        return 'Indexable if attendance is online';
-    }
 }

package/dist/src/organisations/types/IOrganisationsSitemapDependencies.d.ts

@@ -1,7 +1,9 @@
 import { ISitemapDependencies } from '../../common/ISitemapDependencies';
 import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
 import { PortalType } from '@studyportals/domain-client';
+import { IOrganisationsClient } from '../../sitemap-generator/IOrganisationsClient';
 export interface IOrganisationsSitemapDependencies extends ISitemapDependencies {
+    organisationsClient: IOrganisationsClient;
     portalType: PortalType;
     rankingApiClient: IRankingApiClient;
 }

package/dist/src/presenters/DegreePresenter.d.ts

@@ -0,0 +1,11 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class DegreePresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): DegreePresenter;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/DegreePresenter.js

@@ -0,0 +1,23 @@
+import { DegreeTypeFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class DegreePresenter {
+    filterKey = FilterKey.DEGREE_TYPE;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = Object.values(DegreeTypeFilterOptionValue).map((degree) => {
+            return {
+                id: degree,
+                path: degree
+            };
+        });
+    }
+    static getInstance() {
+        if (!DegreePresenter.instance) {
+            DegreePresenter.instance = new DegreePresenter();
+        }
+        return DegreePresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/DurationPresenter.d.ts

@@ -0,0 +1,13 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class DurationPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): DurationPresenter;
+    private generatePaths;
+    private formatDurationPath;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/DurationPresenter.js

@@ -0,0 +1,46 @@
+import { DurationFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class DurationPresenter {
+    filterKey = FilterKey.DURATION;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!DurationPresenter.instance) {
+            DurationPresenter.instance = new DurationPresenter();
+        }
+        return DurationPresenter.instance;
+    }
+    generatePaths() {
+        const indexableDurations = [
+            DurationFilterOptionValue.ONE_YEAR,
+            DurationFilterOptionValue.TWO_YEARS,
+            DurationFilterOptionValue.THREE_YEARS,
+            DurationFilterOptionValue.FOUR_YEARS
+        ];
+        return indexableDurations.map((duration) => {
+            return {
+                id: duration,
+                path: this.formatDurationPath(duration)
+            };
+        });
+    }
+    formatDurationPath(duration) {
+        switch (duration) {
+            case DurationFilterOptionValue.ONE_YEAR:
+                return '1-year';
+            case DurationFilterOptionValue.TWO_YEARS:
+                return '2-years';
+            case DurationFilterOptionValue.THREE_YEARS:
+                return '3-years';
+            case DurationFilterOptionValue.FOUR_YEARS:
+                return '4-years';
+            default:
+                return duration.toLowerCase().replace(/_/g, '-');
+        }
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/EducationalFormPresenter.d.ts

@@ -0,0 +1,12 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class EducationalFormPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): EducationalFormPresenter;
+    private formatEducationalFormPath;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/EducationalFormPresenter.js

@@ -0,0 +1,32 @@
+import { EducationalFormFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class EducationalFormPresenter {
+    filterKey = FilterKey.EDUCATIONAL_FORM;
+    static instance;
+    fragments;
+    constructor() {
+        const indexableEducationalForms = [
+            EducationalFormFilterOptionValue.ACADEMIC_COURSE,
+            EducationalFormFilterOptionValue.SUMMER_SCHOOL,
+            EducationalFormFilterOptionValue.SEMESTER_STUDY_ABROAD,
+            EducationalFormFilterOptionValue.SKILL_PROFESSIONAL_COURSE
+        ];
+        this.fragments = indexableEducationalForms.map((form) => {
+            return {
+                id: form,
+                path: this.formatEducationalFormPath(form)
+            };
+        });
+    }
+    static getInstance() {
+        if (!EducationalFormPresenter.instance) {
+            EducationalFormPresenter.instance = new EducationalFormPresenter();
+        }
+        return EducationalFormPresenter.instance;
+    }
+    formatEducationalFormPath(form) {
+        return form.toLowerCase().replace(/_/g, '-');
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/FormatPresenter.d.ts

@@ -0,0 +1,11 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class FormatPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): FormatPresenter;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/FormatPresenter.js

@@ -0,0 +1,24 @@
+import { FormatFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class FormatPresenter {
+    filterKey = FilterKey.ATTENDANCE;
+    static instance;
+    fragments;
+    constructor() {
+        // Part-time is the only indexable format according to PartTimeFormatRule
+        this.fragments = [
+            {
+                id: FormatFilterOptionValue.PART_TIME,
+                path: 'part-time'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!FormatPresenter.instance) {
+            FormatPresenter.instance = new FormatPresenter();
+        }
+        return FormatPresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/SpecialProgrammesPresenter.d.ts

@@ -0,0 +1,11 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class SpecialProgrammesPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): SpecialProgrammesPresenter;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/SpecialProgrammesPresenter.js

@@ -0,0 +1,27 @@
+import { SpecialProgrammesFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class SpecialProgrammesPresenter {
+    filterKey = FilterKey.SPECIAL_PROGRAMMES;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = [
+            {
+                id: SpecialProgrammesFilterOptionValue.JOINT_PROGRAMMES,
+                path: 'joint-programmes'
+            },
+            {
+                id: SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS,
+                path: 'erasmus-mundus'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!SpecialProgrammesPresenter.instance) {
+            SpecialProgrammesPresenter.instance = new SpecialProgrammesPresenter();
+        }
+        return SpecialProgrammesPresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/TuitionFeePresenter.d.ts

@@ -0,0 +1,11 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class TuitionFeePresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): TuitionFeePresenter;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/TuitionFeePresenter.js

@@ -0,0 +1,23 @@
+import { TuitionFeeFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class TuitionFeePresenter {
+    filterKey = FilterKey.TUITION_FEE;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = [
+            {
+                id: TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED,
+                path: 'affordable'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!TuitionFeePresenter.instance) {
+            TuitionFeePresenter.instance = new TuitionFeePresenter();
+        }
+        return TuitionFeePresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

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

@@ -1,7 +1,8 @@
-import { IRule } from '../common/IRule';
 import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
-import { IProgrammesSeoDependencies } from './IProgrammesSeoDependencies';
-export declare abstract class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IProgrammesSeoDependencies> {
-    protected readonly rules: IRule[];
-    protected get baseRules(): IRule[];
+import { IProgrammeSeoDependencies } from './types/IProgrammeSeoDependencies';
+import { IProgrammeSitemapUrlGenerator } from './types/IProgrammeSitemapUrlGenerator';
+import { FilterKey } from '@studyportals/search-filters';
+export declare abstract class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IProgrammeSeoDependencies> implements IProgrammeSitemapUrlGenerator {
+    abstract readonly filterKeys: FilterKey[];
+    protected initateBaseRules(): void;
 }

package/dist/src/programmes/ProgrammesBaseIndexabilityPolicy.js

@@ -3,8 +3,19 @@ import { IndexablePageNumberRule } from './rules/IndexablePageNumberRule';
 import { NotDistanceLearningPortalRule } from './rules/NotDistanceLearningPortalRule';
 import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
 export class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
-    rules = [new AtLeastSevenResultsRule(), new IndexablePageNumberRule(), new NotDistanceLearningPortalRule()];
-    get baseRules() {
-        return this.rules;
+    initateBaseRules() {
+        const indexablePageNumberRule = new IndexablePageNumberRule();
+        let atLeastSevenResultsRule;
+        let notDistanceLearningPortalRule;
+        if (super.isSitemapUrlGeneratorDependencies()) {
+            const dependencies = this.dependencies;
+            atLeastSevenResultsRule = new AtLeastSevenResultsRule(dependencies.searchApiClient);
+            notDistanceLearningPortalRule = new NotDistanceLearningPortalRule(dependencies.portalType);
+        }
+        else {
+            atLeastSevenResultsRule = new AtLeastSevenResultsRule();
+            notDistanceLearningPortalRule = new NotDistanceLearningPortalRule();
+        }
+        this.rules.push(atLeastSevenResultsRule, notDistanceLearningPortalRule, indexablePageNumberRule);
     }
 }

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

@@ -3,7 +3,7 @@ import { ISeoIndexabilityPolicy } from '../common/ISeoIndexabilityPolicy';
 import { ISeoInfoBase } from '../common/ISeoInfoBase';
 import { ISeoFilterState } from '../common/ISeoFilterState';
 import { ISearchIndexabilityManager } from '../common/ISearchIndexabilityManager';
-import { IProgrammeSearchApplicationState } from './IProgrammeSearchApplicationState';
+import { IProgrammeSearchApplicationState } from './types/IProgrammeSearchApplicationState';
 export declare class SearchIndexabilityManager implements ISearchIndexabilityManager {
     private policies;
     constructor(portalType: PortalType, seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: IProgrammeSearchApplicationState);

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

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

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

@@ -3,17 +3,34 @@ import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedR
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AreaPresenter } from '../../presenters/AreaPresenter';
 export class Area extends ProgrammesBaseIndexabilityPolicy {
     name = 'Area Policy';
     description = 'Controls indexing of pages filtered by geographic areas.';
+    filterKeys = [FilterKey.AREA];
     rules = [
-        ...this.baseRules,
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
         new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            const filterKeyValues = new Map([
+                [FilterKey.AREA, [area.id]],
+                [FilterKey.COUNTRY, [area.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(area.path);
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.AREA;

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

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

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

@@ -4,17 +4,31 @@ import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValue
 import { FilterCombinations } from '../../enums/FilterCombinations';
 import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
 import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 export class Attendance extends ProgrammesBaseIndexabilityPolicy {
     name = 'Attendance Policy';
     description = 'Determines indexing rules for pages filtered by study format (online, on-campus, etc.).';
+    filterKeys = [FilterKey.DELIVERY_METHOD];
     rules = [
-        ...this.baseRules,
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
         new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD]),
         new OnlineAttendanceRule()
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(attendance.path);
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.ATTENDANCE;

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

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

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

@@ -5,19 +5,40 @@ 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';
 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.';
+    filterKeys = [FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
     rules = [
-        ...this.baseRules,
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
         new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
         new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE]),
         new IndexableDegreeRule(),
         new OnlineAttendanceRule()
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            for (const degree of degreeFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                    [FilterKey.DEGREE_TYPE, [degree.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(`${attendance.path}/${degree.path}`);
+                }
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.ATTENDANCE_DEGREE;

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

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