Merge branch 'w2p-112970_added-missing-breadcrumbs_contribute-7.4' into main

Author: alexandrevryghem

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

@@ -4,6 +4,7 @@ import { BrowseByGuard } from '../browse-by/browse-by-guard';
 import { BrowseByI18nBreadcrumbResolver } from '../browse-by/browse-by-i18n-breadcrumb.resolver';
 import { AuthenticatedGuard } from '../core/auth/authenticated.guard';
 import { CollectionBreadcrumbResolver } from '../core/breadcrumbs/collection-breadcrumb.resolver';
+import { CommunityBreadcrumbResolver } from '../core/breadcrumbs/community-breadcrumb.resolver';
 import { I18nBreadcrumbResolver } from '../core/breadcrumbs/i18n-breadcrumb.resolver';
 import { ComcolBrowseByComponent } from '../shared/comcol/sections/comcol-browse-by/comcol-browse-by.component';
 import { ComcolSearchSectionComponent } from '../shared/comcol/sections/comcol-search-section/comcol-search-section.component';
@@ -24,12 +25,28 @@ import { ItemTemplatePageResolver } from './edit-item-template-page/item-templat
 import { ThemedEditItemTemplatePageComponent } from './edit-item-template-page/themed-edit-item-template-page.component';
 import { ThemedCollectionPageComponent } from './themed-collection-page.component';
 
