DIGG-463: Updating handling of factes that isn't publisher or choice

Author: MikaMunterud

components/content/Search/SearchFilters/index.tsx

@@ -292,7 +292,7 @@ export const SearchFilters: React.FC<SearchFilterProps> = ({
                                   aria-selected={selected(key, facetValue)}
                                 >
                                   <button
-                                    className={`focus--in group relative flex w-full items-center break-all py-md pl-md pr-[3rem] text-left hover:bg-brown-100 ${
+                                    className={`focus--in group relative flex w-full items-center break-words py-md pl-md pr-[3rem] text-left hover:bg-brown-100 ${
                                       selected(key, facetValue) && "font-strong"
                                     }`}
                                     onClick={() => {

types/entrystore-js.d.ts

@@ -15,6 +15,7 @@ declare module "@entryscape/entrystore-js" {
       all: boolean,
       asyncCallType?: any,
     ): Promise<Entry[]>;
+    loadOnlyPublicEntries(all: boolean): void;
   }
 
   export class SolrQuery {

utilities/entryScape.ts

@@ -9,14 +9,15 @@ import {
   getPublisherNames,
   getTemplateChoices,
   getLocalizedChoiceLabel,
+  getFacetNames,
 } from "@/utilities";
 import { Translate } from "next-translate";
 import { SearchSortOrder } from "@/providers/SearchProvider";
 // @ts-ignore
 import { EntryStore, EntryStoreUtil } from "@entryscape/entrystore-js";
 // @ts-ignore
 import { namespaces } from "@entryscape/rdfjson";
-import { publisherCache } from "./publisherCache";
+import { publisherCache, entryCache } from "./localCache";
 //const tokenize = require('edge-ngrams')()
 
 //#region ES members
@@ -103,8 +104,7 @@ export class EntryScape {
     // Initialize the EntryStore instance
     this.entryStore = new EntryStore(this.entryscapeUrl);
     this.entryStoreUtil = new EntryStoreUtil(this.entryStore);
-    // this.entryStore.getREST().disableJSONP();
-    // this.entryStore.getREST().disableCredentials();
+    this.entryStoreUtil.loadOnlyPublicEntries(true);
   }
 
   /**
@@ -140,6 +140,17 @@ export class EntryScape {
       );
 
       if (facetSpec) {
+        if (
+          facetSpec.dcatType !== "choice" &&
+          facetSpec.dcatProperty !== "dcterms:publisher"
+        ) {
+          await getFacetNames(
+            f.values.map((v) => v.name),
+            this.entryStoreUtil,
+            facetSpec,
+          );
+        }
+
         facets[f.predicate] = {
           title: this.t(f.predicate),
           name: f.name,
@@ -174,6 +185,8 @@ export class EntryScape {
               } else if (facetSpec?.dcatProperty === "dcterms:publisher") {
                 // Use cached publisher name without making new requests
                 displayName = publisherCache.getValue(value.name) || value.name;
+              } else {
+                displayName = entryCache.getValue(value.name) || value.name;
               }
 
               return {
@@ -461,7 +474,7 @@ export class EntryScape {
 
     // Set query text
     if (query) {
-      esQuery.all(`*${query}*`);
+      esQuery.all(`${query}`);
     }
 
     try {
@@ -478,7 +491,7 @@ export class EntryScape {
         ?.values?.map((v: any) => v.name);
 
       if (publisherUris) {
-        await getPublisherNames(publisherUris, es, esu);
+        await getPublisherNames(publisherUris, esu);
       }
 
       // Process children sequentially to maintain order

utilities/entrystoreUtil.ts

@@ -12,7 +12,7 @@
  */
 
 import { EntryStore, EntryStoreUtil } from "@entryscape/entrystore-js";
-import { publisherCache } from "./publisherCache";
+import { entryCache, publisherCache } from "./localCache";
 
 export const getLocalizedMetadataValue = (
   metadataGraph: any,
@@ -118,10 +118,62 @@ export const getSimplifiedLocalizedValue = (
   return (svValue || enValue || values[0])?.getValue() || "";
 };
 
+export const getFacetNames = async (
+  facetValues: string[],
+  esu: EntryStoreUtil,
+  facetSpec: any,
+) => {
+  const cache = entryCache.get();
+  // Filter out null values and already cached URIs
+  const uniqueUris = Array.from(new Set(facetValues)).filter(
+    (uri): uri is string => uri !== null && !cache.has(uri),
+  );
+
+  if (uniqueUris.length === 0) {
+    return cache;
+  }
+
+  try {
+    // Load all entries in one batch with a single request
+    const entries = await esu.loadEntriesByResourceURIs(
+      uniqueUris,
+      null,
+      true,
+      facetSpec.predicate,
+    );
+
+    // Process all entries at once
+    entries.forEach(async (entry: any) => {
+      if (entry) {
+        const metadata = entry.getMetadata();
+        const uri = entry.getResourceURI();
+        const name =
+          getSimplifiedLocalizedValue(metadata, "dcterms:title") ||
+          getSimplifiedLocalizedValue(metadata, "foaf:name") ||
+          undefined;
+
+        cache.set(uri, name);
+      }
+    });
+
+    // Cache any URIs that weren't found
+    uniqueUris.forEach((uri) => {
+      if (!cache.has(uri)) {
+        cache.set(uri, uri);
+      }
+    });
+
+    return cache;
+  } catch (error) {
+    console.error("Error fetching publisher names:", error);
+    uniqueUris.forEach((uri) => cache.set(uri, uri));
+    return cache;
+  }
+};
+
 // Helper function to get publisher name from URI
 export const getPublisherNames = async (
   publisherUris: string[],
-  es: EntryStore,
   esu: EntryStoreUtil,
 ) => {
   const cache = publisherCache.get();

utilities/publisherCache.ts renamed to utilities/localCache.ts

@@ -27,3 +27,33 @@ class PublisherCacheManager {
 }
 
 export const publisherCache = PublisherCacheManager.getInstance();
+
+class EntryCacheManager {
+  private static instance: EntryCacheManager;
+  private cache: Map<string, any>;
+
+  private constructor() {
+    this.cache = new Map<string, string>();
+  }
+
+  public static getInstance(): EntryCacheManager {
+    if (!EntryCacheManager.instance) {
+      EntryCacheManager.instance = new EntryCacheManager();
+    }
+    return EntryCacheManager.instance;
+  }
+
+  public get(): Map<string, string> {
+    return this.cache;
+  }
+
+  public getValue(key: string): string | undefined {
+    return this.cache.get(key);
+  }
+
+  public set(key: string, value: string): void {
+    this.cache.set(key, value);
+  }
+}
+
+export const entryCache = EntryCacheManager.getInstance();