@studyportals/fawkes 8.2.4-9 → 8.3.1-0

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

@@ -3,4 +3,5 @@ import { FilterKey } from '@studyportals/search-filters/server-side';
 export interface IPresenter {
     readonly filterKey: FilterKey;
     getFragments(): IFragment[];
+    getFragmentsAsync?(): Promise<IFragment[]>;
 }

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

@@ -1,9 +1,10 @@
 export declare enum FilterCombinations {
-    CITY = "city",
     AREA = "area",
     AREA_ATTENDANCE = "areaAttendance",
     AREA_DISCIPLINE = "areaDiscipline",
     COUNTRY = "country",
+    COUNTRY_CITY = "countryCity",
+    COUNTRY_AREA_CITY = "countryAreaCity",
     DEGREE = "degree",
     DURATION = "duration",
     FORMAT = "format",

package/dist/src/enums/FilterCombinations.js

@@ -1,10 +1,11 @@
 export var FilterCombinations;
 (function (FilterCombinations) {
-    FilterCombinations["CITY"] = "city";
     FilterCombinations["AREA"] = "area";
     FilterCombinations["AREA_ATTENDANCE"] = "areaAttendance";
     FilterCombinations["AREA_DISCIPLINE"] = "areaDiscipline";
     FilterCombinations["COUNTRY"] = "country";
+    FilterCombinations["COUNTRY_CITY"] = "countryCity";
+    FilterCombinations["COUNTRY_AREA_CITY"] = "countryAreaCity";
     FilterCombinations["DEGREE"] = "degree";
     FilterCombinations["DURATION"] = "duration";
     FilterCombinations["FORMAT"] = "format";

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

@@ -3,11 +3,12 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ExcludeByIdForCitiesRule } from '../../../organisations/rules/ExcludeByIdForCitiesRule';
 export declare class CountryAreaCity extends OrganisationsSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | ExcludeByIdForCitiesRule)[];
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

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

@@ -4,6 +4,8 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { CityPresenter } from '../../../presenters/CityPresenter';
+import { ExcludeByIdForCitiesRule } from '../../../organisations/rules/ExcludeByIdForCitiesRule';
 export class CountryAreaCity extends OrganisationsSeoIndexabilityPolicy {
     name = 'Country Area City Policy';
     description = 'Controls indexing of pages filtered by geographic cities and areas, ensuring only SEO-valuable regional content with sufficient search volume is indexed.';
@@ -12,14 +14,33 @@ export class CountryAreaCity extends OrganisationsSeoIndexabilityPolicy {
         new SingleValueSelectedForFilterRule(FilterKey.CITY),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
-        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY, FilterKey.AREA])
+        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY, FilterKey.AREA]),
+        new ExcludeByIdForCitiesRule(FilterKey.CITY)
     ];
     async generateUrls() {
-        // NOTE: Since we have a mechanism for url calculation in CountryCity policy, that covers this scenario. For that reason this method is left unimplemented.
-        // In any case that you delete the CountryCity policy, you should implement this method to avoid losing functionality.
-        return await new Promise((resolve) => resolve([]));
+        const cityFragments = await CityPresenter
+            .getInstance(this.dependencies.searchApiClient)
+            .getFragments();
+        const paths = [];
+        const filteredFragmentsForCountryAreaCity = cityFragments.filter(city => city.areaId !== null && city.areaId !== undefined);
+        for (const city of filteredFragmentsForCountryAreaCity) {
+            const areaId = city.areaId?.toString() || '';
+            if (areaId === '') {
+                continue;
+            }
+            const filterKeyValues = new Map([
+                [FilterKey.CITY, [city.id]],
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [city.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(city.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
-        return FilterCombinations.CITY;
+        return FilterCombinations.COUNTRY_AREA_CITY;
     }
 }

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

@@ -3,11 +3,12 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ExcludeByIdForCitiesRule } from '../../../organisations/rules/ExcludeByIdForCitiesRule';
 export declare class CountryCity extends OrganisationsSeoIndexabilityPolicy {
     readonly name: string;
     readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
-    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | ExcludeByIdForCitiesRule)[];
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

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

@@ -5,6 +5,7 @@ import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/polic
 import { CityPresenter } from '../../../presenters/CityPresenter';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ExcludeByIdForCitiesRule } from '../../../organisations/rules/ExcludeByIdForCitiesRule';
 export class CountryCity extends OrganisationsSeoIndexabilityPolicy {
     name = 'Country City Policy';
     description = 'Controls indexing of pages filtered by geographic cities, ensuring only SEO-valuable regional content with sufficient search volume is indexed.';
@@ -12,14 +13,16 @@ export class CountryCity extends OrganisationsSeoIndexabilityPolicy {
     baseRules = [
         new SingleValueSelectedForFilterRule(FilterKey.CITY),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY])
+        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY]),
+        new ExcludeByIdForCitiesRule(FilterKey.CITY)
     ];
     async generateUrls() {
         const cityFragments = await CityPresenter
             .getInstance(this.dependencies.searchApiClient)
             .getFragments();
         const paths = [];
-        for (const city of cityFragments) {
+        const filteredFragmentsForCountryCity = cityFragments.filter(city => city.areaId === null || city.areaId === undefined);
+        for (const city of filteredFragmentsForCountryCity) {
             const filterKeyValues = new Map([
                 [FilterKey.CITY, [city.id]],
                 [FilterKey.COUNTRY, [city.countryId]]
@@ -32,6 +35,6 @@ export class CountryCity extends OrganisationsSeoIndexabilityPolicy {
         return paths;
     }
     get filterCombination() {
-        return FilterCombinations.CITY;
+        return FilterCombinations.COUNTRY_CITY;
     }
 }

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

@@ -0,0 +1,11 @@
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { RankedOrganisationsSeoIndexabilityPolicy } from "../RankedOrganisationsSeoIndexabilityPolicy";
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+export declare class RankedCountryAreaCity extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,42 @@
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { FilterKey } from "@studyportals/search-filters/server-side";
+import { RankedOrganisationsSeoIndexabilityPolicy } from "../RankedOrganisationsSeoIndexabilityPolicy";
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { CityPresenter } from "../../../presenters/CityPresenter";
+export class RankedCountryAreaCity extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Country Area City Policy';
+    description = 'Manages indexability of ranking-sorted country and area-specific city pages, applying rules to prioritize regions where quality-based sorting adds search value.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CITY),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY])
+    ];
+    async generateUrls() {
+        const cityFragments = await CityPresenter
+            .getInstance(this.dependencies.searchApiClient)
+            .getFragmentsAsync();
+        const paths = [];
+        console.warn(`Total city fragments fetched: ${cityFragments.length}`);
+        const filteredFragmentsForCountryAreaCity = cityFragments.filter(city => city.areaId !== null && city.areaId !== undefined);
+        for (const city of filteredFragmentsForCountryAreaCity) {
+            const areaId = city.areaId?.toString() || '';
+            if (areaId === '') {
+                continue;
+            }
+            const filterKeyValues = new Map([
+                [FilterKey.CITY, [city.id]],
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [city.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(city.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_COUNTRY_AREA_CITY;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { RankedOrganisationsSeoIndexabilityPolicy } from "../RankedOrganisationsSeoIndexabilityPolicy";
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+export declare class RankedCountryCity extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,36 @@
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { FilterKey } from "@studyportals/search-filters/server-side";
+import { RankedOrganisationsSeoIndexabilityPolicy } from "../RankedOrganisationsSeoIndexabilityPolicy";
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { CityPresenter } from "../../../presenters/CityPresenter";
+export class RankedCountryCity extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Country City Policy';
+    description = 'Manages indexability of ranking-sorted country and city-specific pages, applying rules to prioritize regions where quality-based sorting adds search value.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CITY),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.CITY, FilterKey.COUNTRY])
+    ];
+    async generateUrls() {
+        const cityFragments = await CityPresenter
+            .getInstance(this.dependencies.searchApiClient)
+            .getFragmentsAsync();
+        const paths = [];
+        const filteredFragmentsForCountryCity = cityFragments.filter(city => city.areaId === null || city.areaId === undefined);
+        for (const city of filteredFragmentsForCountryCity) {
+            const filterKeyValues = new Map([
+                [FilterKey.CITY, [city.id]],
+                [FilterKey.COUNTRY, [city.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(city.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_COUNTRY_CITY;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { IRule } from "../../common/IRule";
+import { ISearchDependencies } from "../../common/ISearchDependencies";
+import { FilterKey } from "@studyportals/search-filters/server-side";
+import { FilterKeyValuesMap } from "../../../sitemap-generator-seo";
+export declare class ExcludeByIdForCitiesRule implements IRule {
+    private readonly filterKey;
+    private excludedIds;
+    constructor(filterKey: FilterKey);
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,31 @@
+import { FilterKey } from "@studyportals/search-filters/server-side";
+export class ExcludeByIdForCitiesRule {
+    filterKey;
+    excludedIds;
+    constructor(filterKey) {
+        this.filterKey = filterKey;
+        // Exclude city with ID 532 (Washington D.C.)
+        this.excludedIds = ['532'];
+    }
+    async forSearch(dependencies) {
+        const selectedCities = dependencies.seoInfoBase.getFilterOptionValueBy(this.filterKey, dependencies.filterState);
+        if (!selectedCities || selectedCities.trim() === '') {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(!this.excludedIds.includes(selectedCities));
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        const cities = filterKeyValues.get(FilterKey.CITY);
+        if (cities && cities.length > 0) {
+            const filteredCities = cities.filter(city => !this.excludedIds.includes(city));
+            return Promise.resolve(filteredCities.length > 0);
+        }
+        return Promise.resolve(true);
+    }
+    getName() {
+        return 'ExcludeByIdForCitiesRule';
+    }
+    getDescription() {
+        return `This rule excludes specific city IDs from the search results. (${this.excludedIds.join(", ")})`;
+    }
+}

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

@@ -10,4 +10,5 @@ export declare class CityPresenter {
     static getInstance(searchApiClient: ISearchApiClient): CityPresenter;
     getFragments(): Promise<ICityFragment[]>;
     private fetchCities;
+    private processCity;
 }

package/dist/src/presenters/CityPresenter.js

@@ -28,31 +28,8 @@ export class CityPresenter {
                 console.error('searchApiClient.getCities is not found');
                 throw new Error('searchApiClient.getCities is not found');
             }
-            const data = await this.searchApiClient.getCities();
-            const cityFragments = data.map(city => {
-                const country = countriesExtendedAll.find(item => item.iso?.toLowerCase() === city.countryIsoCode?.toLowerCase());
-                let cityPath = ``;
-                const countryPath = countryGetIsoCodePath(country?.iso || '');
-                if (city.areaId === null || city.areaId === undefined) {
-                    cityPath += `${countryPath}/`;
-                }
-                else {
-                    const area = areaGetPath(city.areaId?.toString() || '');
-                    if (area && area !== '') {
-                        cityPath += `${area}/`;
-                    }
-                    else {
-                        cityPath += `${countryPath}/`;
-                    }
-                }
-                cityPath += `${city.virtualPath}`;
-                return {
-                    id: city.id.toString(),
-                    path: cityPath,
-                    areaId: city.areaId?.toString(),
-                    countryId: country ? country.id.toString() : '',
-                };
-            });
+            const cities = await this.searchApiClient.getCities();
+            const cityFragments = cities.map(city => this.processCity(city));
             return cityFragments;
         }
         catch (error) {
@@ -60,4 +37,18 @@ export class CityPresenter {
             throw error;
         }
     }
+    processCity(city) {
+        const country = countriesExtendedAll.find(item => item.iso?.toLowerCase() === city.countryIsoCode?.toLowerCase());
+        const countryPath = countryGetIsoCodePath(country?.iso || '');
+        const areaPath = city.areaId != null ? areaGetPath(city.areaId.toString()) : '';
+        const useAreaPath = areaPath && areaPath.trim() !== '';
+        // AreaPath do also includes country, for that reason, we do not need to add countryPath if area exists
+        const cityPath = `${useAreaPath ? areaPath : countryPath}/${city.virtualPath}`;
+        return {
+            id: city.id.toString(),
+            path: cityPath,
+            areaId: useAreaPath ? city.areaId?.toString() : null,
+            countryId: country ? country.id.toString() : '',
+        };
+    }
 }

package/dist/src/presenters/fragments/ICityFragment.d.ts

@@ -1,5 +1,5 @@
 import { IFragment } from './IFragment';
 export interface ICityFragment extends IFragment {
-    areaId: string;
+    areaId?: string | null;
     countryId: string;
 }

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

@@ -0,0 +1,7 @@
+export interface ICity {
+    id: number;
+    name: string;
+    virtualPath: string;
+    areaId: number | null;
+    countryIsoCode: string;
+}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/fawkes",
-	"version": "8.2.4-9",
+	"version": "8.3.1-0",
 	"description": "A package to centralize SEO related logic for SBLP and Sitemap Generator.",
 	"files": [
 		"./dist"