-
 export const ROUTES: Route[] = [
   {
     path: COLLECTION_CREATE_PATH,
-    component: CreateCollectionPageComponent,
     canActivate: [AuthenticatedGuard, CreateCollectionPageGuard],
+    children: [
+      {
+        path: '',
+        component: CreateCollectionPageComponent,
+        resolve: {
+          breadcrumb: I18nBreadcrumbResolver,
+        },
+        data: {
+          breadcrumbKey: 'collection.create',
+        },
+      },
+    ],
+    data: {
+      breadcrumbQueryParam: 'parent',
+    },
+    resolve: {
+      breadcrumb: CommunityBreadcrumbResolver,
+    },
   },
   {
     path: ':id',

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

@@ -25,8 +25,25 @@ import { ThemedCommunityPageComponent } from './themed-community-page.component'
 export const ROUTES: Route[] = [
   {
     path: COMMUNITY_CREATE_PATH,
-    component: CreateCommunityPageComponent,
+    children: [
+      {
+        path: '',
+        component: CreateCommunityPageComponent,
+        resolve: {
+          breadcrumb: I18nBreadcrumbResolver,
+        },
+        data: {
+          breadcrumbKey: 'community.create',
+        },
+      },
+    ],
     canActivate: [AuthenticatedGuard, CreateCommunityPageGuard],
+    data: {
+      breadcrumbQueryParam: 'parent',
+    },
+    resolve: {
+      breadcrumb: CommunityBreadcrumbResolver,
+    },
   },
   {
     path: ':id',

src/app/core/breadcrumbs/community-breadcrumb.resolver.ts

@@ -1,6 +1,13 @@
 import { Injectable } from '@angular/core';
+import {
+  ActivatedRouteSnapshot,
+  RouterStateSnapshot,
+} from '@angular/router';
+import { Observable } from 'rxjs';
 
+import { BreadcrumbConfig } from '../../breadcrumbs/breadcrumb/breadcrumb-config.model';
 import { COMMUNITY_PAGE_LINKS_TO_FOLLOW } from '../../community-page/community-page.resolver';
+import { hasValue } from '../../shared/empty.util';
 import { FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
 import { CommunityDataService } from '../data/community-data.service';
 import { Community } from '../shared/community.model';
@@ -18,6 +25,23 @@ export class CommunityBreadcrumbResolver extends DSOBreadcrumbResolver<Community
     super(breadcrumbService, dataService);
   }
 
+  /**
+   * Method to retrieve the breadcrumb config by the route id. It is also possible to retrieve the id through the
+   * query parameters. This is done by defining the name of the query parameter in the data section under the property
+   * breadcrumbQueryParam.
+   *
+   * @param route The current {@link ActivatedRouteSnapshot}
+   * @param state The current {@link RouterStateSnapshot}
+   * @returns BreadcrumbConfig object
+   */
+  override resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<BreadcrumbConfig<Community>> {
+    if (hasValue(route.data.breadcrumbQueryParam) && hasValue(route.queryParams[route.data.breadcrumbQueryParam])) {
+      return this.resolveById(route.queryParams[route.data.breadcrumbQueryParam]);
+    } else {
+      return super.resolve(route, state);
+    }
+  }
+
   /**
    * Method that returns the follow links to already resolve
    * The self links defined in this list are expected to be requested somewhere in the near future

src/app/core/breadcrumbs/dso-breadcrumb.resolver.spec.ts

@@ -19,7 +19,10 @@ describe('DSOBreadcrumbResolver', () => {
       uuid = '1234-65487-12354-1235';
       breadcrumbUrl = '/collections/' + uuid;
       currentUrl = breadcrumbUrl + '/edit';
-      testCollection = Object.assign(new Collection(), { uuid });
+      testCollection = Object.assign(new Collection(), {
+        uuid: uuid,
+        type: 'collection',
+      });
       dsoBreadcrumbService = {};
       collectionService = {
         findById: (id: string) => createSuccessfulRemoteDataObject$(testCollection),

src/app/core/breadcrumbs/dso-breadcrumb.resolver.ts

@@ -7,6 +7,7 @@ import {
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 
+import { getDSORoute } from '../../app-routing-paths';
 import { BreadcrumbConfig } from '../../breadcrumbs/breadcrumb/breadcrumb-config.model';
 import { hasValue } from '../../shared/empty.util';
 import { FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
@@ -39,15 +40,22 @@ export abstract class DSOBreadcrumbResolver<T extends ChildHALResource & DSpaceO
    * @returns BreadcrumbConfig object
    */
   resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<BreadcrumbConfig<T>> {
-    const uuid = route.params.id;
+    return this.resolveById(route.params.id);
+  }
+
+  /**
+   * Method for resolving a breadcrumb by id
+   *
+   * @param uuid The uuid to resolve
+   * @returns BreadcrumbConfig object
+   */
+  resolveById(uuid: string): Observable<BreadcrumbConfig<T>> {
     return this.dataService.findById(uuid, true, false, ...this.followLinks).pipe(
       getFirstCompletedRemoteData(),
       getRemoteDataPayload(),
       map((object: T) => {
         if (hasValue(object)) {
-          const fullPath = state.url;
-          const url = fullPath.substr(0, fullPath.indexOf(uuid)) + uuid;
-          return { provider: this.breadcrumbService, key: object, url: url };
+          return { provider: this.breadcrumbService, key: object, url: getDSORoute(object) };
         } else {
           return undefined;
         }

src/app/core/submission/resolver/submission-links-to-follow.ts

@@ -0,0 +1,17 @@
+import {
+  followLink,
+  FollowLinkConfig,
+} from '../../../shared/utils/follow-link-config.model';
+import { WorkflowItem } from '../models/workflowitem.model';
+import { WorkspaceItem } from '../models/workspaceitem.model';
+
+/**
+ * The self links defined in this list are expected to be requested somewhere in the near future
+ * Requesting them as embeds will limit the number of requests
+ *
+ * Needs to be in a separate file to prevent circular dependencies in webpack.
+ */
+export const SUBMISSION_LINKS_TO_FOLLOW: FollowLinkConfig<WorkflowItem | WorkspaceItem>[] = [
+  followLink('item'),
+  followLink('collection'),
+];

src/app/core/submission/resolver/submission-object.resolver.ts

@@ -4,38 +4,36 @@ import {
   Resolve,
   RouterStateSnapshot,
 } from '@angular/router';
-import { Store } from '@ngrx/store';
 import { Observable } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
 
-import { followLink } from '../../../shared/utils/follow-link-config.model';
 import { IdentifiableDataService } from '../../data/base/identifiable-data.service';
 import { RemoteData } from '../../data/remote-data';
 import { getFirstCompletedRemoteData } from '../../shared/operators';
+import { SUBMISSION_LINKS_TO_FOLLOW } from './submission-links-to-follow';
 
 /**
  * This class represents a resolver that requests a specific item before the route is activated
  */
 @Injectable({ providedIn: 'root' })
 export class SubmissionObjectResolver<T> implements Resolve<RemoteData<T>> {
   constructor(
-      protected dataService: IdentifiableDataService<any>,
-      protected store: Store<any>,
+    protected dataService: IdentifiableDataService<any>,
   ) {
   }
 
   /**
-     * Method for resolving an item based on the parameters in the current route
-     * @param {ActivatedRouteSnapshot} route The current ActivatedRouteSnapshot
-     * @param {RouterStateSnapshot} state The current RouterStateSnapshot
-     * @returns Observable<<RemoteData<Item>> Emits the found item based on the parameters in the current route,
-     * or an error if something went wrong
-     */
+   * Method for resolving an item based on the parameters in the current route
+   * @param {ActivatedRouteSnapshot} route The current ActivatedRouteSnapshot
+   * @param {RouterStateSnapshot} state The current RouterStateSnapshot
+   * @returns Observable<<RemoteData<Item>> Emits the found item based on the parameters in the current route,
+   * or an error if something went wrong
+   */
   resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<RemoteData<T>> {
     const itemRD$ = this.dataService.findById(route.params.id,
       true,
       false,
-      followLink('item'),
+      ...SUBMISSION_LINKS_TO_FOLLOW,
     ).pipe(
       getFirstCompletedRemoteData(),
       switchMap((wfiRD: RemoteData<any>) => wfiRD.payload.item as Observable<RemoteData<T>>),

src/app/core/submission/resolver/submission-parent-breadcrumb.resolver.ts

@@ -0,0 +1,51 @@
+import {
+  ActivatedRouteSnapshot,
+  Resolve,
+  RouterStateSnapshot,
+} from '@angular/router';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { BreadcrumbConfig } from '../../../breadcrumbs/breadcrumb/breadcrumb-config.model';
+import { IdentifiableDataService } from '../../data/base/identifiable-data.service';
+import {
+  getFirstCompletedRemoteData,
+  getRemoteDataPayload,
+} from '../../shared/operators';
+import { SubmissionObject } from '../models/submission-object.model';
+import { SubmissionParentBreadcrumbsService } from '../submission-parent-breadcrumb.service';
+import { SUBMISSION_LINKS_TO_FOLLOW } from './submission-links-to-follow';
+
+/**
+ * This class represents a resolver that requests a specific item before the route is activated
+ */
+export abstract class SubmissionParentBreadcrumbResolver implements Resolve<BreadcrumbConfig<SubmissionObject>> {
+
+  protected constructor(
+    protected dataService: IdentifiableDataService<any>,
+    protected breadcrumbService: SubmissionParentBreadcrumbsService,
+  ) {
+  }
+
+  /**
+   * Method for resolving an item based on the parameters in the current route
+   * @param {ActivatedRouteSnapshot} route The current ActivatedRouteSnapshot
+   * @param {RouterStateSnapshot} state The current RouterStateSnapshot
+   * @returns Observable<<RemoteData<Item>> Emits the found item based on the parameters in the current route,
+   * or an error if something went wrong
+   */
+  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<BreadcrumbConfig<SubmissionObject>> {
+    return this.dataService.findById(route.params.id,
+      true,
+      false,
+      ...SUBMISSION_LINKS_TO_FOLLOW,
+    ).pipe(
+      getFirstCompletedRemoteData(),
+      getRemoteDataPayload(),
+      map((submissionObject: SubmissionObject) => ({
+        provider: this.breadcrumbService,
+        key: submissionObject,
+      } as BreadcrumbConfig<SubmissionObject>)),
+    );
+  }
+}

src/app/core/submission/submission-parent-breadcrumb.service.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import {
+  combineLatest,
+  Observable,
+  of as observableOf,
+  switchMap,
+} from 'rxjs';
+
+import { getDSORoute } from '../../app-routing-paths';
+import { Breadcrumb } from '../../breadcrumbs/breadcrumb/breadcrumb.model';
+import { hasValue } from '../../shared/empty.util';
+import { SubmissionService } from '../../submission/submission.service';
+import { BreadcrumbsProviderService } from '../breadcrumbs/breadcrumbsProviderService';
+import { DSOBreadcrumbsService } from '../breadcrumbs/dso-breadcrumbs.service';
+import { DSONameService } from '../breadcrumbs/dso-name.service';
+import { CollectionDataService } from '../data/collection-data.service';
+import { RemoteData } from '../data/remote-data';
+import { Collection } from '../shared/collection.model';
+import {
+  getFirstCompletedRemoteData,
+  getRemoteDataPayload,
+} from '../shared/operators';
+import { SubmissionObject } from './models/submission-object.model';
+
+/**
+ * Service to calculate the parent {@link DSpaceObject} breadcrumbs for a {@link SubmissionObject}
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class SubmissionParentBreadcrumbsService implements BreadcrumbsProviderService<SubmissionObject> {
+
+  constructor(
+    protected dsoNameService: DSONameService,
+    protected dsoBreadcrumbsService: DSOBreadcrumbsService,
+    protected submissionService: SubmissionService,
+    protected collectionService: CollectionDataService,
+  ) {
+  }
+
+  /**
+   * Creates the parent breadcrumb structure for {@link SubmissionObject}s. It also automatically recreates the
+   * parent breadcrumb structure when you change a {@link SubmissionObject}'s by dispatching a
+   * {@link ChangeSubmissionCollectionAction}.
+   *
+   * @param submissionObject The {@link SubmissionObject} for which the parent breadcrumb structure needs to be created
+   */
+  getBreadcrumbs(submissionObject: SubmissionObject): Observable<Breadcrumb[]> {
+    return combineLatest([
+      (submissionObject.collection as Observable<RemoteData<Collection>>).pipe(
+        getFirstCompletedRemoteData(),
+        getRemoteDataPayload(),
+      ),
+      this.submissionService.getSubmissionCollectionId(submissionObject.id),
+    ]).pipe(
+      switchMap(([collection, latestCollectionId]: [Collection, string]) => {
+        if (hasValue(latestCollectionId)) {
+          return this.collectionService.findById(latestCollectionId).pipe(
+            getFirstCompletedRemoteData(),
+            getRemoteDataPayload(),
+          );
+        } else {
+          return observableOf(collection);
+        }
+      }),
+      switchMap((collection: Collection) => this.dsoBreadcrumbsService.getBreadcrumbs(collection, getDSORoute(collection))),
+    );
+  }
+
+}

src/app/submission/submission.service.ts

@@ -1,7 +1,12 @@
 import { HttpHeaders } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Router } from '@angular/router';
-import { Store } from '@ngrx/store';
+import {
+  createSelector,
+  MemoizedSelector,
+  select,
+  Store,
+} from '@ngrx/store';
 import { TranslateService } from '@ngx-translate/core';
 import {
   Observable,
@@ -71,6 +76,20 @@ import {
   SubmissionState,
 } from './submission.reducers';
 
+function getSubmissionSelector(submissionId: string):  MemoizedSelector<SubmissionState, SubmissionObjectEntry> {
+  return createSelector(
+    submissionSelector,
+    (state: SubmissionState) => state.objects[submissionId],
+  );
+}
+
+function getSubmissionCollectionIdSelector(submissionId: string): MemoizedSelector<SubmissionState, string> {
+  return createSelector(
+    getSubmissionSelector(submissionId),
+    (submission: SubmissionObjectEntry) => submission?.collection,
+  );
+}
+
 /**
  * A service that provides methods used in submission process.
  */
@@ -120,10 +139,19 @@ export class SubmissionService {
    * @param collectionId
    *    The collection id
    */
-  changeSubmissionCollection(submissionId, collectionId) {
+  changeSubmissionCollection(submissionId: string, collectionId: string): void {
     this.store.dispatch(new ChangeSubmissionCollectionAction(submissionId, collectionId));
   }
 
+  /**
+   * Listen to collection changes for a certain {@link SubmissionObject}
+   *
+   * @param submissionId The submission id
+   */
+  getSubmissionCollectionId(submissionId: string): Observable<string> {
+    return this.store.pipe(select(getSubmissionCollectionIdSelector(submissionId)));
+  }
+
   /**
    * Perform a REST call to create a new workspaceitem and return response
    *