diff --git a/src/components/face-category/FacetCategory.ts b/src/components/face-category/FacetCategory.ts
index 7669705..3161dcf 100644
--- a/src/components/face-category/FacetCategory.ts
+++ b/src/components/face-category/FacetCategory.ts
@@ -20,7 +20,7 @@ export default class FacetCategory extends Vue {
     filterName!: string;
 
     get alias(): string {
-        console.log("filterName:", this.filterName);
+        // console.log("filterName:", this.filterName);
         return this.filterName == "datatype" ? "doctype" : this.filterName;
     }
 
@@ -54,7 +54,7 @@ export default class FacetCategory extends Vue {
 
     @Emit("filter")
     activateItem(filterItem: FacetItem): FacetItem {
-        // console.log(filterItem);
+        // console.log("ActivateItem");
         filterItem.category = this.alias;
         filterItem.active = true;
         // this.$emit("filter", filterItem);
diff --git a/src/components/face-category/facet-category.vue b/src/components/face-category/facet-category.vue
index bc278c8..4dd196d 100644
--- a/src/components/face-category/facet-category.vue
+++ b/src/components/face-category/facet-category.vue
@@ -8,9 +8,6 @@
             <!-- e.g.language -->
             <ul class="filter-items list-unstyled" v-bind:class="{ limited: facetItems.length > 1 && collapsed }">
                 <li v-for="(item, index) in facetItems" v-bind:key="index" class="list-group-item titlecase">
-                    {{ item.active }}
-                    {{ item.val }}
-                    {{ item.count }} //
                     <!-- <span :class="item.Active ? 'disabled' : ''" @click.prevent="activateItem(item)">{{ item.val }} ({{ item.count }}) </span> -->
                     <span v-bind:class="item.active ? 'disabled' : ''" @click.prevent="activateItem(item)">{{ item.val }} ({{ item.count }}) </span>
                 </li>
diff --git a/src/components/vs-input/vs-input.ts b/src/components/vs-input/vs-input.ts
index 128a95c..76c3ea6 100644
--- a/src/components/vs-input/vs-input.ts
+++ b/src/components/vs-input/vs-input.ts
@@ -2,12 +2,12 @@
 // import debounce from 'lodash/debounce';
 // import { DatasetService } from "../../services/dataset.service";
 import DatasetService from "../../services/dataset.service";
-import { SolrSettings } from "@/models/solr";  // PENDING USE
+// import { SolrSettings } from "@/models/solr";  // PENDING USE
 
 import { OpenSettings } from "@/models/solr";
 import { Component, Vue, Prop, Emit } from "vue-facing-decorator";
 import { Dataset, Suggestion, SearchType } from "@/models/dataset";
-import { SOLR_HOST, SOLR_CORE } from "@/constants";
+// import { SOLR_HOST, SOLR_CORE } from "@/constants";
 
 import { OPEN_HOST, OPEN_CORE } from "@/constants"; // PENDING USE
 import { HitHighlight } from "@/models/headers";
@@ -38,10 +38,10 @@ export default class VsInput extends Vue {
     private loading = false; // Loading state indicator
     private selectedIndex = -1; // Index of the currently selected suggestion
 
-    private solr: SolrSettings = {
-        core: SOLR_CORE, //"rdr_data", // SOLR.core;
-        host: SOLR_HOST, //"tethys.at",
-    };
+    // private solr: SolrSettings = {
+    //     core: SOLR_CORE, //"rdr_data", // SOLR.core;
+    //     host: SOLR_HOST, //"tethys.at",
+    // };
 
     private openSearch: OpenSettings = {
         core: OPEN_CORE, //"rdr_data", // SOLR.core;
diff --git a/src/constants.ts b/src/constants.ts
index 56a2a29..7762dfe 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -2,8 +2,8 @@
 // declare const EDGE_URL: string;
 declare const APP_URL: string;
 declare const VUE_API: string;
-declare const SOLR_HOST: string;
-declare const SOLR_CORE: string;
+// declare const SOLR_HOST: string;
+// declare const SOLR_CORE: string;
 
 // OPENSEARCH
 declare const OPEN_HOST: string;
@@ -13,8 +13,8 @@ declare const OPEN_CORE: string;
 // const _POINT_URL = POINT_URL;
 const _APP_URL = APP_URL;
 const _VUE_API = VUE_API;
-const _SOLR_HOST = SOLR_HOST;
-const _SOLR_CORE = SOLR_CORE;
+// const _SOLR_HOST = SOLR_HOST;
+// const _SOLR_CORE = SOLR_CORE;
 
 // OPENSEARCH
 const _OPEN_HOST = OPEN_HOST;
@@ -24,8 +24,8 @@ const _OPEN_CORE = OPEN_CORE;
 // export { _POINT_URL as POINT_URL };
 export { _APP_URL as APP_URL };
 export { _VUE_API as VUE_API };
-export { _SOLR_HOST as SOLR_HOST };
-export { _SOLR_CORE as SOLR_CORE };
+// export { _SOLR_HOST as SOLR_HOST };
+// export { _SOLR_CORE as SOLR_CORE };
 
 // OPENSEARCH
 export { _OPEN_HOST as OPEN_HOST };
diff --git a/src/models/solr.ts b/src/models/solr.ts
index 0061c6a..d850e71 100644
--- a/src/models/solr.ts
+++ b/src/models/solr.ts
@@ -1,7 +1,7 @@
-export interface SolrSettings {
-    core: string;
-    host: string;
-}
+// export interface SolrSettings {
+//     core: string;
+//     host: string;
+// }
 
 export interface OpenSettings {
     core: string;
diff --git a/src/services/dataset.service.ts b/src/services/dataset.service.ts
index 485efb9..a6ddc12 100644
--- a/src/services/dataset.service.ts
+++ b/src/services/dataset.service.ts
@@ -26,11 +26,10 @@ class DatasetService {
     // private openSearchUrl = "http://opensearch.geoinformation.dev/tethys-records/_search";
     // private openSearchUrl = "http://192.168.21.18/tethys-records/_search";
 
-    // public searchTerm(term: string): Observable<Dataset[]> {
     public searchTerm(term: string, openCore: string, openHost: string): Observable<{ datasets: Dataset[], highlights: HitHighlight[] }> {
         // OpenSearch endpoint
-        const host = "https://" + openHost; // When using geoinformation.dev
-        // const host = "http://" + openHost; // When using local OpenSearch dev endpoint
+        // const host = "https://" + openHost; // When using geoinformation.dev
+        const host = "http://" + openHost; // When using local OpenSearch dev endpoint
         const path = "/" + openCore + "/_search";
         const base = host + path;
         /** 
@@ -57,8 +56,10 @@ class DatasetService {
             sort: [{ _score: { order: "desc" } }], // Sort by _score in descending order
             track_scores: true, // This ensures "_score" is included even when sorting by other criteria. Otherwise the relevance score is not calculated
             aggs: {
-                language: { terms: { field: "language.keyword" } },
-                subjects: { terms: { field: "subjects.keyword", size: 10 } } // In SOLR is "subject"!
+                subjects: { terms: { field: "subjects.keyword", size: 1000 } }, // In SOLR is "subject"!
+                language: { terms: { field: "language" } },  // << ".keyword" HAS TO BE REMOVED. OTHERWISE BUCKETS ARE NOT OBTAINED FOR THIS
+                author: { terms: { field: "author.keyword", size: 1000 } },
+                year: { terms: { field: "year", size: 100 } }  // << ".keyword" HAS TO BE REMOVED. OTHERWISE BUCKETS ARE NOT OBTAINED FOR THIS
             },
             highlight: {
                 fields: {
@@ -69,6 +70,8 @@ class DatasetService {
             }
         };
 
+        
+
         // Make API call to OpenSearch and return the result
         /**
          * When a POST request is made to the OpenSearch server using the api.post<OpenSearchResponse> method, the response received from OpenSearch is an object that includes various details about the search results. 
@@ -140,7 +143,8 @@ class DatasetService {
         start?: string, // Starting page
     ): Observable<OpenSearchResponse> {
         // OpenSearch endpoint
-        const host = "https://" + openHost;
+        // const host = "https://" + openHost; // When using geoinformation.dev
+        const host = "http://" + openHost; // When using local OpenSearch dev endpoint
         const path = "/" + openCore + "/_search";
         const base = host + path;
     
@@ -179,10 +183,17 @@ class DatasetService {
             };
     
         // Constructing Filters Based on Active Filter Categories
-        const filters = Object.entries(activeFilterCategories).map(([category, values]) => ({
-            terms: { [`${category}.keyword`]: values }
-            // terms: { [category]: values }
-        }));
+        // const filters = Object.entries(activeFilterCategories).map(([category, values]) => ({
+        //     terms: { [`${category}.keyword`]: values }
+        //     // terms: { [category]: values }
+        // }));
+        const filters = Object.entries(activeFilterCategories).map(([category, values]) => {
+            if (category === "language" || category === "year") {
+                return { terms: { [category]: values } };
+            } else {
+                return { terms: { [`${category}.keyword`]: values } };
+            }
+        });
     
         const body = {
             query: {
@@ -199,10 +210,10 @@ class DatasetService {
                 // terms: Aggregation type that returns the most common terms in a field.
                 // !For a large number of terms setting an extremely large size might not be efficient 
                 // If you genuinely need all unique terms and expect a large number of them, consider using a composite aggregation for more efficient pagination of terms.
-                subjects: { terms: { field: "subjects.keyword", size: 1000 } },
-                language: { terms: { field: "language.keyword" } },
+                subjects: { terms: { field: "subjects.keyword", size: 1000 } }, // In SOLR is "subject"!
+                language: { terms: { field: "language" } }, // ".keyword" HAS TO BE REMOVED. OTHERWISE BUCKETS ARE NOT OBTAINED FOR THIS
                 author: { terms: { field: "author.keyword", size: 1000 } },
-                year: { terms: { field: "year.keyword", size: 100 } }
+                year: { terms: { field: "year", size: 100 } }  // ".keyword" HAS TO BE REMOVED. OTHERWISE BUCKETS ARE NOT OBTAINED FOR THIS
             },
             highlight: {
                 fields: {
@@ -213,126 +224,119 @@ class DatasetService {
             }
         };
     
-        // return api.post<OpenSearchResponse>(base, body).pipe(
-        //     // map(response => ({
-        //     //     datasets: response.hits.hits.map(hit => hit._source),
-        //     //     highlights: response.hits.hits.map(hit => hit.highlight),
-        //     //     // aggregations: response.aggregations
-        //     // }))
-        // );
         const stations = api.post<OpenSearchResponse>(base, body);
 
         return stations;
     }
         
-    /**
-     * This method performs a faceted search on a Solr core. Faceted search allows the user to filter search results based on various categories (facets)
-     */
-    public facetedSearch(
-        suggestion: Suggestion | string,
-        activeFilterCategories: ActiveFilterCategories,
-        solrCore: string,
-        solrHost: string,
-        start?: string, // Starting page
-    ): Observable<SolrResponse> {
-        // console.log("face:", suggestion);
-        // console.log(activeFilterCategories);
-        // console.log(solrCore);
-        // console.log(solrHost);
-        // console.log(start);
+    // /**
+    //  * This method performs a faceted search on a Solr core. Faceted search allows the user to filter search results based on various categories (facets)
+    //  */
+    // public facetedSearch_SOLR(
+    //     suggestion: Suggestion | string,
+    //     activeFilterCategories: ActiveFilterCategories,
+    //     solrCore: string,
+    //     solrHost: string,
+    //     start?: string, // Starting page
+    // ): Observable<SolrResponse> {
+    //     // console.log("face:", suggestion);
+    //     // console.log(activeFilterCategories);
+    //     // console.log(solrCore);
+    //     // console.log(solrHost);
+    //     // console.log(start);
         
-        console.log("facetedsearchSOLR > suggestion entered:");
-        console.log(suggestion);
+    //     console.log("facetedsearchSOLR > suggestion entered:");
+    //     console.log(suggestion);
 
-        // Construct Solr query parameters
-        const host = "https://" + solrHost;
-        const path = "/solr/" + solrCore + "/select?";
-        const base = host + path;
+    //     // Construct Solr query parameters
+    //     const host = "https://" + solrHost;
+    //     const path = "/solr/" + solrCore + "/select?";
+    //     const base = host + path;
 
-        const fields = [
-            "id",
-            "licence",
-            "server_date_published",
-            "abstract_output",
-            "identifier",
-            "title_output",
-            "title_additional",
-            "author",
-            "subject",
-            "doctype",
-        ].toString();
+    //     const fields = [
+    //         "id",
+    //         "licence",
+    //         "server_date_published",
+    //         "abstract_output",
+    //         "identifier",
+    //         "title_output",
+    //         "title_additional",
+    //         "author",
+    //         "subject",
+    //         "doctype",
+    //     ].toString();
 
-        // Determine search term, query operator, and query fields based on the suggestion type. Depending on whether suggestion is a string or a Suggestion object, it constructs the search term and query fields differently.
-        let term, queryOperator, qfFields;
-        if (typeof suggestion === "string") { // f suggestion is a string, it appends a wildcard (*) for partial matches.
-            term = suggestion + "*";
-            queryOperator = "or";
-            qfFields = "title^3 author^2 subject^1";
-        } else if (suggestion instanceof Suggestion) { // If suggestion is a Suggestion object, it forms a more specific query based on the type and value of the suggestion.
-            term = suggestion.type + ':"' + suggestion.value + '"';
-            queryOperator = "and";
-            qfFields = undefined;
-        }
+    //     // Determine search term, query operator, and query fields based on the suggestion type. Depending on whether suggestion is a string or a Suggestion object, it constructs the search term and query fields differently.
+    //     let term, queryOperator, qfFields;
+    //     if (typeof suggestion === "string") { // f suggestion is a string, it appends a wildcard (*) for partial matches.
+    //         term = suggestion + "*";
+    //         queryOperator = "or";
+    //         qfFields = "title^3 author^2 subject^1";
+    //     } else if (suggestion instanceof Suggestion) { // If suggestion is a Suggestion object, it forms a more specific query based on the type and value of the suggestion.
+    //         term = suggestion.type + ':"' + suggestion.value + '"';
+    //         queryOperator = "and";
+    //         qfFields = undefined;
+    //     }
 
-        // Set default value for start if not provided
-        if (start === undefined) start = "0";
+    //     // Set default value for start if not provided
+    //     if (start === undefined) start = "0";
 
-        // Construct filter fields based on active filter categories
-        const filterFields = new Array<string>();
-        if (Object.keys(activeFilterCategories).length > 0) {
-            /* Declare variable prop with a type that is a key of the activeFilterCategories. The 'keyof typeof' activeFilterCategories type represents all possible keys 
-            that can exist on the activeFilterCategories --> prop can only be assigned a value that is a key of the activeFilterCategories object */
-            let prop: keyof typeof activeFilterCategories;
-            for (prop in activeFilterCategories) {
-                const filterItems = activeFilterCategories[prop];
-                filterItems.forEach(function (value: string) {
-                    filterFields.push(prop + ':("' + value + '")');
-                    // e.g. Array [ 'subject:("Vektordaten")', 'author:("GeoSphere Austria, ")' ]
-                });
-            }
-        }
+    //     // Construct filter fields based on active filter categories
+    //     const filterFields = new Array<string>();
+    //     if (Object.keys(activeFilterCategories).length > 0) {
+    //         /* Declare variable prop with a type that is a key of the activeFilterCategories. The 'keyof typeof' activeFilterCategories type represents all possible keys 
+    //         that can exist on the activeFilterCategories --> prop can only be assigned a value that is a key of the activeFilterCategories object */
+    //         let prop: keyof typeof activeFilterCategories;
+    //         for (prop in activeFilterCategories) {
+    //             const filterItems = activeFilterCategories[prop];
+    //             filterItems.forEach(function (value: string) {
+    //                 filterFields.push(prop + ':("' + value + '")');
+    //                 // e.g. Array [ 'subject:("Vektordaten")', 'author:("GeoSphere Austria, ")' ]
+    //             });
+    //         }
+    //     }
 
-        // https://solr.apache.org/guide/8_4/json-request-api.html
-        // Construct Solr query parameters
-        const q_params = {
-            "0": "fl=" + fields,
-            q: term,
-            "q.op": queryOperator,
-            defType: "edismax",
-            qf: qfFields,
-            // df: "title",
-            indent: "on",
-            wt: "json",
-            rows: 10,
-            // fq: ["subject:Steiermark", "language:de"],
-            fq: filterFields,
-            start: start,
-            sort: "server_date_published desc",
-            facet: "on",
-            // "facet.field": "language",
-            "json.facet.language": '{ type: "terms", field: "language" }',
-            "json.facet.subject": '{ type: "terms", field: "subject", limit: -1 }',
-            "json.facet.year": '{ type: "terms", field: "year" }',
-            "json.facet.author": '{ type: "terms", field: "author_facet", limit: -1 }',
-        };
-        /* E.g.
-        {"0":"fl=id,licence,server_date_published,abstract_output,identifier,title_output,title_additional,author,subject,doctype","q":"*","q.op":"or","defType":"edismax",
-        "qf":"title^3 author^2 subject^1",
-        "indent":"on","wt":"json","rows":10,
-        "fq":["subject:(\"Vektordaten\")","author:(\"GeoSphere Austria, \")"],
-        "start":"0","sort":"server_date_published desc","facet":"on",
-        "json.facet.language":"{ type: \"terms\", field: \"language\" }",
-        "json.facet.subject":"{ type: \"terms\", field: \"subject\", limit: -1 }",
-        "json.facet.year":"{ type: \"terms\", field: \"year\" }",
-        "json.facet.author":"{ type: \"terms\", field: \"author_facet\", limit: -1 }"}
-         */
-        // console.log(JSON.stringify(q_params));
+    //     // https://solr.apache.org/guide/8_4/json-request-api.html
+    //     // Construct Solr query parameters
+    //     const q_params = {
+    //         "0": "fl=" + fields,
+    //         q: term,
+    //         "q.op": queryOperator,
+    //         defType: "edismax",
+    //         qf: qfFields,
+    //         // df: "title",
+    //         indent: "on",
+    //         wt: "json",
+    //         rows: 10,
+    //         // fq: ["subject:Steiermark", "language:de"],
+    //         fq: filterFields,
+    //         start: start,
+    //         sort: "server_date_published desc",
+    //         facet: "on",
+    //         // "facet.field": "language",
+    //         "json.facet.language": '{ type: "terms", field: "language" }',
+    //         "json.facet.subject": '{ type: "terms", field: "subject", limit: -1 }',
+    //         "json.facet.year": '{ type: "terms", field: "year" }',
+    //         "json.facet.author": '{ type: "terms", field: "author_facet", limit: -1 }',
+    //     };
+    //     /* E.g.
+    //     {"0":"fl=id,licence,server_date_published,abstract_output,identifier,title_output,title_additional,author,subject,doctype","q":"*","q.op":"or","defType":"edismax",
+    //     "qf":"title^3 author^2 subject^1",
+    //     "indent":"on","wt":"json","rows":10,
+    //     "fq":["subject:(\"Vektordaten\")","author:(\"GeoSphere Austria, \")"],
+    //     "start":"0","sort":"server_date_published desc","facet":"on",
+    //     "json.facet.language":"{ type: \"terms\", field: \"language\" }",
+    //     "json.facet.subject":"{ type: \"terms\", field: \"subject\", limit: -1 }",
+    //     "json.facet.year":"{ type: \"terms\", field: \"year\" }",
+    //     "json.facet.author":"{ type: \"terms\", field: \"author_facet\", limit: -1 }"}
+    //      */
+    //     // console.log(JSON.stringify(q_params));
         
-        // Make API call to Solr and return the result
-        const stations = api.get<SolrResponse>(base, q_params);
+    //     // Make API call to Solr and return the result
+    //     const stations = api.get<SolrResponse>(base, q_params);
 
-        return stations;
-    }
+    //     return stations;
+    // }
 
     // Method to fetch years
     public getYears(): Observable<string[]> {
diff --git a/src/views/search-view/search-view-component.ts b/src/views/search-view/search-view-component.ts
index dbc933d..5ce94b6 100644
--- a/src/views/search-view/search-view-component.ts
+++ b/src/views/search-view/search-view-component.ts
@@ -3,16 +3,17 @@ import VsInput from "@/components/vs-input/vs-input.vue";
 import VsResult from "@/components/vs-result/vs-result.vue";
 import FacetCategory from "@/components/face-category/facet-category.vue";
 import ActiveFacetCategory from "@/components/active-facet-category/active-facet-category.vue";
-import { SolrSettings } from "@/models/solr";
+// import { SolrSettings } from "@/models/solr";
 
 import { OpenSettings } from "@/models/solr";
 // import { DatasetService } from "@/services/dataset.service";
 import DatasetService from "../../services/dataset.service";
 import { Suggestion, Dataset, SearchType } from "@/models/dataset";
 // import { SolrResponse, FacetFields, FacetItem, FacetResults, FacetInstance } from "@/models/headers";
-import { SolrResponse, FacetFields, FacetItem, FacetResults, FacetInstance, OpenSearchResponse, HitHighlight } from "@/models/headers";
+// import { SolrResponse, FacetFields, FacetItem, FacetResults, FacetInstance, OpenSearchResponse, HitHighlight } from "@/models/headers";
+import { FacetFields, FacetItem, FacetResults, FacetInstance, OpenSearchResponse, HitHighlight } from "@/models/headers";
 import { ActiveFilterCategories } from "@/models/solr";
-import { SOLR_HOST, SOLR_CORE } from "@/constants";
+// import { SOLR_HOST, SOLR_CORE } from "@/constants";
 import { IPagination } from "@/models/pagination";
 import PaginationComponent from "@/components/PaginationComponent.vue";
 
@@ -54,10 +55,10 @@ export default class SearchViewComponent extends Vue {
     };
     loaded = false;
     numFound!: number;
-    private solr: SolrSettings = {
-        core: SOLR_CORE, //"rdr_data", // SOLR.core;
-        host: SOLR_HOST, //"tethys.at",
-    };
+    // private solr: SolrSettings = {
+    //     core: SOLR_CORE, //"rdr_data", // SOLR.core;
+    //     host: SOLR_HOST, //"tethys.at",
+    // };
 
     private open: OpenSettings = {
         core: OPEN_CORE, //"rdr_data", // SOLR.core;
@@ -157,6 +158,8 @@ export default class SearchViewComponent extends Vue {
         // console.log(this.numFound);
         // console.log(res.hits.hits);
         // console.log(res.hits.total.value);
+        console.log(res);
+        
 
         // for (const key in this.results) {
         //     if (Object.prototype.hasOwnProperty.call(this.results, key)) {
@@ -172,81 +175,113 @@ export default class SearchViewComponent extends Vue {
         this.pagination.data = this.results;
         this.pagination.lastPage = Math.ceil(this.pagination.total / this.pagination.perPage);
 
+        // if (res.aggregations) {
+        //     const facet_fields = res.aggregations;
+
+        //     let prop: keyof typeof facet_fields;
+
+        //     for (prop in facet_fields) {
+        //         const facetCategory = facet_fields[prop];
+        //         if (facetCategory.buckets) {
+        //             const facetItems = facetCategory.buckets.map(bucket => new FacetItem(bucket.key, bucket.doc_count));
+        //             this.facets[prop] = facetItems.filter(el => el.count > 0);
+        //         }
+        //     }
+        // }
+
         if (res.aggregations) {
             const facet_fields = res.aggregations;
-
+    
             let prop: keyof typeof facet_fields;
-
+    
+            // Iterate through facet fields
             for (prop in facet_fields) {
                 const facetCategory = facet_fields[prop];
                 if (facetCategory.buckets) {
                     const facetItems = facetCategory.buckets.map(bucket => new FacetItem(bucket.key, bucket.doc_count));
-
-                    this.facets[prop] = facetItems.filter(el => el.count > 0);
+    
+                    let facetValues = facetItems.map((facetItem) => {
+                        let rObj: FacetItem;
+                        // Check if current facet item matches filter item
+                        if (filterItem?.val == facetItem.val) {
+                            rObj = filterItem;
+                        } else if (this.facets[prop]?.some((e) => e.val === facetItem.val)) {
+                            const indexOfFacetValue = this.facets[prop].findIndex((i) => i.val === facetItem.val);
+                            rObj = this.facets[prop][indexOfFacetValue];
+                            rObj.count = facetItem.count;
+                        } else {
+                            // Create new facet item
+                            rObj = new FacetItem(facetItem.val, facetItem.count);
+                        }
+                        return rObj;
+                    });
+    
+                    // Filter out null values and values with count <= 0
+                    facetValues = facetValues.filter(el => el.count > 0);
+                    this.facets[prop] = facetValues;
                 }
             }
         }
-
     }
 
-    // Method to handle search response
-    private dataHandler(res: SolrResponse, filterItem?: FacetItem): void {
-        // console.log("dataHandlerSOLR (docs, numFound):");
-        // console.log(res.response.docs);
-        // console.log(res.response.numFound);
+    // // Method to handle search response
+    // private dataHandler(res: SolrResponse, filterItem?: FacetItem): void {
+    //     // console.log("dataHandlerSOLR (docs, numFound):");
+    //     // console.log(res.response.docs);
+    //     // console.log(res.response.numFound);
 
-        // Update results
-        this.results = res.response.docs;
-        this.numFound = res.response.numFound;
+    //     // Update results
+    //     this.results = res.response.docs;
+    //     this.numFound = res.response.numFound;
 
-        // Update pagination
-        this.pagination["total"] = res.response.numFound;
-        this.pagination["perPage"] = res.responseHeader.params.rows as number;
-        this.pagination["data"] = res.response.docs;
-        this.pagination.lastPage = Math.ceil(this.pagination.total / this.pagination.perPage);
+    //     // Update pagination
+    //     this.pagination["total"] = res.response.numFound;
+    //     this.pagination["perPage"] = res.responseHeader.params.rows as number;
+    //     this.pagination["data"] = res.response.docs;
+    //     this.pagination.lastPage = Math.ceil(this.pagination.total / this.pagination.perPage);
 
-        const facet_fields: FacetFields = res.facets;
+    //     const facet_fields: FacetFields = res.facets;
         
-        /* This code declares a variable prop with a type of keys of the facet_fields object. The keyof typeof facet_fields type represents the keys of the facet_fields object. 
-        This means that prop can only hold values that are keys of the facet_fields object. */
-        let prop: keyof typeof facet_fields;
+    //     /* This code declares a variable prop with a type of keys of the facet_fields object. The keyof typeof facet_fields type represents the keys of the facet_fields object. 
+    //     This means that prop can only hold values that are keys of the facet_fields object. */
+    //     let prop: keyof typeof facet_fields;
         
-        // Iterate through facet fields
-        for (prop in facet_fields) {
-            const facetCategory = facet_fields[prop];
-            if (facetCategory.buckets) {
-                const facetItems: Array<FacetItem> = facetCategory.buckets;
+    //     // Iterate through facet fields
+    //     for (prop in facet_fields) {
+    //         const facetCategory = facet_fields[prop];
+    //         if (facetCategory.buckets) {
+    //             const facetItems: Array<FacetItem> = facetCategory.buckets;
 
-                let facetValues = facetItems.map((facetItem) => {
-                    let rObj: FacetItem;
-                    // Check if current facet item matches filter item
-                    if (filterItem?.val == facetItem.val) {
-                        rObj = filterItem;
-                    } else if (this.facets[prop]?.some((e) => e.val === facetItem.val)) {
-                        // console.log(facetValue + " is included")
-                        // Update existing facet item with new count
-                        const indexOfFacetValue = this.facets[prop].findIndex((i) => i.val === facetItem.val);
-                        // console.log(indexOfFacetValue);
-                        rObj = this.facets[prop][indexOfFacetValue];
-                        rObj.count = facetItem.count;
-                        // rObj = new FacetItem(val, count);
-                    } else {
-                        // Create new facet item
-                        rObj = new FacetItem(facetItem.val, facetItem.count);
-                    }
-                    return rObj;
-                });
+    //             let facetValues = facetItems.map((facetItem) => {
+    //                 let rObj: FacetItem;
+    //                 // Check if current facet item matches filter item
+    //                 if (filterItem?.val == facetItem.val) {
+    //                     rObj = filterItem;
+    //                 } else if (this.facets[prop]?.some((e) => e.val === facetItem.val)) {
+    //                     // console.log(facetValue + " is included")
+    //                     // Update existing facet item with new count
+    //                     const indexOfFacetValue = this.facets[prop].findIndex((i) => i.val === facetItem.val);
+    //                     // console.log(indexOfFacetValue);
+    //                     rObj = this.facets[prop][indexOfFacetValue];
+    //                     rObj.count = facetItem.count;
+    //                     // rObj = new FacetItem(val, count);
+    //                 } else {
+    //                     // Create new facet item
+    //                     rObj = new FacetItem(facetItem.val, facetItem.count);
+    //                 }
+    //                 return rObj;
+    //             });
 
-                // Filter out null values and values with count <= 0
-                facetValues = facetValues.filter(function (el) {
-                    return el != null && el.count > 0;
-                });
-                // this.facets[prop] = facetCategory;
-                // Update facet values
-                this.facets[prop] = facetValues;
-            }
-        }
-    }
+    //             // Filter out null values and values with count <= 0
+    //             facetValues = facetValues.filter(function (el) {
+    //                 return el != null && el.count > 0;
+    //             });
+    //             // this.facets[prop] = facetCategory;
+    //             // Update facet values
+    //             this.facets[prop] = facetValues;
+    //         }
+    //     }
+    // }
 
     // Method to handle search errors
     private errorHandler(err: string): void {
@@ -278,15 +313,15 @@ export default class SearchViewComponent extends Vue {
         
         // Reset current page
         this.pagination.currentPage = 1;
-        console.log(facetItem.val);
-        console.log(facetItem.category);
+        // console.log(facetItem.val);
+        // console.log(facetItem.category);
         
         // if (!this.activeFilterCategories.hasOwnProperty(facetItem.category)) {
         
         // Check if filter item already exists
         if (!Object.prototype.hasOwnProperty.call(this.activeFilterCategories, facetItem.category)) {
             this.activeFilterCategories[facetItem.category] = new Array<string>();
-            console.log(this.activeFilterCategories);
+            // console.log(this.activeFilterCategories);
         }
         // if (!this.activeFilterCategories[facetItem.category].some((e) => e === facetItem.val)) {
 
@@ -299,7 +334,7 @@ export default class SearchViewComponent extends Vue {
             //     (res: SolrResponse) => this.dataHandler(res, facetItem),
             //     (error: string) => this.errorHandler(error),
             // );
-            console.log(this.activeFilterCategories);
+            // console.log(this.activeFilterCategories);
             DatasetService.facetedSearchOPEN(this.searchTerm, this.activeFilterCategories, this.open.core, this.open.host, undefined).subscribe({
                 next: (res: OpenSearchResponse) => this.dataHandlerOPEN(res, facetItem),
                 error: (error: string) => this.errorHandler(error),
@@ -363,7 +398,7 @@ export default class SearchViewComponent extends Vue {
 
     // Method to clear facet category filter
     onClearFacetCategoryOPEN(categoryName: string): void {
-        console.log("onClearFacetCategory");
+        // console.log("onClearFacetCategory");
         delete this.activeFilterCategories[categoryName];
 
         // Trigger new search with updated filter
diff --git a/vue.config.cjs b/vue.config.cjs
index 6f43f5f..4fc1199 100644
--- a/vue.config.cjs
+++ b/vue.config.cjs
@@ -89,8 +89,8 @@ module.exports = {
                 __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
                 APP_URL: JSON.stringify(process.env.APP_URL),
                 VUE_API: JSON.stringify(process.env.VUE_API),
-                SOLR_HOST: JSON.stringify(process.env.SOLR_HOST),
-                SOLR_CORE: JSON.stringify(process.env.SOLR_CORE),
+                // SOLR_HOST: JSON.stringify(process.env.SOLR_HOST),
+                // SOLR_CORE: JSON.stringify(process.env.SOLR_CORE),
                 // OPENSEARCH
                 OPEN_HOST: JSON.stringify(process.env.OPEN_HOST),
                 OPEN_CORE: JSON.stringify(process.env.OPEN_CORE),