[DURACOM-508] make explore pages configurable

Author: FrancescoMolinaro

config/config.example.yml

@@ -711,6 +711,9 @@ accessibility:
 # Configuration for layout customization of metadata rendering in Item page
 # Currently only the authority reference config is available, more will follow with the integration of the so called CRIS layout.
 layout:
+  # Enable or disable the explore pages feature (/explore/:id routes and their navbar menu entries).
+  # When false, explore routes redirect to 404 and the explore menu is hidden.
+  enableExplorePages: true
   # Configuration of icons and styles to be used for each authority controlled link
   authorityRef:
     - entityType: DEFAULT

src/app/explore-page/explore-pages-enabled.guard.ts

@@ -0,0 +1,31 @@
+import { inject } from '@angular/core';
+import {
+  ActivatedRouteSnapshot,
+  CanActivateFn,
+  Router,
+  RouterStateSnapshot,
+  UrlTree,
+} from '@angular/router';
+import {
+  APP_CONFIG,
+  AppConfig,
+} from '@dspace/config/app-config.interface';
+
+import { getPageNotFoundRoute } from '../core/router/core-routing-paths';
+
+/**
+ * Route guard that checks whether explore pages are enabled in the application config.
+ * When `layout.enableExplorePages` is false, navigating to any explore route
+ * will redirect to the 404 page.
+ */
+export const explorePagesEnabledGuard: CanActivateFn = (
+  route: ActivatedRouteSnapshot,
+  state: RouterStateSnapshot,
+  appConfig: AppConfig = inject(APP_CONFIG),
+  router: Router = inject(Router),
+): boolean | UrlTree => {
+  if (appConfig.layout.enableExplorePages) {
+    return true;
+  }
+  return router.parseUrl(getPageNotFoundRoute());
+};

src/app/explore-page/explore-routes.ts

@@ -8,13 +8,14 @@ import { Route } from '@angular/router';
 import { endUserAgreementCurrentUserGuard } from '../core/end-user-agreement/end-user-agreement-current-user.guard';
 import { exploreI18nBreadcrumbResolver } from './explore-i18n-breadcrumb.resolver';
 import { ExplorePageComponent } from './explore-page.component';
+import { explorePagesEnabledGuard } from './explore-pages-enabled.guard';
 
 export const ROUTES: Route[] = [
   {
     path: ':id',
     component: ExplorePageComponent,
     resolve: { breadcrumb: exploreI18nBreadcrumbResolver },
     data: { title: 'explore.title', breadcrumbKey: 'explore', showSocialButtons: true },
-    canActivate: [endUserAgreementCurrentUserGuard],
+    canActivate: [explorePagesEnabledGuard, endUserAgreementCurrentUserGuard],
   },
 ];

src/app/shared/menu/providers/explore.menu.spec.ts

@@ -12,28 +12,101 @@ import { SectionDataService } from '@dspace/core/data/section-data.service';
 import { createPaginatedList } from '@dspace/core/testing/utils.test';
 import { createSuccessfulRemoteDataObject$ } from '@dspace/core/utilities/remote-data.utils';
 
