Restore vanilla's locale service (D7) and default the UI base URL to UI_URL

Two problems an independent review found in the previous two commits.

**D7 was not implemented as decided.** The instruction was to prefer vanilla unless
it breaks CLARIN functionality. `locale.service.ts` on the base branch is byte-identical
to `dspace-7.6.5`, i.e. the fork never customised it and a 3-way merge could not have
conflicted - yet the head carried a third blob with 7.6.5's logic. That silently dropped
vanilla's language-detection fix: the full Accept-Language q-list scan, case-insensitive
matching (`DE` and `en-GB` fell through to defaultLanguage), and "don't write an
auto-detected language to the cookie". Worse, the specs had been rewritten to assert the
old behaviour and vanilla's case-insensitivity test deleted, so green CI proved nothing.

`locale.service.ts`, `locale.service.spec.ts` and `locale.interceptor.spec.ts` are now
byte-identical to `dspace-7.6.7` again (verified with `git diff --numstat`).

The reason for the original revert was real: five CLARIN call sites are synchronous
template getters, and vanilla's `getCurrentLanguageCode()` has to be an Observable because
`getLanguageCodeList()` depends on the auth state. But those call sites do not want language
*negotiation* - they want the language the UI is currently rendering in. So they now use a
new, additive `getCurrentLanguageCodeSync()`, and vanilla's method is untouched. The CLARIN
test lives in a separate `locale.service.clarin.spec.ts` so the upstream spec stays
byte-identical and does not re-conflict on the next merge.

**`DSPACE_UI_BASEURL` ignored an existing convention and would have bricked every deploy.**
`UI_URL` is already defined in `build-scripts/run/envs/*` and already feeds the backend's
`dspace.ui.url` via `docker-compose-rest.yml` and `cli.yml` - the same value `ui.baseUrl` is
documented to hold. Requiring a brand-new variable with no default meant `start.sh`,
`deploy.yml` and every documented `docker/README.md` recipe would abort, and an override
compose file cannot rescue it because compose interpolates per file before merging.

`DSPACE_UI_BASEURL` now defaults to `UI_URL` and only fails when neither is set. Verified:

    envs/.default (UI_URL only)  -> DSPACE_UI_BASEURL: http://dev-5.pc
    neither set                  -> error: required variable UI_URL is missing a value
    DSPACE_UI_BASEURL explicit   -> wins over UI_URL

`envs/.local` gained `UI_URL`; `docker/README.md` now carries the requirement next to the
recipes that need it. Two corrections to the earlier rationale: the blast radius also
includes the Google Scholar `citation_pdf_url` / `citation_abstract_html_url` meta tags, and
the pre-upgrade derived value was `http://dspace-angular:4000/`, not a working public URL -
so this fixes a long-standing wrong value rather than a regression the upgrade introduced.
The namespace caveat is now documented: `DSPACE_UI_NAMESPACE` must match the path in the URL
or the legacy-bitstream redirect drops the prefix.

Tests: locale specs 21 SUCCESS (16 upstream incl. the restored case-insensitivity test, plus
5 new), header/clarin-license-info/html-content specs 9 SUCCESS, lint clean on all changed
files.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: milanmajchrak

README-dtq.md

@@ -121,16 +121,33 @@ DSPACE_NAMESPACE # The namespace of the angular application
 DSPACE_SSL # Whether the angular application uses SSL [true/false]
 ```
 
-**Required since 7.6.7:**
+**Required since 7.6.7 - the public UI URL:**
 
 ```bash
