[DSpace-CRIS] Administrative Edit of archived items via submission form and security configuration for metadata visibility (Frontend)

config/config.example.yml

@@ -405,6 +405,20 @@ homePage:
 item:
   edit:
     undoTimeout: 10000 # 10 seconds
+    # Defines the security levels available for metadata fields.
+    # Each level maps to a numeric value stored on the metadata field in the backend and controls visibility of that field based on the user's role.
+    # Levels are displayed as toggle buttons in the metadata edit UI.
+    security:
+      levels:
+          - value: 0       # Public — visible to everyone
+            icon: fa fa-globe
+            color: green
+          - value: 1       # Registered users — visible to authenticated users only
+            icon: fa fa-key
+            color: orange
+          - value: 2       # Administrators only — restricted to admin users
+            icon: fa fa-lock
+            color: red
   # Show the item access status label in items lists
   showAccessStatuses: false
   bitstream:
@@ -419,7 +433,6 @@ item:
     # Metdadata list to be displayed for entities without a specific configuration
     fallbackMetdataList:
       - dc.description.abstract
-      - dc.description.note
     # Configuration for each entity type
     entityDataConfig:
       - entityType: Person

src/app/app-routes.ts

@@ -28,6 +28,7 @@ import { ACCESS_CONTROL_MODULE_PATH } from './access-control/access-control-rout
 import { NOTIFICATIONS_MODULE_PATH } from './admin/admin-routing-paths';
 import {
   ADMIN_MODULE_PATH,
+  EDIT_ITEM_PATH,
   FORGOT_PASSWORD_PATH,
   HEALTH_PAGE_PATH,
   PROFILE_MODULE_PATH,
@@ -280,6 +281,11 @@ export const APP_ROUTES: Route[] = [
           .then((m) => m.ROUTES),
         canActivate: [authenticatedGuard],
       },
+      {
+        path: EDIT_ITEM_PATH,
+        loadChildren: () => import('./edit-item/edit-item-routes').then((m) => m.ROUTES),
+        canActivate: [endUserAgreementCurrentUserGuard],
+      },
       {
         path: 'external-login/:token',
         loadChildren: () => import('./external-login-page/external-login-routes').then((m) => m.ROUTES),

src/app/app.menus.ts

@@ -22,6 +22,7 @@ import { DSpaceObjectEditMenuProvider } from './shared/menu/providers/dso-edit.m
 import { DsoOptionMenuProvider } from './shared/menu/providers/dso-option.menu';
 import { EditMenuProvider } from './shared/menu/providers/edit.menu';
 import { EditCMSMetadataMenuProvider } from './shared/menu/providers/edit-cms-metadata.menu';
+import { EditItemMenuProvider } from './shared/menu/providers/edit-item-details.menu';
 import { EditUserAgreementMenuProvider } from './shared/menu/providers/edit-user-agreement.menu';
 import { ExportMenuProvider } from './shared/menu/providers/export.menu';
 import { HealthMenuProvider } from './shared/menu/providers/health.menu';
@@ -82,6 +83,9 @@ export const MENUS = buildMenuStructure({
   ],
   [MenuID.DSO_EDIT]: [
     DsoOptionMenuProvider.withSubs([
+      EditItemMenuProvider.onRoute(
+        MenuRoute.ITEM_PAGE,
+      ),
       SubscribeMenuProvider.onRoute(
         MenuRoute.COMMUNITY_PAGE,
         MenuRoute.COLLECTION_PAGE,

src/app/collection-page/collection-form/collection-form.component.ts

@@ -4,27 +4,32 @@ import {
   Component,
   Input,
   OnChanges,
+  OnDestroy,
   OnInit,
   SimpleChange,
   SimpleChanges,
 } from '@angular/core';
 import { AuthService } from '@dspace/core/auth/auth.service';
 import { ObjectCacheService } from '@dspace/core/cache/object-cache.service';
+import { ConfigObject } from '@dspace/core/config/models/config.model';
+import { SubmissionDefinitionModel } from '@dspace/core/config/models/config-submission-definition.model';
+import { SubmissionDefinitionsConfigDataService } from '@dspace/core/config/submission-definitions-config-data.service';
 import { CollectionDataService } from '@dspace/core/data/collection-data.service';
 import { EntityTypeDataService } from '@dspace/core/data/entity-type-data.service';
 import { RequestService } from '@dspace/core/data/request.service';
 import { NotificationsService } from '@dspace/core/notification-system/notifications.service';
 import { Collection } from '@dspace/core/shared/collection.model';
 import { ItemType } from '@dspace/core/shared/item-relationships/item-type.model';
-import { NONE_ENTITY_TYPE } from '@dspace/core/shared/item-relationships/item-type.resource-type';
 import { MetadataValue } from '@dspace/core/shared/metadata.models';
 import { getFirstSucceededRemoteListPayload } from '@dspace/core/shared/operators';
 import {
   hasNoValue,
+  hasValue,
   isNotNull,
 } from '@dspace/shared/utils/empty.util';
 import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
 import {
+  DynamicCheckboxModel,
   DynamicFormControlModel,
   DynamicFormOptionConfig,
   DynamicFormService,
@@ -34,7 +39,13 @@ import {
   TranslateModule,
   TranslateService,
 } from '@ngx-translate/core';
-import { Observable } from 'rxjs';
+import {
+  catchError,
+  forkJoin,
+  Observable,
+  of,
+  Subscription,
+} from 'rxjs';
 
 import { ComColFormComponent } from '../../shared/comcol/comcol-forms/comcol-form/comcol-form.component';
 import { ComcolPageLogoComponent } from '../../shared/comcol/comcol-page-logo/comcol-page-logo.component';
@@ -44,6 +55,8 @@ import { VarDirective } from '../../shared/utils/var.directive';
 import {
   collectionFormEntityTypeSelectionConfig,
   collectionFormModels,
+  collectionFormSharedWorkspaceCheckboxConfig,
+  collectionFormSubmissionDefinitionSelectionConfig,
 } from './collection-form.models';
 
 /**
@@ -62,7 +75,7 @@ import {
     VarDirective,
   ],
 })
-export class CollectionFormComponent extends ComColFormComponent<Collection> implements OnInit, OnChanges {
+export class CollectionFormComponent extends ComColFormComponent<Collection> implements OnInit, OnChanges, OnDestroy {
   /**
    * @type {Collection} A new collection when a collection is being created, an existing Input collection when a collection is being edited
    */
@@ -79,12 +92,27 @@ export class CollectionFormComponent extends ComColFormComponent<Collection> imp
    */
   entityTypeSelection: DynamicSelectModel<string> = new DynamicSelectModel(collectionFormEntityTypeSelectionConfig);
 
+  /**
+   * The dynamic form field used for submission definition selection
+   * @type {DynamicSelectModel<string>}
+   */
+  submissionDefinitionSelection: DynamicSelectModel<string> = new DynamicSelectModel(collectionFormSubmissionDefinitionSelectionConfig);
+
+  sharedWorkspaceChekbox: DynamicCheckboxModel = new DynamicCheckboxModel(collectionFormSharedWorkspaceCheckboxConfig);
+
   /**
    * The dynamic form fields used for creating/editing a collection
    * @type {DynamicFormControlModel[]}
    */
   formModel: DynamicFormControlModel[];
 
+  /**
+   * Subscription to unsubscribe on destroy
+   *
+   * @private
+   */
+  private initSubscription: Subscription;
+
   public constructor(protected formService: DynamicFormService,
                      protected translate: TranslateService,
                      protected notificationsService: NotificationsService,
@@ -94,6 +122,7 @@ export class CollectionFormComponent extends ComColFormComponent<Collection> imp
                      protected objectCache: ObjectCacheService,
                      protected entityTypeService: EntityTypeDataService,
                      protected chd: ChangeDetectorRef,
+                     protected submissionDefinitionService: SubmissionDefinitionsConfigDataService,
                      protected modalService: NgbModal) {
     super(formService, translate, notificationsService, authService, requestService, objectCache, modalService);
   }
@@ -115,21 +144,45 @@ export class CollectionFormComponent extends ComColFormComponent<Collection> imp
     }
   }
 
+  /**
+   * Clean up eventual subscription when component gets destroyed
+   */
+  ngOnDestroy() {
+    super.ngOnDestroy();
+    if (hasValue(this.initSubscription)) {
+      this.initSubscription.unsubscribe();
+    }
+  }
+
   initializeForm() {
     let currentRelationshipValue: MetadataValue[];
+    let currentDefinitionValue: MetadataValue[];
+    let currentSharedWorkspaceValue: MetadataValue[];
     if (this.dso && this.dso.metadata) {
       currentRelationshipValue = this.dso.metadata['dspace.entity.type'];
+      currentDefinitionValue = this.dso.metadata['dspace.submission.definition'];
+      currentSharedWorkspaceValue = this.dso.metadata['dspace.workspace.shared'];
     }
 
     const entities$: Observable<ItemType[]> = this.entityTypeService.findAll({ elementsPerPage: 100, currentPage: 1 }).pipe(
       getFirstSucceededRemoteListPayload(),
     );
 
-    // retrieve all entity types to populate the dropdowns selection
-    entities$.subscribe((entityTypes: ItemType[]) => {
+    const definitions$: Observable<ConfigObject[]> = this.submissionDefinitionService
+      .findAll({ elementsPerPage: 100, currentPage: 1 }).pipe(
+        getFirstSucceededRemoteListPayload(),
+        catchError(() => of([])),
+      );
 
-      entityTypes = entityTypes.filter((type: ItemType) => type.label !== NONE_ENTITY_TYPE);
-      entityTypes.forEach((type: ItemType, index: number) => {
+    // retrieve all entity types and submission definitions to populate the dropdowns selection
+    this.initSubscription = forkJoin({
+      entityTypes: entities$,
+      definitions: definitions$,
+    }).subscribe(({ entityTypes, definitions }:  {entityTypes: ItemType[]; definitions: ConfigObject[]}) => {
+      const sortedEntityTypes = entityTypes
+        .sort((a, b) => a.label.localeCompare(b.label));
+
+      sortedEntityTypes.forEach((type: ItemType, index: number) => {
         this.entityTypeSelection.add({
           disabled: false,
           label: type.label,
@@ -141,9 +194,26 @@ export class CollectionFormComponent extends ComColFormComponent<Collection> imp
         }
       });
 
-      this.formModel = entityTypes.length === 0 ? collectionFormModels : [...collectionFormModels, this.entityTypeSelection];
+      definitions.filter(def => !def.id.includes('-edit')).forEach((definition: SubmissionDefinitionModel, index: number) => {
+        this.submissionDefinitionSelection.add({
+          disabled: false,
+          label: definition.name,
+          value: definition.name,
+        } as DynamicFormOptionConfig<string>);
+        if (currentDefinitionValue && currentDefinitionValue.length > 0 && currentDefinitionValue[0].value === definition.name) {
+          this.submissionDefinitionSelection.select(index);
+        }
+      });
+
+      this.formModel = entityTypes.length === 0 ?
+        [...collectionFormModels, this.submissionDefinitionSelection, this.sharedWorkspaceChekbox] :
+        [...collectionFormModels, this.entityTypeSelection, this.submissionDefinitionSelection, this.sharedWorkspaceChekbox];
 
       super.ngOnInit();
+
+      if (currentSharedWorkspaceValue && currentSharedWorkspaceValue.length > 0) {
+        this.sharedWorkspaceChekbox.value = currentSharedWorkspaceValue[0].value === 'true';
+      }
       this.chd.detectChanges();
     });
 

src/app/collection-page/collection-form/collection-form.models.ts

@@ -1,4 +1,5 @@
 import {
+  DynamicCheckboxModelConfig,
   DynamicFormControlModel,
   DynamicInputModel,
   DynamicSelectModelConfig,
@@ -11,6 +12,25 @@ export const collectionFormEntityTypeSelectionConfig: DynamicSelectModelConfig<s
   id: 'entityType',
   name: 'dspace.entity.type',
   disabled: false,
+  errorMessages: {
+    required: 'collection.form.errors.entityType.required',
+  },
+};
+
+export const collectionFormSubmissionDefinitionSelectionConfig: DynamicSelectModelConfig<string> = {
+  id: 'submissionDefinition',
+  name: 'dspace.submission.definition',
+  disabled: false,
+  errorMessages: {
+    required: 'collection.form.errors.submissionDefinition.required',
+  },
+};
+
+
+export const collectionFormSharedWorkspaceCheckboxConfig: DynamicCheckboxModelConfig = {
+  id: 'sharedWorkspace',
+  name: 'dspace.workspace.shared',
+  disabled: false,
 };
 
 /**

src/app/core/breadcrumbs/edit-item-breadcrumb.resolver.spec.ts

@@ -0,0 +1,62 @@
+import {
+  EnvironmentInjector,
+  runInInjectionContext,
+} from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { editItemBreadcrumbResolver } from '@dspace/core/breadcrumbs/edit-item-breadcrumb.resolver';
+import { Item } from '@dspace/core/shared/item.model';
+import { getTestScheduler } from 'jasmine-marbles';
+import { of } from 'rxjs';
+
+import { ItemDataService } from '../data/item-data.service';
+import { createSuccessfulRemoteDataObject$ } from '../utilities/remote-data.utils';
+import { DSOBreadcrumbsService } from './dso-breadcrumbs.service';
+
+describe('editItemBreadcrumbResolver', () => {
+  describe('resolve', () => {
+    let resolver: any;
+    let dsoBreadcrumbService: any;
+    let itemDataService: any;
+    let testItem: Item;
+    let uuid: string;
+    let breadcrumbUrl: string;
+    let currentUrl: string;
+
+    beforeEach(() => {
+      uuid = '1234-65487-12354-1235';
+      breadcrumbUrl = `/items/${uuid}`;
+      currentUrl = `${breadcrumbUrl}/edit`;
+      testItem = Object.assign(new Item(), {
+        uuid: uuid,
+        type: 'item',
+      });
+
+      itemDataService = {
+        findById: () => createSuccessfulRemoteDataObject$(testItem),
+      };
+
+      dsoBreadcrumbService = {
+        getRepresentativeName: () => testItem.uuid,
+        getBreadcrumbs: () => of({ provider: dsoBreadcrumbService, key: testItem, url: breadcrumbUrl }),
+      };
+
+      TestBed.configureTestingModule({
+        providers: [
+          { provide: DSOBreadcrumbsService, useValue: dsoBreadcrumbService },
+          { provide: ItemDataService, useValue: itemDataService },
+        ],
+      });
+
+      resolver = editItemBreadcrumbResolver;
+    });
+
+    it('should resolve a breadcrumb config for the correct uuid', () => {
+      const injector = TestBed.inject(EnvironmentInjector);
+      const resolvedConfig = runInInjectionContext(injector, () =>
+        resolver({ params: { id: testItem.uuid + ':FULL' } } as any, { url: currentUrl } as any),
+      );
+      const expectedConfig = { provider: dsoBreadcrumbService, key: testItem, url: breadcrumbUrl };
+      getTestScheduler().expectObservable(resolvedConfig).toBe('(a|)', { a: expectedConfig });
+    });
+  });
+});

src/app/core/breadcrumbs/edit-item-breadcrumb.resolver.ts

@@ -0,0 +1,27 @@
+import {
+  ActivatedRouteSnapshot,
+  ResolveFn,
+  RouterStateSnapshot,
+} from '@angular/router';
+import { itemBreadcrumbResolver } from '@dspace/core/breadcrumbs/item-breadcrumb.resolver';
+import { Observable } from 'rxjs';
+
+import { Item } from '../shared/item.model';
+import { BreadcrumbConfig } from './models/breadcrumb-config.model';
+
+/**
+ * The resolve function that resolves the BreadcrumbConfig object for an Item in edit mode
+ */
+export const editItemBreadcrumbResolver: ResolveFn<BreadcrumbConfig<Item>> = (
+  route: ActivatedRouteSnapshot,
+  state: RouterStateSnapshot,
+): Observable<BreadcrumbConfig<Item>> => {
+  const routeWithCorrectId = Object.assign(route, {
+    params: {
+      ...route.params,
+      id: route.params.id.split(':')[0],
+    },
+  });
+
+  return itemBreadcrumbResolver(routeWithCorrectId, state) as Observable<BreadcrumbConfig<Item>>;
+};

src/app/core/cache/builders/remote-data-build.service.ts

@@ -339,6 +339,7 @@ export class RemoteDataBuildService {
           response.errorMessage,
           payload,
           response.statusCode,
+          response.errors,
         );
       }),
     );