@studyportals/fawkes 4.0.3-0 → 5.0.0

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

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

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

@@ -1,7 +1,11 @@
 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 { SitemapUrlGeneratorManager } from '../src/sitemap-generator/SitemapUrlGeneratorManager';
+import { OrganisationsSitemapUrlGeneratorManager } from '../src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
+import { ScholarshipsSitemapUrlGeneratorManager } from '../src/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
 import { FilterCombinations } from '../src/enums/FilterCombinations';
-export { IOrganisationsClient, IOrganisation, ISearchApiClient, ISitemapUrlGeneratorManager, SitemapUrlGeneratorManager, FilterCombinations };
+import { FilterKeyValuesMap } from '../src/common/FilterKeyValuesMap';
+import { IPresenter } from '../src/common';
+export { IOrganisationsClient, IOrganisation, IRankingApiClient, ISearchApiClient, ISitemapUrlGeneratorManager, OrganisationsSitemapUrlGeneratorManager, ScholarshipsSitemapUrlGeneratorManager, FilterCombinations, FilterKeyValuesMap, IPresenter };

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

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

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

@@ -0,0 +1,6 @@
+import { IFragment } from "../presenters/fragments/IFragment";
+import { FilterKey } from "@studyportals/search-filters";
+export interface IPresenter {
+    readonly filterKey: FilterKey;
+    getFragments(): IFragment[];
+}

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

@@ -2,3 +2,4 @@ export * from './ISeoInfoBase';
 export * from './ISeoFilterState';
 export * from './ISearchApplicationState';
 export * from './ISearchIndexabilityManager';
+export * from './IPresenter';

package/dist/src/common/index.js

@@ -2,3 +2,4 @@ export * from './ISeoInfoBase';
 export * from './ISeoFilterState';
 export * from './ISearchApplicationState';
 export * from './ISearchIndexabilityManager';
+export * from './IPresenter';

package/dist/src/common/policies/BaseSeoIndexabilityPolicy.d.ts

@@ -4,7 +4,7 @@ import { IRule } from '../IRule';
 import { FilterKeyValuesMap } from '../FilterKeyValuesMap';
 import { ISeoIndexabilityPolicy } from '../ISeoIndexabilityPolicy';
 import { ISitemapUrlGenerator } from '../ISitemapUrlGenerator';