-import { environment } from '../../../../environments/environment';
+import { MenuItemType } from '../menu-item-type.model';
+import { PartialMenuSection } from '../menu-provider.model';
 import { ExploreMenuProvider } from './explore.menu';
 
 describe('ExploreMenuProvider', () => {
 
   let provider: ExploreMenuProvider;
-  let sectionDataServiceStub = {
-    findVisibleSections: () => createSuccessfulRemoteDataObject$(createPaginatedList([])),
-  };
+  let sectionDataServiceStub: any;
+
+  const mockSections = [
+    { id: 'publications', componentRows: [], nestedSections: [] },
+    { id: 'researchers', componentRows: [], nestedSections: [] },
+  ];
+
+  function configureTestingModule(enableExplorePages: boolean) {
+    sectionDataServiceStub = {
+      findVisibleSections: jasmine.createSpy('findVisibleSections').and.returnValue(
+        createSuccessfulRemoteDataObject$(createPaginatedList(mockSections)),
+      ),
+    };
 
-  beforeEach(() => {
     TestBed.configureTestingModule({
       providers: [
         ExploreMenuProvider,
-        { provide: APP_CONFIG, useValue: environment },
+        { provide: APP_CONFIG, useValue: { layout: { enableExplorePages } } },
         { provide: SectionDataService, useValue: sectionDataServiceStub },
       ],
     });
     provider = TestBed.inject(ExploreMenuProvider);
+  }
+
+  describe('when enableExplorePages is true', () => {
+    beforeEach(() => {
+      configureTestingModule(true);
+    });
+
+    it('should be created', () => {
+      expect(provider).toBeTruthy();
+    });
+
+    it('should call findVisibleSections on the SectionDataService', (done) => {
+      provider.getSections().subscribe(() => {
+        expect(sectionDataServiceStub.findVisibleSections).toHaveBeenCalled();
+        done();
+      });
+    });
+
+    it('should return menu sections for each visible section', (done) => {
+      const expectedSections: PartialMenuSection[] = [
+        {
+          visible: true,
+          model: {
+            type: MenuItemType.LINK,
+            text: 'menu.section.explore_publications',
+            link: '/explore/publications',
+          },
+        },
+        {
+          visible: true,
+          model: {
+            type: MenuItemType.LINK,
+            text: 'menu.section.explore_researchers',
+            link: '/explore/researchers',
+          },
+        },
+      ];
+
+      provider.getSections().subscribe((sections) => {
+        expect(sections).toEqual(expectedSections);
+        done();
+      });
+    });
   });
 
-  it('should be created', () => {
-    expect(provider).toBeTruthy();
+  describe('when enableExplorePages is false', () => {
+    beforeEach(() => {
+      configureTestingModule(false);
+    });
+
+    it('should be created', () => {
+      expect(provider).toBeTruthy();
+    });
+
+    it('should return an empty array', (done) => {
+      provider.getSections().subscribe((sections) => {
+        expect(sections).toEqual([]);
+        done();
+      });
+    });
+
+    it('should not call findVisibleSections on the SectionDataService', (done) => {
+      provider.getSections().subscribe(() => {
+        expect(sectionDataServiceStub.findVisibleSections).not.toHaveBeenCalled();
+        done();
+      });
+    });
   });
 });

src/app/shared/menu/providers/explore.menu.ts

@@ -6,13 +6,20 @@
  * http://www.dspace.org/license/
  */
 
-import { Injectable } from '@angular/core';
+import {
+  inject,
+  Injectable,
+} from '@angular/core';
+import { APP_CONFIG } from '@dspace/config/app-config.interface';
 import { PaginatedList } from '@dspace/core/data/paginated-list.model';
 import { RemoteData } from '@dspace/core/data/remote-data';
 import { SectionDataService } from '@dspace/core/data/section-data.service';
 import { Section } from '@dspace/core/layout/models/section.model';
 import { getFirstSucceededRemoteData } from '@dspace/core/shared/operators';
-import { Observable } from 'rxjs';
+import {
+  Observable,
+  of,
+} from 'rxjs';
 import { map } from 'rxjs/operators';
 
 import { MenuItemType } from '../menu-item-type.model';
@@ -22,10 +29,13 @@ import {
 } from '../menu-provider.model';
 
 /**
- * Menu provider to create the explore menu sections in the public navbar
+ * Menu provider to create the explore menu sections in the public navbar.
+ * Returns an empty menu when `layout.enableExplorePages` is false.
  */
 @Injectable()
 export class ExploreMenuProvider extends AbstractMenuProvider {
+  protected appConfig = inject(APP_CONFIG);
+
   constructor(
     protected sectionDataService: SectionDataService,
   ) {
@@ -34,8 +44,12 @@ export class ExploreMenuProvider extends AbstractMenuProvider {
 
   /**
    * Retrieves subsections by fetching the browse definitions from the backend and mapping them to partial menu sections.
+   * Returns an empty array when explore pages are disabled in the app configuration.
    */
   getSections(): Observable<PartialMenuSection[]> {
+    if (!this.appConfig.layout.enableExplorePages) {
+      return of([]);
+    }
     return this.sectionDataService.findVisibleSections().pipe(
       getFirstSucceededRemoteData(),
       map((rd: RemoteData<PaginatedList<Section>>) => {

src/config/default-app-config.ts

@@ -746,6 +746,7 @@ export class DefaultAppConfig implements AppConfig {
   // These styles are used in components like MetadataLinkViewComponent to display entity type indicators
   // alongside metadata values, providing visual cues about the type of referenced entity.
   layout: LayoutConfig = {
+    enableExplorePages: true,
     authorityRef: [
       {
         entityType: 'DEFAULT',

src/config/layout-config.interfaces.ts

@@ -62,6 +62,12 @@ export interface AuthorityRefConfig extends Config {
  * @see AppConfig
  */
 export interface LayoutConfig extends Config {
+  /**
+   * Whether explore pages (e.g., /explore/:id) and the explore menu in the navbar are enabled.
+   * When false, explore routes will redirect to 404 and menu entries will be hidden.
+   */
+  enableExplorePages: boolean;
+
   /**
    * Array of authority reference configurations for different entity types.
    * Each entry defines how entities of a specific type should be visually represented with icons and styles.

src/environments/environment.test.ts

@@ -535,6 +535,7 @@ export const environment: BuildConfig = {
 
   // Configuration for layout customization of metadata rendering in Item page
   layout: {
+    enableExplorePages: true,
     authorityRef: [
       {
         entityType: 'DEFAULT',