-DSPACE_UI_BASEURL # Public URL this UI answers on, e.g. https://lindat.example.org/repository
+UI_URL            # Public URL this UI answers on, e.g. https://lindat.example.org/repository
+DSPACE_UI_BASEURL # Optional override; defaults to UI_URL
 ```
 
-`ui.baseUrl` used to be derived from `DSPACE_HOST`/`DSPACE_PORT`/`DSPACE_SSL`; 7.6.7 replaced that with a
-hardcoded `http://localhost:4000` default. It is used for legacy `/bitstream/handle/...` redirects and for
-the `robots.txt` Sitemap, so leaving it at the default silently breaks historical citation URLs.
-`docker/docker-compose.yml` therefore requires it - the stack refuses to start if it is missing from `.env`.
+`ui.baseUrl` used to be derived from `DSPACE_HOST`/`DSPACE_PORT`/`DSPACE_SSL`. 7.6.7 replaced that with a
+hardcoded `http://localhost:4000` default and dropped the Host-header trust, so those variables no longer
+affect it. Note this was never a *working* public URL in Docker either - the compose file pins
+`DSPACE_UI_HOST: dspace-angular`, so the derived value used to be `http://dspace-angular:4000/`. The change is
+that a wrong value is now the same wrong value everywhere instead of an internal hostname.
+
+It matters because `ui.baseUrl` feeds more than it looks: legacy `/bitstream/handle/...` 301 redirects, the
+`robots.txt` `Sitemap:` line, and the Google Scholar `citation_pdf_url` / `citation_abstract_html_url` meta
+tags on every item page. All of them fail silently, with no log line.
+
+`UI_URL` already existed in the env files and already feeds the backend's `dspace.ui.url`
+(`docker-compose-rest.yml`, `cli.yml`) - the two are meant to be the same value, which is exactly what
+`config.example.yml` says about `ui.baseUrl`. `docker/docker-compose.yml` therefore defaults
+`DSPACE_UI_BASEURL` to `UI_URL`, and refuses to start if neither is set.
+
+> **If the UI is served under a namespace** (e.g. `/repository`), set `DSPACE_UI_NAMESPACE` to the same path
+> that appears in `UI_URL`. They are independent settings with no cross-check, and the legacy-bitstream
+> redirect builds its target from `nameSpace + route` resolved against `baseUrl` - so a namespaced `UI_URL`
+> with `DSPACE_UI_NAMESPACE` left at `/` produces a URL without the prefix, i.e. a 404 on every legacy
+> citation link.
 
 All other settings can be set using the following convention for naming the environment variables:
 

build-scripts/run/envs/.local

@@ -1,2 +1,3 @@
 DSPACE_UI_HOST=0.0.0.0
 DSPACE_UI_IMAGE=dspace-angular
+UI_URL=http://localhost:4000

docker/README.md

@@ -58,6 +58,12 @@ A default/demo version of this image is built *automatically*.
   - Docker compose file that will download and install data into a DSpace REST assetstore.  This script points to a default dataset that will be utilized for CI testing.
 
 