-import { FilterCombinations } from '../../enums/FilterCombinations';
+import { FilterCombinations } from '../../../sitemap-generator-seo';
 export declare abstract class BaseSeoIndexabilityPolicy<TDependencies extends IDependencies> implements ISeoIndexabilityPolicy, ISitemapUrlGenerator {
     protected readonly dependencies: TDependencies;
     protected abstract readonly rules: IRule[];
@@ -16,6 +16,6 @@ export declare abstract class BaseSeoIndexabilityPolicy<TDependencies extends ID
     protected isIndexable(): Promise<boolean>;
     protected checkRulesForSearch(dependencies: ISearchDependencies): Promise<boolean>;
     protected checkRulesForSitemap(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
-    private isIndexabilityPolicyDependencies;
-    private isSitemapUrlGeneratorDependencies;
+    protected isIndexabilityPolicyDependencies(): boolean;
+    protected isSitemapUrlGeneratorDependencies(): boolean;
 }

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

@@ -3,35 +3,26 @@ export declare enum FilterCombinations {
     AREA_ATTENDANCE = "areaAttendance",
     AREA_DISCIPLINE = "areaDiscipline",
     COUNTRY = "country",
-    COUNTRY_DEGREE = "countryDegree",
-    COUNTRY_DURATION = "countryDuration",
-    COUNTRY_FORMAT = "countryFormat",
-    COUNTRY_TUITION_FEE = "countryTuitionFee",
-    COUNTRY_EDUCATIONAL_FORM = "countryEducationalForm",
-    COUNTRY_ATTENDANCE_DEGREE = "countryAttendanceDegree",
-    COUNTRY_DURATION_DEGREE = "countryDurationDegree",
     DISCIPLINE_AREA = "disciplineArea",
     DISCIPLINE_ATTENDANCE = "disciplineAttendance",
     DISCIPLINE_COUNTRY = "disciplineCountry",
-    DISCIPLINE_CONTINENT = "disciplineContinent",
-    DISCIPLINE_DEGREE = "disciplineDegree",
-    DISCIPLINE_DURATION = "disciplineDuration",
-    DISCIPLINE_FORMAT = "disciplineFormat",
-    DISCIPLINE_TUITION_FEE = "disciplineTuitionFee",
-    DISCIPLINE_EDUCATIONAL_FORM = "disciplineEducationalForm",
-    DISCIPLINE_TUITION_FEE_ATTENDANCE = "disciplineTuitionFeeAttendance",
-    DISCIPLINE_COUNTRY_EDUCATIONAL_FORM = "disciplineCountryEducationalForm",
-    DISCIPLINE_COUNTRY_DEGREE = "disciplineCountryDegree",
     DISCIPLINE = "discipline",
     UNFILTERED = "unfiltered",
     UNIVERSITY_COUNTRY = "universityCountry",
     ATTENDANCE_DISCIPLINE = "attendancedDiscipline",
-    ATTENDANCE_DEGREE = "attendanceDegree",
     CONTINENT_ATTENDANCE = "continentAttendance",
     COUNTRY_ATTENDANCE = "countryAttendance",
     ATTENDANCE = "attendance",
     CONTINENT = "continent",
-    CONTINENT_TUITION_FEE = "continentTuitionFee",
-    TUITION_FEE = "tuitionFee",
-    SPECIAL_PROGRAMMES = "specialProgrammes"
+    RANKED_AREA = "rankedArea",
+    RANKED_AREA_DISCIPLINE = "rankedAreaDiscipline",
+    RANKED_ATTENDANCE = "rankedAttendance",
+    RANKED_ATTENDANCE_DISCIPLINE = "rankedAttendancedDiscipline",
+    RANKED_CONTINENT = "rankedContinent",
+    RANKED_CONTINENT_ATTENDANCE = "rankedContinentAttendance",
+    RANKED_COUNTRY = "rankedCountry",
+    RANKED_COUNTRY_ATTENDANCE = "rankedCountryAttendance",
+    RANKED_DISCIPLINE_COUNTRY = "rankedDisciplineCountry",
+    RANKED_DISCIPLINE = "rankedDiscipline",
+    RANKED_UNFILTERED = "rankedUnfiltered"
 }

package/dist/src/enums/FilterCombinations.js

@@ -4,35 +4,26 @@ export var FilterCombinations;
     FilterCombinations["AREA_ATTENDANCE"] = "areaAttendance";
     FilterCombinations["AREA_DISCIPLINE"] = "areaDiscipline";
     FilterCombinations["COUNTRY"] = "country";
-    FilterCombinations["COUNTRY_DEGREE"] = "countryDegree";
-    FilterCombinations["COUNTRY_DURATION"] = "countryDuration";
-    FilterCombinations["COUNTRY_FORMAT"] = "countryFormat";
-    FilterCombinations["COUNTRY_TUITION_FEE"] = "countryTuitionFee";
-    FilterCombinations["COUNTRY_EDUCATIONAL_FORM"] = "countryEducationalForm";
-    FilterCombinations["COUNTRY_ATTENDANCE_DEGREE"] = "countryAttendanceDegree";
-    FilterCombinations["COUNTRY_DURATION_DEGREE"] = "countryDurationDegree";
     FilterCombinations["DISCIPLINE_AREA"] = "disciplineArea";
     FilterCombinations["DISCIPLINE_ATTENDANCE"] = "disciplineAttendance";
     FilterCombinations["DISCIPLINE_COUNTRY"] = "disciplineCountry";
-    FilterCombinations["DISCIPLINE_CONTINENT"] = "disciplineContinent";
-    FilterCombinations["DISCIPLINE_DEGREE"] = "disciplineDegree";
-    FilterCombinations["DISCIPLINE_DURATION"] = "disciplineDuration";
-    FilterCombinations["DISCIPLINE_FORMAT"] = "disciplineFormat";
-    FilterCombinations["DISCIPLINE_TUITION_FEE"] = "disciplineTuitionFee";
-    FilterCombinations["DISCIPLINE_EDUCATIONAL_FORM"] = "disciplineEducationalForm";
-    FilterCombinations["DISCIPLINE_TUITION_FEE_ATTENDANCE"] = "disciplineTuitionFeeAttendance";
-    FilterCombinations["DISCIPLINE_COUNTRY_EDUCATIONAL_FORM"] = "disciplineCountryEducationalForm";
-    FilterCombinations["DISCIPLINE_COUNTRY_DEGREE"] = "disciplineCountryDegree";
     FilterCombinations["DISCIPLINE"] = "discipline";
     FilterCombinations["UNFILTERED"] = "unfiltered";
     FilterCombinations["UNIVERSITY_COUNTRY"] = "universityCountry";
     FilterCombinations["ATTENDANCE_DISCIPLINE"] = "attendancedDiscipline";
-    FilterCombinations["ATTENDANCE_DEGREE"] = "attendanceDegree";
     FilterCombinations["CONTINENT_ATTENDANCE"] = "continentAttendance";
     FilterCombinations["COUNTRY_ATTENDANCE"] = "countryAttendance";
     FilterCombinations["ATTENDANCE"] = "attendance";
     FilterCombinations["CONTINENT"] = "continent";
-    FilterCombinations["CONTINENT_TUITION_FEE"] = "continentTuitionFee";
-    FilterCombinations["TUITION_FEE"] = "tuitionFee";
-    FilterCombinations["SPECIAL_PROGRAMMES"] = "specialProgrammes";
+    FilterCombinations["RANKED_AREA"] = "rankedArea";
+    FilterCombinations["RANKED_AREA_DISCIPLINE"] = "rankedAreaDiscipline";
+    FilterCombinations["RANKED_ATTENDANCE"] = "rankedAttendance";
+    FilterCombinations["RANKED_ATTENDANCE_DISCIPLINE"] = "rankedAttendancedDiscipline";
+    FilterCombinations["RANKED_CONTINENT"] = "rankedContinent";
+    FilterCombinations["RANKED_CONTINENT_ATTENDANCE"] = "rankedContinentAttendance";
+    FilterCombinations["RANKED_COUNTRY"] = "rankedCountry";
+    FilterCombinations["RANKED_COUNTRY_ATTENDANCE"] = "rankedCountryAttendance";
+    FilterCombinations["RANKED_DISCIPLINE_COUNTRY"] = "rankedDisciplineCountry";
+    FilterCombinations["RANKED_DISCIPLINE"] = "rankedDiscipline";
+    FilterCombinations["RANKED_UNFILTERED"] = "rankedUnfiltered";
 })(FilterCombinations || (FilterCombinations = {}));

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.d.ts

