ZCU-PUB/feat(community): show "Články" collection 3rd, after "Kapitoly v knihách" (#953) (#1492)

* ZCU-PUB/feat(community): show "Články" collection 3rd, after "Kapitoly v knihách" (#953)

Hardcode the display order for the ZCU publications community so that the
"Články" collection appears in 3rd position, immediately after "Kapitoly v
knihách", while all other collections keep their existing alphabetical order.

Approach: the base sub-collection-list component gains a no-op
`applyCustomCollectionOrder` seam applied to each fetched page, keeping
behavior identical for every other theme/customer. The custom theme overrides
it to pin the two named collections via a small, unit-tested pure
`reorderCollections` helper.

Assumption: only the "Články -> 3rd" constraint is encoded here; a full
configurable custom ordering would be the separate Option B feature.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ZCU-PUB/feat(community): also apply "Články" 3rd order in the community browse tree (#953)

The initial fix only reordered the community *detail* page (the themed
sub-collection list). The "Communities & Collections" browse tree
(/community-list) renders collections through CommunityListService and was
still showing the default alphabetical order (Články last).

Extract the ordering rule into a shared pure helper
(shared/zcu-collection-order.ts) and apply it in both places:
- the custom-theme sub-collection-list override (delegates to the helper),
- CommunityListService (reorders each fetched collection page in the tree).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ZCU-PUB/fix(community): pin "Články" directly after "Kapitoly v knihách" (#953)

The previous #953 hardcode force-pinned "Kapitoly v knihách" to the 2nd slot
and "Články" to the 3rd, which is wrong whenever book parts is not naturally
2nd. Per the refined requirement, "Články" must simply follow book parts
wherever it sits: book parts 1st -> articles 2nd, book parts 2nd -> articles
3rd, etc. Book parts and every other collection keep their natural
(alphabetical) order; only "Články" moves.

reorderZcuPublicationCollections now finds book parts, removes "Články", and
re-inserts it immediately after book parts (no-op when either is absent or they
are already adjacent). Constants renamed ZCU_{SECOND,THIRD} ->
ZCU_{BOOKPARTS,ARTICLES}_COLLECTION_NAME to stop implying fixed positions. The
shared helper is used by both the community page (themed sub-collection-list)
and the community browse tree (CommunityListService), so both are fixed.

Verified end-to-end on a seeded Publikační činnost hierarchy: a department with
book parts 2nd shows Články 3rd, and one with book parts 1st shows Články 2nd,
in both the /community-list tree and the community detail page.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* Update docd

* fix(community): match book parts / articles collections by Czech title prefix

Departments name these collections inconsistently ("Články",
"Články / Articles", "Články / Articles (KAE)", and the same pattern for
"Kapitoly v knihách / Bookparts (KAE)"). The exact-name match only handled the
plain Czech variant, so the reorder never fired for most departments. Match by
Czech title prefix (trimmed, case-insensitive) so every bilingual/suffixed
variant is handled regardless of UI language.

* Update docs

---------

Co-authored-by: Matus Kasak <matus.kasak@dataquest.sk>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 3 people

src/app/community-list-page/community-list-service.ts

@@ -25,6 +25,7 @@ import { ShowMoreFlatNode } from './show-more-flat-node.model';
 import { FindListOptions } from '../core/data/find-list-options.model';
 import { AppConfig, APP_CONFIG } from 'src/config/app-config.interface';
 import { v4 as uuidv4 } from 'uuid';
+import { reorderZcuPublicationCollections } from '../shared/zcu-collection-order';
 
 // Helper method to combine and flatten an array of observables of flatNode arrays
 export const combineAndFlatten = (obsList: Observable<FlatNode[]>[]): Observable<FlatNode[]> =>
@@ -255,7 +256,8 @@ export class CommunityListService {
             getFirstCompletedRemoteData(),
             map((rd: RemoteData<PaginatedList<Collection>>) => {
               if (hasValue(rd) && hasValue(rd.payload)) {
-                let nodes = rd.payload.page
+                // apply the ZCU collection display order in the community browse tree
+                let nodes = reorderZcuPublicationCollections(rd.payload.page)
                   .map((collection: Collection) => toFlatNode(collection, observableOf(false), level + 1, false, communityFlatNode));
                 if (currentCollectionPage < rd.payload.totalPages && currentCollectionPage === rd.payload.currentPage) {
                   nodes = [...nodes, showMoreFlatNode(`collection-${uuidv4()}`, level + 1, communityFlatNode)];

src/app/community-page/sub-collection-list/community-page-sub-collection-list.component.ts

@@ -88,10 +88,20 @@ export class CommunityPageSubCollectionListComponent implements OnInit, OnDestro
         });
       })
     ).subscribe((results) => {
-      this.subCollectionsRDObs.next(results);
+      this.subCollectionsRDObs.next(this.applyCustomCollectionOrder(results));
     }));
   }
 
+  /**
+   * Extension point for theme/customer-specific ordering of the current page of collections.
+   *
+   * @param rd the RemoteData holding the current page of collections
+   * @returns the RemoteData to emit, potentially with a reordered page
+   */
+  protected applyCustomCollectionOrder(rd: RemoteData<PaginatedList<Collection>>): RemoteData<PaginatedList<Collection>> {
+    return rd;
+  }
+
   ngOnDestroy(): void {
     this.paginationService.clearPagination(this.config?.id);
     this.subscriptions.map((subscription: Subscription) => subscription.unsubscribe());

src/app/shared/zcu-collection-order.spec.ts

@@ -0,0 +1,114 @@
+import { Collection } from '../core/shared/collection.model';
+import {
+  reorderZcuPublicationCollections,
+  ZCU_ARTICLES_COLLECTION_PREFIX,
+  ZCU_BOOKPARTS_COLLECTION_PREFIX,
+} from './zcu-collection-order';
+
+function fakeCollection(name: string): Collection {
+  return { get name(): string { return name; } } as Collection;
+}
+
+function names(collections: Collection[]): string[] {
+  return collections.map((collection: Collection) => collection.name);
+}
+
+describe('reorderZcuPublicationCollections', () => {
+  it('uses the Czech title prefixes', () => {
+    expect(ZCU_BOOKPARTS_COLLECTION_PREFIX).toBe('Kapitoly v knihách');
+    expect(ZCU_ARTICLES_COLLECTION_PREFIX).toBe('Články');
+  });
+
+  it('moves articles directly after book parts when book parts is 2nd (-> articles 3rd)', () => {
+    const input = [
+      fakeCollection('Habilitace'),
+      fakeCollection('Kapitoly v knihách'),
+      fakeCollection('Sborníky'),
+      fakeCollection('Články'),
+    ];
+
+    expect(names(reorderZcuPublicationCollections(input)))
+      .toEqual(['Habilitace', 'Kapitoly v knihách', 'Články', 'Sborníky']);
+  });
+
+  it('moves articles to 2nd when book parts is 1st', () => {
+    const input = [
+      fakeCollection('Kapitoly v knihách'),
+      fakeCollection('Sborníky'),
+      fakeCollection('Zprávy'),
+      fakeCollection('Články'),
+    ];
+
+    expect(names(reorderZcuPublicationCollections(input)))
+      .toEqual(['Kapitoly v knihách', 'Články', 'Sborníky', 'Zprávy']);
+  });
+
+  it('matches the bilingual, department-suffixed names used in production', () => {
+    const input = [
+      fakeCollection('Disertační práce'),
+      fakeCollection('Kapitoly v knihách / Bookparts (KAE)'),
+      fakeCollection('Konferenční příspěvky'),
+      fakeCollection('Monografie a kolektivní monografie'),
+      fakeCollection('Zprávy'),
+      fakeCollection('Články / Articles (KAE)'),
+    ];
+
+    expect(names(reorderZcuPublicationCollections(input))).toEqual([
+      'Disertační práce',
+      'Kapitoly v knihách / Bookparts (KAE)',
+      'Články / Articles (KAE)',
+      'Konferenční příspěvky',
+      'Monografie a kolektivní monografie',
+      'Zprávy',
+    ]);
+  });
+
+  it('matches mixed variants (plain articles, bilingual book parts)', () => {
+    const input = [
+      fakeCollection('Kapitoly v knihách / Bookparts'),
+      fakeCollection('Sborníky'),
+      fakeCollection('Články'),
+    ];
+
+    expect(names(reorderZcuPublicationCollections(input)))
+      .toEqual(['Kapitoly v knihách / Bookparts', 'Články', 'Sborníky']);
+  });
+
+  it('never moves book parts out of its natural position', () => {
+    const input = [
+      fakeCollection('Abstrakty'),
+      fakeCollection('Habilitace'),
+      fakeCollection('Kapitoly v knihách'),
+      fakeCollection('Články'),
+    ];
+
+    expect(names(reorderZcuPublicationCollections(input)))
+      .toEqual(['Abstrakty', 'Habilitace', 'Kapitoly v knihách', 'Články']);
+  });
+
+  it('leaves the list unchanged when articles is already directly after book parts', () => {
+    const input = [
+      fakeCollection('Habilitace'),
+      fakeCollection('Kapitoly v knihách'),
+      fakeCollection('Články'),
+      fakeCollection('Sborníky'),
+    ];
+
+    expect(reorderZcuPublicationCollections(input)).toBe(input);
+  });
+
+  it('leaves the list unchanged when an anchor collection is missing', () => {
+    expect(names(reorderZcuPublicationCollections([
+      fakeCollection('Knihy'), fakeCollection('Články'),
+    ]))).toEqual(['Knihy', 'Články']);
+
+    expect(names(reorderZcuPublicationCollections([
+      fakeCollection('Knihy'), fakeCollection('Kapitoly v knihách'),
+    ]))).toEqual(['Knihy', 'Kapitoly v knihách']);
+  });
+
+  it('handles empty and single-element input without error', () => {
+    expect(reorderZcuPublicationCollections([])).toEqual([]);
+    expect(names(reorderZcuPublicationCollections([fakeCollection('Knihy')]))).toEqual(['Knihy']);
+  });
+});

src/app/shared/zcu-collection-order.ts

@@ -0,0 +1,42 @@
+import { Collection } from '../core/shared/collection.model';
+
+/**
+ * Title prefix of the collection that anchors the ordering.
+ */
+export const ZCU_BOOKPARTS_COLLECTION_PREFIX = 'Kapitoly v knihách';
+
+/**
+ * Title prefix of the collection pinned directly after book parts.
+ */
+export const ZCU_ARTICLES_COLLECTION_PREFIX = 'Články';
+
+function nameStartsWith(collection: Collection, prefix: string): boolean {
+  const name = collection?.name;
+  return typeof name === 'string' && name.trim().toLocaleLowerCase().startsWith(prefix.toLocaleLowerCase());
+}
+
+/**
+ * Reorders a list of collections so that the articles collection is shown immediately after
+ * the book parts collection, while every other collection keeps its original position.
+ */
+export function reorderZcuPublicationCollections(collections: Collection[]): Collection[] {
+  if (!Array.isArray(collections) || collections.length < 2) {
+    return collections;
+  }
+
+  const bookPartsIndex = collections.findIndex((collection: Collection) => nameStartsWith(collection, ZCU_BOOKPARTS_COLLECTION_PREFIX));
+  const articlesIndex = collections.findIndex((collection: Collection) => nameStartsWith(collection, ZCU_ARTICLES_COLLECTION_PREFIX));
+
+  if (bookPartsIndex === -1 || articlesIndex === -1) {
+    return collections;
+  }
+  if (articlesIndex === bookPartsIndex + 1) {
+    return collections;
+  }
+
+  const articles = collections[articlesIndex];
+  const withoutArticles = collections.filter((_: Collection, index: number) => index !== articlesIndex);
+  const insertAt = withoutArticles.findIndex((collection: Collection) => nameStartsWith(collection, ZCU_BOOKPARTS_COLLECTION_PREFIX)) + 1;
+
+  return [...withoutArticles.slice(0, insertAt), articles, ...withoutArticles.slice(insertAt)];
+}

src/themes/custom/app/community-page/sub-collection-list/community-page-sub-collection-list.component.spec.ts

@@ -0,0 +1,96 @@
+import { Collection } from '../../../../../app/core/shared/collection.model';
+import { CommunityPageSubCollectionListComponent } from './community-page-sub-collection-list.component';
+
+/**
+ * Builds a minimal Collection-like stub that only exposes the `name` getter used by the
+ * reordering logic under test.
+ *
+ * @param name the collection name (dc.title) to expose
+ * @returns an object typed as Collection for the purposes of these tests
+ */
+function fakeCollection(name: string): Collection {
+  return { get name(): string { return name; } } as Collection;
+}
+
+/**
+ * Maps a list of collections to their names for concise assertions.
+ *
+ * @param collections the collections to map
+ * @returns the ordered list of collection names
+ */
+function names(collections: Collection[]): string[] {
+  return collections.map((collection: Collection) => collection.name);
+}
+
+const BOOKPARTS_COLLECTION_NAME = 'Kapitoly v knihách';
+const ARTICLES_COLLECTION_NAME = 'Články';
+
+describe('CommunityPageSubCollectionListComponent (custom theme) reorderCollections', () => {
+  let component: CommunityPageSubCollectionListComponent;
+
+  const reorder = (collections: Collection[]): Collection[] =>
+    (component as any).reorderCollections(collections);
+
+  beforeEach(() => {
+    component = new CommunityPageSubCollectionListComponent(null, null, null);
+  });
+
+  it('shows "Články" directly after "Kapitoly v knihách" (book parts 2nd -> articles 3rd)', () => {
+    const input = [
+      fakeCollection('Alfa'),
+      fakeCollection(BOOKPARTS_COLLECTION_NAME),
+      fakeCollection('Sborníky'),
+      fakeCollection(ARTICLES_COLLECTION_NAME),
+    ];
+
+    const result = reorder(input);
+
+    expect(names(result)).toEqual(['Alfa', BOOKPARTS_COLLECTION_NAME, ARTICLES_COLLECTION_NAME, 'Sborníky']);
+    expect(names(result).indexOf(ARTICLES_COLLECTION_NAME))
+      .toBe(names(result).indexOf(BOOKPARTS_COLLECTION_NAME) + 1);
+  });
+
+  it('shows "Články" 2nd when "Kapitoly v knihách" is 1st', () => {
+    const input = [
+      fakeCollection(BOOKPARTS_COLLECTION_NAME),
+      fakeCollection('Sborníky'),
+      fakeCollection(ARTICLES_COLLECTION_NAME),
+    ];
+
+    expect(names(reorder(input))).toEqual([BOOKPARTS_COLLECTION_NAME, ARTICLES_COLLECTION_NAME, 'Sborníky']);
+  });
+
+  it('leaves the list unchanged when "Kapitoly v knihách" is missing', () => {
+    const input = [
+      fakeCollection('Alfa'),
+      fakeCollection(ARTICLES_COLLECTION_NAME),
+      fakeCollection('Zeta'),
+    ];
+
+    expect(names(reorder(input))).toEqual(['Alfa', ARTICLES_COLLECTION_NAME, 'Zeta']);
+  });
+
+  it('leaves the list unchanged when "Články" is missing', () => {
+    const input = [
+      fakeCollection('Alfa'),
+      fakeCollection(BOOKPARTS_COLLECTION_NAME),
+      fakeCollection('Zeta'),
+    ];
+
+    expect(names(reorder(input))).toEqual(['Alfa', BOOKPARTS_COLLECTION_NAME, 'Zeta']);
+  });
+
+  it('uses the exact diacritic collection names', () => {
+    expect(BOOKPARTS_COLLECTION_NAME).toBe('Kapitoly v knihách');
+    expect(ARTICLES_COLLECTION_NAME).toBe('Články');
+
+    const input = [
+      fakeCollection('Alfa'),
+      fakeCollection('Kapitoly v knihach'),
+      fakeCollection('Clanky'),
+      fakeCollection('Zeta'),
+    ];
+
+    expect(names(reorder(input))).toEqual(['Alfa', 'Kapitoly v knihach', 'Clanky', 'Zeta']);
+  });
+});

src/themes/custom/app/community-page/sub-collection-list/community-page-sub-collection-list.component.ts

@@ -1,6 +1,10 @@
 import { Component } from '@angular/core';
 import { CommunityPageSubCollectionListComponent as BaseComponent }
   from '../../../../../app/community-page/sub-collection-list/community-page-sub-collection-list.component';
+import { RemoteData } from '../../../../../app/core/data/remote-data';
+import { PaginatedList } from '../../../../../app/core/data/paginated-list.model';
+import { Collection } from '../../../../../app/core/shared/collection.model';
+import { reorderZcuPublicationCollections } from '../../../../../app/shared/zcu-collection-order';
 
 @Component({
   selector: 'ds-community-page-sub-collection-list',
@@ -9,4 +13,32 @@ import { CommunityPageSubCollectionListComponent as BaseComponent }
   // templateUrl: './community-page-sub-collection-list.component.html',
   templateUrl: '../../../../../app/community-page/sub-collection-list/community-page-sub-collection-list.component.html'
 })
-export class CommunityPageSubCollectionListComponent extends BaseComponent {}
+export class CommunityPageSubCollectionListComponent extends BaseComponent {
+
+  /**
+   * Reorders the current page of collections so that "Články" is shown directly after
+   * "Kapitoly v knihách", while every other collection keeps its existing alphabetical position.
+   *
+   * @param rd the RemoteData holding the current page of collections
+   * @returns the RemoteData with a reordered page, or unchanged when the page is empty
+   */
+  protected applyCustomCollectionOrder(rd: RemoteData<PaginatedList<Collection>>): RemoteData<PaginatedList<Collection>> {
+    const page = rd?.payload?.page;
+    if (Array.isArray(page) && page.length > 0) {
+      rd.payload.page = this.reorderCollections(page);
+    }
+    return rd;
+  }
+
+  /**
+   * Reorders the current page of collections using the shared ZCU ordering rule,
+   * moving "Články" to sit directly after "Kapitoly v knihách".
+   *
+   * @param collections the collections of the current page (alphabetical by dc.title)
+   * @returns a new, reordered array, or the original array when the rule does not apply
+   */
+  protected reorderCollections(collections: Collection[]): Collection[] {
+    return reorderZcuPublicationCollections(collections);
+  }
+
+}