+> **Required since 7.6.7:** every recipe below that uses `docker/docker-compose.yml` needs the public UI URL.
+> Set `UI_URL` (or `DSPACE_UI_BASEURL`) in your env file - `build-scripts/run/envs/.default` and `.local`
+> already do. Without it compose refuses to start, because 7.6.7 no longer derives `ui.baseUrl` from
+> `DSPACE_UI_HOST`/`PORT`/`SSL` and would otherwise serve `http://localhost:4000` in redirects, `robots.txt`
+> and the Google Scholar citation meta tags. See `README-dtq.md` for the namespace caveat.
+
 ## To refresh / pull DSpace images from Dockerhub
 ```
 docker-compose -f docker/docker-compose.yml pull

docker/docker-compose.yml

@@ -23,10 +23,15 @@ services:
       DSPACE_UI_PORT: 4000
       DSPACE_UI_NAMESPACE: ${DSPACE_UI_NAMESPACE:-/}
       # Public URL this UI answers on. Since 7.6.7 `ui.baseUrl` is no longer derived from
-      # DSPACE_UI_HOST/PORT/SSL, so it MUST be set explicitly in `.env` - otherwise legacy
-      # /bitstream/handle/... redirects and robots.txt Sitemap point at localhost.
-      # Intentionally has no default: a missing value fails the stack instead of failing silently.
-      DSPACE_UI_BASEURL: ${DSPACE_UI_BASEURL:?set it in .env to the public UI URL, e.g. https://lindat.example.org/repository}
+      # DSPACE_UI_HOST/PORT/SSL, so it has to be set explicitly - otherwise legacy
+      # /bitstream/handle/... redirects, the robots.txt Sitemap and the Google Scholar
+      # citation_* meta tags all point at localhost, silently.
+      # Defaults to UI_URL, which the env files already define and which also feeds the backend's
+      # `dspace.ui.url` (see docker-compose-rest.yml) - the two are meant to be the same value.
+      # If neither is set the stack refuses to start rather than serving wrong URLs.
+      # NOTE: if the UI is served under a namespace, DSPACE_UI_NAMESPACE must match the path in
+      # this URL, otherwise the legacy-bitstream redirect drops the prefix and 404s.
+      DSPACE_UI_BASEURL: ${DSPACE_UI_BASEURL:-${UI_URL:?set UI_URL (or DSPACE_UI_BASEURL) in the env file to the public UI URL, e.g. https://lindat.example.org/repository}}
       DSPACE_REST_SSL: ${DSPACE_SSL:-false}
       DSPACE_REST_HOST: ${DSPACE_HOST:-localhost}
       DSPACE_REST_PORT: ${DSPACE_REST_PORT:-8080}

src/app/core/locale/locale.interceptor.spec.ts

@@ -44,7 +44,7 @@ describe(`LocaleInterceptor`, () => {
     httpMock = TestBed.inject(HttpTestingController);
     localeService = TestBed.inject(LocaleService);
 
-    localeService.getCurrentLanguageCode.and.returnValue('en');
+    localeService.getCurrentLanguageCode.and.returnValue(of('en'));
   });
 
   describe('', () => {

src/app/core/locale/locale.service.clarin.spec.ts

@@ -0,0 +1,93 @@
+import { TestBed, waitForAsync } from '@angular/core/testing';
+
+import { TranslateLoader, TranslateModule, TranslateService } from '@ngx-translate/core';
+
+import { CookieService } from '../services/cookie.service';
+import { CookieServiceMock } from '../../shared/mocks/cookie.service.mock';
+import { TranslateLoaderMock } from '../../shared/mocks/translate-loader.mock';
+import { LANG_COOKIE, LocaleService } from './locale.service';
+import { AuthService } from '../auth/auth.service';
+import { NativeWindowRef } from '../services/window.service';
+import { RouteService } from '../services/route.service';
+import { routeServiceStub } from '../../shared/testing/route-service.stub';
+import { environment } from '../../../environments/environment';
+
+/**
+ * CLARIN-only additions to LocaleService.
+ *
+ * Kept in a separate file so `locale.service.spec.ts` stays byte-identical to upstream and does not
+ * re-conflict on the next vanilla merge.
+ */
+describe('LocaleService CLARIN additions', () => {
+  let service: LocaleService;
+  let cookieService: CookieService;
+  let translateService: TranslateService;
+  let window;
+  let spyOnGet;
+  let authService;
+  let routeService;
+  let document;
+
+  authService = jasmine.createSpyObj('AuthService', {
+    isAuthenticated: jasmine.createSpy('isAuthenticated'),
+    isAuthenticationLoaded: jasmine.createSpy('isAuthenticationLoaded'),
+    getAuthenticatedUserFromStore: jasmine.createSpy('getAuthenticatedUserFromStore'),
+  });
+
+  beforeEach(waitForAsync(() => {
+    return TestBed.configureTestingModule({
+      imports: [
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useClass: TranslateLoaderMock
+          }
+        }),
+      ],
+      providers: [
+        { provide: CookieService, useValue: new CookieServiceMock() },
+        { provide: AuthService, userValue: authService },
+        { provide: RouteService, useValue: routeServiceStub },
+        { provide: Document, useValue: document },
+      ]
+    });
+  }));
+
+  beforeEach(() => {
+    cookieService = TestBed.inject(CookieService);
+    translateService = TestBed.inject(TranslateService);
+    routeService = TestBed.inject(RouteService);
+    window = new NativeWindowRef();
+    document = { documentElement: { lang: 'en' } };
+    service = new LocaleService(window, cookieService, translateService, authService, routeService, document);
+    spyOnGet = spyOn(cookieService, 'get');
+  });
+
+  describe('getCurrentLanguageCodeSync', () => {
+    it('should return the language the UI is currently rendering in', () => {
+      translateService.use('cs');
+      expect(service.getCurrentLanguageCodeSync()).toBe('cs');
+    });
+
+    it('should fall back to the cookie before any language has been applied', () => {
+      spyOnGet.withArgs(LANG_COOKIE).and.returnValue('de');
+      expect(service.getCurrentLanguageCodeSync()).toBe('de');
+    });
+
+    it('should fall back to the default language when there is neither', () => {
+      spyOnGet.and.returnValue(undefined);
+      expect(service.getCurrentLanguageCodeSync()).toBe(environment.defaultLanguage);
+    });
+
+    it('should track setCurrentLanguageCode', () => {
+      service.setCurrentLanguageCode('cs');
+      expect(service.getCurrentLanguageCodeSync()).toBe('cs');
+    });
+
+    it('should be synchronous - the header and licence templates call it directly', () => {
+      translateService.use('en');
+      const result: string = service.getCurrentLanguageCodeSync();
+      expect(typeof result).toBe('string');
+    });
+  });
+});

src/app/core/locale/locale.service.spec.ts

@@ -66,33 +66,51 @@ describe('LocaleService test suite', () => {
   });
 
   describe('getCurrentLanguageCode', () => {
+    let testScheduler: TestScheduler;
+
     beforeEach(() => {
       spyOn(translateService, 'getLangs').and.returnValue(langList);
+      testScheduler = new TestScheduler((actual, expected) => {
+        // use jasmine to test equality
+        expect(actual).toEqual(expected);
+      });
+      authService.isAuthenticated.and.returnValue(of(false));
+      authService.isAuthenticationLoaded.and.returnValue(of(false));
     });
 
     it('should return the language saved on cookie if it\'s a valid & active language', () => {
       spyOnGet.and.returnValue('de');
-      expect(service.getCurrentLanguageCode()).toBe('de');
+      testScheduler.run(({expectObservable}) => {
+        expectObservable(service.getCurrentLanguageCode()).toBe('(a|)', { a: 'de' });
+      });
     });
 
     it('should return the default language if the cookie language is disabled', () => {
       spyOnGet.and.returnValue('disabled');
-      expect(service.getCurrentLanguageCode()).toBe('en');
+      testScheduler.run(({expectObservable}) => {
+        expectObservable(service.getCurrentLanguageCode()).toBe('(a|)', { a: 'en' });
+      });
     });
 
     it('should return the default language if the cookie language does not exist', () => {
       spyOnGet.and.returnValue('does-not-exist');
-      expect(service.getCurrentLanguageCode()).toBe('en');
+      testScheduler.run(({expectObservable}) => {
+        expectObservable(service.getCurrentLanguageCode()).toBe('(a|)', { a: 'en' });
+      });
     });
 
     it('should return language from browser setting', () => {
-      spyOn(translateService, 'getBrowserLang').and.returnValue('xx');
-      expect(service.getCurrentLanguageCode()).toBe('xx');
+      spyOn(service, 'getLanguageCodeList').and.returnValue(of(['xx', 'en']));
+      testScheduler.run(({expectObservable}) => {
+        expectObservable(service.getCurrentLanguageCode()).toBe('(a|)', { a: 'xx' });
+      });
     });
 
-    it('should return default language from config', () => {
-      spyOn(translateService, 'getBrowserLang').and.returnValue('fr');
-      expect(service.getCurrentLanguageCode()).toBe('en');
+    it('should match language from browser setting case insensitive', () => {
+      spyOn(service, 'getLanguageCodeList').and.returnValue(of(['DE', 'en']));
+      testScheduler.run(({expectObservable}) => {
+        expectObservable(service.getCurrentLanguageCode()).toBe('(a|)', { a: 'DE' });
+      });
     });
   });
 
@@ -153,14 +171,13 @@ describe('LocaleService test suite', () => {
     });
 
     it('should set the current language', () => {
-      spyOn(service, 'getCurrentLanguageCode').and.returnValue('es');
+      spyOn(service, 'getCurrentLanguageCode').and.returnValue(of('es'));
       service.setCurrentLanguageCode();
       expect(translateService.use).toHaveBeenCalledWith('es');
-      expect(service.saveLanguageCodeToCookie).toHaveBeenCalledWith('es');
     });
 
     it('should set the current language on the html tag', () => {
-      spyOn(service, 'getCurrentLanguageCode').and.returnValue('es');
+      spyOn(service, 'getCurrentLanguageCode').and.returnValue(of('es'));
       service.setCurrentLanguageCode();
       expect((service as any).document.documentElement.lang).toEqual('es');
     });

src/app/core/locale/locale.service.ts

@@ -1,12 +1,12 @@
-import { Inject, Injectable } from '@angular/core';
+import { Inject, Injectable, OnDestroy } from '@angular/core';
 
 import { TranslateService } from '@ngx-translate/core';
 
-import { isEmpty, isNotEmpty } from '../../shared/empty.util';
+import { isEmpty, isNotEmpty, hasValue } from '../../shared/empty.util';
 import { CookieService } from '../services/cookie.service';
 import { environment } from '../../../environments/environment';
 import { AuthService } from '../auth/auth.service';
-import { combineLatest, Observable, of as observableOf } from 'rxjs';
+import { combineLatest, Observable, of as observableOf, Subscription } from 'rxjs';
 import { map, mergeMap, take } from 'rxjs/operators';
 import { NativeWindowRef, NativeWindowService } from '../services/window.service';
 import { RouteService } from '../services/route.service';
@@ -28,13 +28,15 @@ export enum LANG_ORIGIN {
  * Service to provide localization handler
  */
 @Injectable()
-export class LocaleService {
+export class LocaleService implements OnDestroy {
 
   /**
    * Eperson language metadata
    */
   EPERSON_LANG_METADATA = 'eperson.language';
 
+  subs: Subscription[] = [];
+
   constructor(
     @Inject(NativeWindowService) protected _window: NativeWindowRef,
     protected cookie: CookieService,
@@ -48,20 +50,43 @@ export class LocaleService {
   /**
    * Get the language currently used
    *
-   * @returns {string} The language code
+   * @returns {Observable<string>} The language code
    */
-  getCurrentLanguageCode(): string {
+  getCurrentLanguageCode(): Observable<string> {
     // Attempt to get the language from a cookie
     let lang = this.getLanguageCodeFromCookie();
     if (isEmpty(lang) || environment.languages.find((langConfig: LangConfig) => langConfig.code === lang && langConfig.active) === undefined) {
       // Attempt to get the browser language from the user
-      if (this.translate.getLangs().includes(this.translate.getBrowserLang())) {
-        lang = this.translate.getBrowserLang();
-      } else {
-        lang = environment.defaultLanguage;
-      }
+      return this.getLanguageCodeList()
+        .pipe(
+          map(browserLangs => {
+            return browserLangs
+              .map(browserLang => browserLang.split(';')[0])
+              .find(browserLang =>
+                this.translate.getLangs().some(userLang => userLang.toLowerCase() === browserLang.toLowerCase())
+              ) || environment.defaultLanguage;
+          }),
+        );
     }
-    return lang;
+    return observableOf(lang);
+  }
+
+  /**
+   * CLARIN: the language the UI is currently rendering in, available synchronously.
+   *
+   * This is deliberately NOT a synchronous variant of {@link getCurrentLanguageCode}. That method
+   * *negotiates* the initial language against the authenticated user's profile and the browser's
+   * Accept-Language list, which requires the auth state and is therefore asynchronous.
+   *
+   * The fork's header and licence components need something different and much simpler: the
+   * language currently in effect, inside synchronous template getters. Once
+   * {@link setCurrentLanguageCode} has run, that is whatever `translate.use()` last applied.
+   *
+   * @returns {string} The active language code
+   */
+  getCurrentLanguageCodeSync(): string {
+    const lang = this.translate.currentLang || this.getLanguageCodeFromCookie();
+    return isNotEmpty(lang) ? lang : environment.defaultLanguage;
   }
 
   /**
@@ -145,11 +170,16 @@ export class LocaleService {
    */
   setCurrentLanguageCode(lang?: string): void {
     if (isEmpty(lang)) {
-      lang = this.getCurrentLanguageCode();
+      this.subs.push(this.getCurrentLanguageCode().subscribe(curLang => {
+        lang = curLang;
+        this.translate.use(lang);
+        this.document.documentElement.lang = lang;
+      }));
+    } else {
+      this.saveLanguageCodeToCookie(lang);
+      this.translate.use(lang);
+      this.document.documentElement.lang = lang;
     }
-    this.translate.use(lang);
-    this.saveLanguageCodeToCookie(lang);
-    this.document.documentElement.lang = lang;
   }
 
   /**
@@ -195,4 +225,10 @@ export class LocaleService {
 
   }
 
+  ngOnDestroy(): void {
+    this.subs
+      .filter((sub) => hasValue(sub))
+      .forEach((sub) => sub.unsubscribe());
+  }
+
 }

src/app/header/header.component.spec.ts

@@ -22,7 +22,7 @@ describe('HeaderComponent', () => {
 
   // Mock LocaleService
   const localeServiceMock = {
-    getCurrentLanguageCode: () => 'en' // returns default language code
+    getCurrentLanguageCodeSync: () => 'en' // returns default language code
   };
 
   // waitForAsync beforeEach