@@ -6,6 +6,8 @@ export declare abstract class OrganisationsSeoIndexabilityPolicy extends BaseSeo
     protected readonly indexablePortalTypes: PortalType[];
     protected abstract readonly sortingOption: SortingOptions;
     constructor(dependencies: IOrganisationsSeoDependencies);
+    generateSitemapUrls(): Promise<string[]>;
     protected isIndexable(): Promise<boolean>;
+    protected getPathWithSortingOption(path: string): string;
     private matchesSortingOption;
 }

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.js

@@ -5,6 +5,12 @@ export class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolic
     constructor(dependencies) {
         super(dependencies);
     }
+    async generateSitemapUrls() {
+        if (this.indexablePortalTypes.includes(this.dependencies.portalType)) {
+            return super.generateSitemapUrls();
+        }
+        return [];
+    }
     async isIndexable() {
         const isIndexable = await super.isIndexable();
         if (!isIndexable) {
@@ -12,6 +18,9 @@ export class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolic
         }
         return this.indexablePortalTypes.includes(this.dependencies.portalType) && this.matchesSortingOption();
     }
+    getPathWithSortingOption(path) {
+        return path;
+    }
     matchesSortingOption() {
         const dependencies = this.dependencies;
         return dependencies.sortingState.getSelectedOption() === this.sortingOption;

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.d.ts

@@ -0,0 +1,7 @@
+import { SortingOptions } from '../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabilityPolicy';
+export declare abstract class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
+    protected readonly sortingOption: SortingOptions;
+    protected addRankedResultsCountRule(): void;
+    protected getPathWithSortingOption(path: string): string;
+}

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.js

@@ -0,0 +1,20 @@
+import { SortingOptions } from '../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabilityPolicy';
+import { AtLeastTwoRankedResultsRule } from '../rules/AtLeastTwoRankedResultsRule';
+export class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
+    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+    addRankedResultsCountRule() {
+        let rankedResultsCountRule;
+        if (super.isSitemapUrlGeneratorDependencies()) {
+            const dependencies = this.dependencies;
+            rankedResultsCountRule = new AtLeastTwoRankedResultsRule(dependencies.rankingApiClient);
+        }
+        else {
+            rankedResultsCountRule = new AtLeastTwoRankedResultsRule();
+        }
+        this.rules.push(rankedResultsCountRule);
+    }
+    getPathWithSortingOption(path) {
+        return 'rankings/' + path;
+    }
+}

package/dist/src/organisations/policies/our-picks/Area.js

@@ -4,6 +4,7 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
 export class Area extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
@@ -12,7 +13,19 @@ export class Area extends OrganisationsSeoIndexabilityPolicy {
         new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
     ];
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        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(this.getPathWithSortingOption(area.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.AREA;

package/dist/src/organisations/policies/our-picks/AreaAttendance.js

@@ -6,6 +6,8 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
 import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
 export class AreaAttendance extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
@@ -17,7 +19,23 @@ export class AreaAttendance extends OrganisationsSeoIndexabilityPolicy {
         new OnlineAttendanceRule()
     ];
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${area.path}`));
+                }
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.AREA_ATTENDANCE;

package/dist/src/organisations/policies/our-picks/Attendance.js

@@ -5,6 +5,7 @@ import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/polic
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
 import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
 export class Attendance extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
@@ -13,7 +14,16 @@ export class Attendance extends OrganisationsSeoIndexabilityPolicy {
         new OnlineAttendanceRule()
     ];
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        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(this.getPathWithSortingOption(attendance.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.ATTENDANCE;

package/dist/src/organisations/policies/our-picks/Continent.d.ts

@@ -6,6 +6,6 @@ import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelect
 export declare class Continent extends OrganisationsSeoIndexabilityPolicy {
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/our-picks/Continent.js

@@ -4,16 +4,26 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ContinentPresenter } from '../../../presenters/ContinentPresenter';
 export class Continent extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
         new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
     ];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.CONTINENT;
     }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const continent of continentFragments) {
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continent.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(continent.path));
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/Country.d.ts

@@ -6,6 +6,6 @@ import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelect
 export declare class Country extends OrganisationsSeoIndexabilityPolicy {
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/our-picks/Country.js

@@ -4,13 +4,23 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
 export class Country extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [new SingleValueSelectedForFilterRule(FilterKey.COUNTRY), new OnlyFiltersSelectedRule([FilterKey.COUNTRY])];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.COUNTRY;
     }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            const filterKeyValues = new Map([[FilterKey.COUNTRY, [country.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(country.path));
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/CountryAttendance.d.ts

@@ -8,6 +8,6 @@ import { SearchVolumeCountriesAttendanceRule } from '../../../organisations/rule
 export declare class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | SearchVolumeCountriesAttendanceRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/our-picks/CountryAttendance.js

@@ -6,6 +6,8 @@ import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleVa
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
 import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
 import { SearchVolumeCountriesAttendanceRule } from '../../../organisations/rules/SearchVolumeCountriesAttendanceRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
 export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
@@ -15,10 +17,25 @@ export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
         new SearchVolumeCountriesAttendanceRule(),
         new OnlineAttendanceRule()
     ];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.COUNTRY_ATTENDANCE;
     }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.COUNTRY, [country.id]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
+                }
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/Unfiltered.js

@@ -5,8 +5,8 @@ import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRu
 export class Unfiltered extends OrganisationsSeoIndexabilityPolicy {
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [new NoFiltersSelectedRule()];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        return Promise.resolve([this.getPathWithSortingOption('')]);
     }
     get filterCombination() {
         return FilterCombinations.UNFILTERED;

package/dist/src/organisations/policies/ranked/RankedArea.d.ts

@@ -1,12 +1,11 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-export declare class RankedArea extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AtLeastTwoRankedResultsRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

package/dist/src/organisations/policies/ranked/RankedArea.js

@@ -1,22 +1,35 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-export class RankedArea extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
-        new AtLeastTwoRankedResultsRule()
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
     ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        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(this.getPathWithSortingOption(area.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
-        return FilterCombinations.AREA;
+        return FilterCombinations.RANKED_AREA;
     }
 }

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.d.ts

@@ -1,13 +1,12 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export declare class RankedAreaDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AtLeastTwoRankedResultsRule | SearchVolumeAreasDisciplineRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeAreasDisciplineRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.js

@@ -1,25 +1,43 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export class RankedAreaDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
         new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
         new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY, FilterKey.DISCIPLINES]),
-        new SearchVolumeAreasDisciplineRule(),
-        new AtLeastTwoRankedResultsRule()
+        new SearchVolumeAreasDisciplineRule()
     ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
     get filterCombination() {
-        return FilterCombinations.AREA_DISCIPLINE;
+        return FilterCombinations.RANKED_AREA_DISCIPLINE;
     }
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${area.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
     }
 }

package/dist/src/organisations/policies/ranked/RankedAttendance.d.ts

@@ -1,13 +1,12 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export declare class RankedAttendance extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | AtLeastTwoRankedResultsRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }