+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{'item.edit.bitstreams.empty' | translate}}
+
+
+
+
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.scss b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.scss
index e69de29bb2..0400e765de 100644
--- a/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.scss
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.scss
@@ -0,0 +1,42 @@
+.header-row {
+ color: $table-dark-color;
+ background-color: $table-dark-bg;
+ border-color: $table-dark-border-color;
+}
+
+.bundle-row {
+ color: $table-head-color;
+ background-color: $table-head-bg;
+ border-color: $table-border-color;
+}
+
+.row-element {
+ padding: 12px;
+ padding: 0.75em;
+ border-bottom: $table-border-width solid $table-border-color;
+}
+
+.drag-handle {
+ visibility: hidden;
+ &:hover {
+ cursor: grab;
+ }
+}
+
+:host ::ng-deep .bitstream-row:hover .drag-handle {
+ visibility: visible !important;
+}
+
+.cdk-drag-preview {
+ margin-left: 0;
+ box-sizing: border-box;
+ box-shadow: 0 5px 5px -3px rgba(0, 0, 0, 0.2), 0 8px 10px 1px rgba(0, 0, 0, 0.14), 0 3px 14px 2px rgba(0, 0, 0, 0.12);
+}
+
+.cdk-drag-placeholder {
+ opacity: 0;
+}
+
+.cdk-drag-animating {
+ transition: transform 250ms cubic-bezier(0, 0, 0.2, 1);
+}
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.spec.ts b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.spec.ts
new file mode 100644
index 0000000000..9184889257
--- /dev/null
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.spec.ts
@@ -0,0 +1,224 @@
+import { Bitstream } from '../../../core/shared/bitstream.model';
+import { of as observableOf } from 'rxjs/internal/observable/of';
+import { RemoteData } from '../../../core/data/remote-data';
+import { PaginatedList } from '../../../core/data/paginated-list';
+import { PageInfo } from '../../../core/shared/page-info.model';
+import { Item } from '../../../core/shared/item.model';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { ItemBitstreamsComponent } from './item-bitstreams.component';
+import { ItemDataService } from '../../../core/data/item-data.service';
+import { TranslateModule } from '@ngx-translate/core';
+import { ObjectUpdatesService } from '../../../core/data/object-updates/object-updates.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { GLOBAL_CONFIG } from '../../../../config';
+import { ChangeDetectorRef, NO_ERRORS_SCHEMA } from '@angular/core';
+import { FieldChangeType } from '../../../core/data/object-updates/object-updates.actions';
+import { RouterStub } from '../../../shared/testing/router-stub';
+import { INotification, Notification } from '../../../shared/notifications/models/notification.model';
+import { NotificationType } from '../../../shared/notifications/models/notification-type';
+import { BitstreamDataService } from '../../../core/data/bitstream-data.service';
+import { getMockRequestService } from '../../../shared/mocks/mock-request.service';
+import { ObjectCacheService } from '../../../core/cache/object-cache.service';
+import { RequestService } from '../../../core/data/request.service';
+import { ObjectValuesPipe } from '../../../shared/utils/object-values-pipe';
+import { VarDirective } from '../../../shared/utils/var.directive';
+import { BundleDataService } from '../../../core/data/bundle-data.service';
+import { Bundle } from '../../../core/shared/bundle.model';
+import { RestResponse } from '../../../core/cache/response.models';
+import { SearchConfigurationService } from '../../../core/shared/search/search-configuration.service';
+
+let comp: ItemBitstreamsComponent;
+let fixture: ComponentFixture
;
+
+const infoNotification: INotification = new Notification('id', NotificationType.Info, 'info');
+const warningNotification: INotification = new Notification('id', NotificationType.Warning, 'warning');
+const successNotification: INotification = new Notification('id', NotificationType.Success, 'success');
+const bitstream1 = Object.assign(new Bitstream(), {
+ id: 'bitstream1',
+ uuid: 'bitstream1'
+});
+const bitstream2 = Object.assign(new Bitstream(), {
+ id: 'bitstream2',
+ uuid: 'bitstream2'
+});
+const fieldUpdate1 = {
+ field: bitstream1,
+ changeType: undefined
+};
+const fieldUpdate2 = {
+ field: bitstream2,
+ changeType: FieldChangeType.REMOVE
+};
+const bundle = Object.assign(new Bundle(), {
+ id: 'bundle1',
+ uuid: 'bundle1',
+ _links: {
+ self: { href: 'bundle1-selflink' }
+ },
+ bitstreams: createMockRDPaginatedObs([bitstream1, bitstream2])
+});
+const moveOperations = [
+ {
+ op: 'move',
+ from: '/0',
+ path: '/1'
+ }
+];
+const date = new Date();
+const url = 'thisUrl';
+let item: Item;
+let itemService: ItemDataService;
+let objectUpdatesService: ObjectUpdatesService;
+let router: any;
+let route: ActivatedRoute;
+let notificationsService: NotificationsService;
+let bitstreamService: BitstreamDataService;
+let objectCache: ObjectCacheService;
+let requestService: RequestService;
+let searchConfig: SearchConfigurationService;
+let bundleService: BundleDataService;
+
+describe('ItemBitstreamsComponent', () => {
+ beforeEach(async(() => {
+ objectUpdatesService = jasmine.createSpyObj('objectUpdatesService',
+ {
+ getFieldUpdates: observableOf({
+ [bitstream1.uuid]: fieldUpdate1,
+ [bitstream2.uuid]: fieldUpdate2,
+ }),
+ getFieldUpdatesExclusive: observableOf({
+ [bitstream1.uuid]: fieldUpdate1,
+ [bitstream2.uuid]: fieldUpdate2,
+ }),
+ saveAddFieldUpdate: {},
+ discardFieldUpdates: {},
+ discardAllFieldUpdates: {},
+ reinstateFieldUpdates: observableOf(true),
+ initialize: {},
+ getUpdatedFields: observableOf([bitstream1, bitstream2]),
+ getLastModified: observableOf(date),
+ hasUpdates: observableOf(true),
+ isReinstatable: observableOf(false),
+ isValidPage: observableOf(true),
+ getMoveOperations: observableOf(moveOperations)
+ }
+ );
+ router = Object.assign(new RouterStub(), {
+ url: url
+ });
+ notificationsService = jasmine.createSpyObj('notificationsService',
+ {
+ info: infoNotification,
+ warning: warningNotification,
+ success: successNotification
+ }
+ );
+ bitstreamService = jasmine.createSpyObj('bitstreamService', {
+ deleteAndReturnResponse: jasmine.createSpy('deleteAndReturnResponse')
+ });
+ objectCache = jasmine.createSpyObj('objectCache', {
+ remove: jasmine.createSpy('remove')
+ });
+ requestService = getMockRequestService();
+ searchConfig = Object.assign( {
+ paginatedSearchOptions: observableOf({})
+ });
+
+ item = Object.assign(new Item(), {
+ uuid: 'item',
+ id: 'item',
+ _links: {
+ self: { href: 'item-selflink' }
+ },
+ bundles: createMockRDPaginatedObs([bundle]),
+ lastModified: date
+ });
+ itemService = Object.assign( {
+ getBitstreams: () => createMockRDPaginatedObs([bitstream1, bitstream2]),
+ findById: () => createMockRDObs(item),
+ getBundles: () => createMockRDPaginatedObs([bundle])
+ });
+ route = Object.assign({
+ parent: {
+ data: observableOf({ item: createMockRD(item) })
+ },
+ url: url
+ });
+ bundleService = jasmine.createSpyObj('bundleService', {
+ patch: observableOf(new RestResponse(true, 200, 'OK'))
+ });
+
+ TestBed.configureTestingModule({
+ imports: [TranslateModule.forRoot()],
+ declarations: [ItemBitstreamsComponent, ObjectValuesPipe, VarDirective],
+ providers: [
+ { provide: ItemDataService, useValue: itemService },
+ { provide: ObjectUpdatesService, useValue: objectUpdatesService },
+ { provide: Router, useValue: router },
+ { provide: ActivatedRoute, useValue: route },
+ { provide: NotificationsService, useValue: notificationsService },
+ { provide: GLOBAL_CONFIG, useValue: { item: { edit: { undoTimeout: 10 } } } as any },
+ { provide: BitstreamDataService, useValue: bitstreamService },
+ { provide: ObjectCacheService, useValue: objectCache },
+ { provide: RequestService, useValue: requestService },
+ { provide: SearchConfigurationService, useValue: searchConfig },
+ { provide: BundleDataService, useValue: bundleService },
+ ChangeDetectorRef
+ ], schemas: [
+ NO_ERRORS_SCHEMA
+ ]
+ }).compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(ItemBitstreamsComponent);
+ comp = fixture.componentInstance;
+ comp.url = url;
+ fixture.detectChanges();
+ });
+
+ describe('when submit is called', () => {
+ beforeEach(() => {
+ comp.submit();
+ });
+
+ it('should call deleteAndReturnResponse on the bitstreamService for the marked field', () => {
+ expect(bitstreamService.deleteAndReturnResponse).toHaveBeenCalledWith(bitstream2.id);
+ });
+
+ it('should not call deleteAndReturnResponse on the bitstreamService for the unmarked field', () => {
+ expect(bitstreamService.deleteAndReturnResponse).not.toHaveBeenCalledWith(bitstream1.id);
+ });
+
+ it('should send out a patch for the move operations', () => {
+ expect(bundleService.patch).toHaveBeenCalled();
+ });
+ });
+
+ describe('discard', () => {
+ it('should discard ALL field updates', () => {
+ comp.discard();
+ expect(objectUpdatesService.discardAllFieldUpdates).toHaveBeenCalled();
+ });
+ });
+
+ describe('reinstate', () => {
+ it('should reinstate field updates on the bundle', () => {
+ comp.reinstate();
+ expect(objectUpdatesService.reinstateFieldUpdates).toHaveBeenCalledWith(bundle.self);
+ });
+ });
+});
+
+export function createMockRDPaginatedObs(list: any[]) {
+ return createMockRDObs(new PaginatedList(new PageInfo(), list));
+}
+
+export function createMockRDObs(obj: any) {
+ return observableOf(createMockRD(obj));
+}
+
+export function createMockRD(obj: any) {
+ return new RemoteData(false, false, true, null, obj);
+}
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.ts b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.ts
index 71f25cd5cf..bdb1ec23a5 100644
--- a/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.ts
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-bitstreams.component.ts
@@ -1,4 +1,34 @@
-import { Component } from '@angular/core';
+import { ChangeDetectorRef, Component, Inject, OnDestroy } from '@angular/core';
+import { AbstractItemUpdateComponent } from '../abstract-item-update/abstract-item-update.component';
+import { filter, map, switchMap, take, tap } from 'rxjs/operators';
+import { Observable } from 'rxjs/internal/Observable';
+import { Subscription } from 'rxjs/internal/Subscription';
+import { ItemDataService } from '../../../core/data/item-data.service';
+import { ObjectUpdatesService } from '../../../core/data/object-updates/object-updates.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { TranslateService } from '@ngx-translate/core';
+import { GLOBAL_CONFIG, GlobalConfig } from '../../../../config';
+import { BitstreamDataService } from '../../../core/data/bitstream-data.service';
+import { hasValue, isNotEmpty, isNotEmptyOperator } from '../../../shared/empty.util';
+import { zip as observableZip, combineLatest as observableCombineLatest, of as observableOf } from 'rxjs';
+import { ErrorResponse, RestResponse } from '../../../core/cache/response.models';
+import { ObjectCacheService } from '../../../core/cache/object-cache.service';
+import { RequestService } from '../../../core/data/request.service';
+import { getRemoteDataPayload, getSucceededRemoteData } from '../../../core/shared/operators';
+import { Item } from '../../../core/shared/item.model';
+import { RemoteData } from '../../../core/data/remote-data';
+import { PaginatedList } from '../../../core/data/paginated-list';
+import { Bundle } from '../../../core/shared/bundle.model';
+import { FieldUpdate, FieldUpdates } from '../../../core/data/object-updates/object-updates.reducer';
+import { Bitstream } from '../../../core/shared/bitstream.model';
+import { FieldChangeType } from '../../../core/data/object-updates/object-updates.actions';
+import { Operation } from 'fast-json-patch';
+import { MoveOperation } from 'fast-json-patch/lib/core';
+import { BundleDataService } from '../../../core/data/bundle-data.service';
+import { PaginatedSearchOptions } from '../../../shared/search/paginated-search-options.model';
+import { ResponsiveColumnSizes } from '../../../shared/responsive-table-sizes/responsive-column-sizes';
+import { ResponsiveTableSizes } from '../../../shared/responsive-table-sizes/responsive-table-sizes';
@Component({
selector: 'ds-item-bitstreams',
@@ -8,6 +38,273 @@ import { Component } from '@angular/core';
/**
* Component for displaying an item's bitstreams edit page
*/
-export class ItemBitstreamsComponent {
- /* TODO implement */
+export class ItemBitstreamsComponent extends AbstractItemUpdateComponent implements OnDestroy {
+
+ /**
+ * The currently listed bundles
+ */
+ bundles$: Observable;
+
+ /**
+ * The page options to use for fetching the bundles
+ */
+ bundlesOptions = {
+ id: 'bundles-pagination-options',
+ currentPage: 1,
+ pageSize: 9999
+ } as any;
+
+ /**
+ * The bootstrap sizes used for the columns within this table
+ */
+ columnSizes = new ResponsiveTableSizes([
+ // Name column
+ new ResponsiveColumnSizes(2, 2, 3, 4, 4),
+ // Description column
+ new ResponsiveColumnSizes(2, 3, 3, 3, 3),
+ // Format column
+ new ResponsiveColumnSizes(2, 2, 2, 2, 2),
+ // Actions column
+ new ResponsiveColumnSizes(6, 5, 4, 3, 3)
+ ]);
+
+ /**
+ * Are we currently submitting the changes?
+ * Used to disable any action buttons until the submit finishes
+ */
+ submitting = false;
+
+ /**
+ * A subscription that checks when the item is deleted in cache and reloads the item by sending a new request
+ * This is used to update the item in cache after bitstreams are deleted
+ */
+ itemUpdateSubscription: Subscription;
+
+ constructor(
+ public itemService: ItemDataService,
+ public objectUpdatesService: ObjectUpdatesService,
+ public router: Router,
+ public notificationsService: NotificationsService,
+ public translateService: TranslateService,
+ @Inject(GLOBAL_CONFIG) public EnvConfig: GlobalConfig,
+ public route: ActivatedRoute,
+ public bitstreamService: BitstreamDataService,
+ public objectCache: ObjectCacheService,
+ public requestService: RequestService,
+ public cdRef: ChangeDetectorRef,
+ public bundleService: BundleDataService
+ ) {
+ super(itemService, objectUpdatesService, router, notificationsService, translateService, EnvConfig, route);
+ }
+
+ /**
+ * Set up and initialize all fields
+ */
+ ngOnInit(): void {
+ super.ngOnInit();
+ this.initializeItemUpdate();
+ }
+
+ /**
+ * Actions to perform after the item has been initialized
+ */
+ postItemInit(): void {
+ this.bundles$ = this.itemService.getBundles(this.item.id, new PaginatedSearchOptions({pagination: this.bundlesOptions})).pipe(
+ getSucceededRemoteData(),
+ getRemoteDataPayload(),
+ map((bundlePage: PaginatedList) => bundlePage.page)
+ );
+ }
+
+ /**
+ * Initialize the notification messages prefix
+ */
+ initializeNotificationsPrefix(): void {
+ this.notificationsPrefix = 'item.edit.bitstreams.notifications.';
+ }
+
+ /**
+ * Update the item (and view) when it's removed in the request cache
+ * Also re-initialize the original fields and updates
+ */
+ initializeItemUpdate(): void {
+ this.itemUpdateSubscription = this.requestService.hasByHrefObservable(this.item.self).pipe(
+ filter((exists: boolean) => !exists),
+ switchMap(() => this.itemService.findById(this.item.uuid)),
+ getSucceededRemoteData(),
+ ).subscribe((itemRD: RemoteData- ) => {
+ if (hasValue(itemRD)) {
+ this.item = itemRD.payload;
+ this.postItemInit();
+ this.initializeOriginalFields();
+ this.initializeUpdates();
+ this.cdRef.detectChanges();
+ }
+ });
+ }
+
+ /**
+ * Submit the current changes
+ * Bitstreams that were dragged around send out a patch request with move operations to the rest API
+ * Bitstreams marked as deleted send out a delete request to the rest API
+ * Display notifications and reset the current item/updates
+ */
+ submit() {
+ this.submitting = true;
+ const bundlesOnce$ = this.bundles$.pipe(take(1));
+
+ // Fetch all move operations for each bundle
+ const moveOperations$ = bundlesOnce$.pipe(
+ switchMap((bundles: Bundle[]) => observableZip(...bundles.map((bundle: Bundle) =>
+ this.objectUpdatesService.getMoveOperations(bundle.self).pipe(
+ take(1),
+ map((operations: MoveOperation[]) => [...operations.map((operation: MoveOperation) => Object.assign(operation, {
+ from: `/_links/bitstreams${operation.from}/href`,
+ path: `/_links/bitstreams${operation.path}/href`
+ }))])
+ )
+ )))
+ );
+
+ // Send out an immediate patch request for each bundle
+ const patchResponses$ = observableCombineLatest(bundlesOnce$, moveOperations$).pipe(
+ switchMap(([bundles, moveOperationList]: [Bundle[], Operation[][]]) =>
+ observableZip(...bundles.map((bundle: Bundle, index: number) => {
+ if (isNotEmpty(moveOperationList[index])) {
+ return this.bundleService.patch(bundle, moveOperationList[index]);
+ } else {
+ return observableOf(undefined);
+ }
+ }))
+ )
+ );
+
+ // Fetch all removed bitstreams from the object update service
+ const removedBitstreams$ = bundlesOnce$.pipe(
+ switchMap((bundles: Bundle[]) => observableZip(
+ ...bundles.map((bundle: Bundle) => this.objectUpdatesService.getFieldUpdates(bundle.self, [], true))
+ )),
+ map((fieldUpdates: FieldUpdates[]) => ([] as FieldUpdate[]).concat(
+ ...fieldUpdates.map((updates: FieldUpdates) => Object.values(updates).filter((fieldUpdate: FieldUpdate) => fieldUpdate.changeType === FieldChangeType.REMOVE))
+ )),
+ map((fieldUpdates: FieldUpdate[]) => fieldUpdates.map((fieldUpdate: FieldUpdate) => fieldUpdate.field))
+ );
+
+ // Send out delete requests for all deleted bitstreams
+ const removedResponses$ = removedBitstreams$.pipe(
+ take(1),
+ switchMap((removedBistreams: Bitstream[]) => {
+ if (isNotEmpty(removedBistreams)) {
+ return observableZip(...removedBistreams.map((bitstream: Bitstream) => this.bitstreamService.deleteAndReturnResponse(bitstream.id)));
+ } else {
+ return observableOf(undefined);
+ }
+ })
+ );
+
+ // Perform the setup actions from above in order and display notifications
+ patchResponses$.pipe(
+ switchMap((responses: RestResponse[]) => {
+ this.displayNotifications('item.edit.bitstreams.notifications.move', responses);
+ return removedResponses$
+ }),
+ take(1)
+ ).subscribe((responses: RestResponse[]) => {
+ this.displayNotifications('item.edit.bitstreams.notifications.remove', responses);
+ this.reset();
+ this.submitting = false;
+ });
+ }
+
+ /**
+ * Display notifications
+ * - Error notification for each failed response with their message
+ * - Success notification in case there's at least one successful response
+ * @param key The i18n key for the notification messages
+ * @param responses The returned responses to display notifications for
+ */
+ displayNotifications(key: string, responses: RestResponse[]) {
+ if (isNotEmpty(responses)) {
+ const failedResponses = responses.filter((response: RestResponse) => hasValue(response) && !response.isSuccessful);
+ const successfulResponses = responses.filter((response: RestResponse) => hasValue(response) && response.isSuccessful);
+
+ failedResponses.forEach((response: ErrorResponse) => {
+ this.notificationsService.error(this.translateService.instant(`${key}.failed.title`), response.errorMessage);
+ });
+ if (successfulResponses.length > 0) {
+ this.notificationsService.success(this.translateService.instant(`${key}.saved.title`), this.translateService.instant(`${key}.saved.content`));
+ }
+ }
+ }
+
+ /**
+ * Request the object updates service to discard all current changes to this item
+ * Shows a notification to remind the user that they can undo this
+ */
+ discard() {
+ const undoNotification = this.notificationsService.info(this.getNotificationTitle('discarded'), this.getNotificationContent('discarded'), {timeOut: this.discardTimeOut});
+ this.objectUpdatesService.discardAllFieldUpdates(this.url, undoNotification);
+ }
+
+ /**
+ * Request the object updates service to undo discarding all changes to this item
+ */
+ reinstate() {
+ this.bundles$.pipe(take(1)).subscribe((bundles: Bundle[]) => {
+ bundles.forEach((bundle: Bundle) => {
+ this.objectUpdatesService.reinstateFieldUpdates(bundle.self);
+ });
+ });
+ }
+
+ /**
+ * Checks whether or not the object is currently reinstatable
+ */
+ isReinstatable(): Observable {
+ return this.bundles$.pipe(
+ switchMap((bundles: Bundle[]) => observableZip(...bundles.map((bundle: Bundle) => this.objectUpdatesService.isReinstatable(bundle.self)))),
+ map((reinstatable: boolean[]) => reinstatable.includes(true))
+ );
+ }
+
+ /**
+ * Checks whether or not there are currently updates for this object
+ */
+ hasChanges(): Observable {
+ return this.bundles$.pipe(
+ switchMap((bundles: Bundle[]) => observableZip(...bundles.map((bundle: Bundle) => this.objectUpdatesService.hasUpdates(bundle.self)))),
+ map((hasChanges: boolean[]) => hasChanges.includes(true))
+ );
+ }
+
+ /**
+ * De-cache the current item (it should automatically reload due to itemUpdateSubscription)
+ */
+ reset() {
+ this.refreshItemCache();
+ this.initializeItemUpdate();
+ }
+
+ /**
+ * Remove the current item's cache from object- and request-cache
+ */
+ refreshItemCache() {
+ this.bundles$.pipe(take(1)).subscribe((bundles: Bundle[]) => {
+ bundles.forEach((bundle: Bundle) => {
+ this.objectCache.remove(bundle.self);
+ this.requestService.removeByHrefSubstring(bundle.self);
+ });
+ this.objectCache.remove(this.item.self);
+ this.requestService.removeByHrefSubstring(this.item.self);
+ });
+ }
+
+ /**
+ * Unsubscribe from open subscriptions whenever the component gets destroyed
+ */
+ ngOnDestroy(): void {
+ if (this.itemUpdateSubscription) {
+ this.itemUpdateSubscription.unsubscribe();
+ }
+ }
}
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-bundle/item-edit-bitstream-bundle.component.html b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-bundle/item-edit-bitstream-bundle.component.html
new file mode 100644
index 0000000000..58273bb931
--- /dev/null
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-bundle/item-edit-bitstream-bundle.component.html
@@ -0,0 +1,21 @@
+
+
+
+
+
+ {{'item.edit.bitstreams.bundle.name' | translate:{ name: bundle.name } }}
+
+
+
+
+
+
+
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-drag-handle/item-edit-bitstream-drag-handle.component.ts b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-drag-handle/item-edit-bitstream-drag-handle.component.ts
new file mode 100644
index 0000000000..e6d72cbd57
--- /dev/null
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream-drag-handle/item-edit-bitstream-drag-handle.component.ts
@@ -0,0 +1,26 @@
+import { Component, OnInit, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+
+@Component({
+ selector: 'ds-item-edit-bitstream-drag-handle',
+ styleUrls: ['../item-bitstreams.component.scss'],
+ templateUrl: './item-edit-bitstream-drag-handle.component.html',
+})
+/**
+ * Component displaying a drag handle for the item-edit-bitstream page
+ * Creates an embedded view of the contents
+ * (which means it'll be added to the parents html without a wrapping ds-item-edit-bitstream-drag-handle element)
+ */
+export class ItemEditBitstreamDragHandleComponent implements OnInit {
+ /**
+ * The view on the drag-handle
+ */
+ @ViewChild('handleView', {static: true}) handleView;
+
+ constructor(private viewContainerRef: ViewContainerRef) {
+ }
+
+ ngOnInit(): void {
+ this.viewContainerRef.createEmbeddedView(this.handleView);
+ }
+
+}
diff --git a/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream/item-edit-bitstream.component.html b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream/item-edit-bitstream.component.html
new file mode 100644
index 0000000000..62014f06bd
--- /dev/null
+++ b/src/app/+item-page/edit-item-page/item-bitstreams/item-edit-bitstream/item-edit-bitstream.component.html
@@ -0,0 +1,43 @@
+
+
+
+
+ {{ bitstreamName }}
+
+
+
+ {{ bitstream?.firstMetadataValue('dc.description') }}
+
+
+
+ {{ (format$ | async)?.shortDescription }}
+
+
- {
protected notificationsService: NotificationsService,
protected http: HttpClient,
protected comparator: DSOChangeAnalyzer
- ,
+ protected bundleService: BundleDataService
) {
super();
}
@@ -219,6 +225,76 @@ export class ItemDataService extends DataService
- {
);
}
+ /**
+ * Get the endpoint for an item's bundles
+ * @param itemId
+ */
+ public getBundlesEndpoint(itemId: string): Observable {
+ return this.halService.getEndpoint(this.linkPath).pipe(
+ switchMap((url: string) => this.halService.getEndpoint('bundles', `${url}/${itemId}`))
+ );
+ }
+
+ /**
+ * Get an item's bundles using paginated search options
+ * @param itemId The item's ID
+ * @param searchOptions The search options to use
+ */
+ public getBundles(itemId: string, searchOptions?: PaginatedSearchOptions): Observable>> {
+ const hrefObs = this.getBundlesEndpoint(itemId).pipe(
+ map((href) => searchOptions ? searchOptions.toRestUrl(href) : href)
+ );
+ hrefObs.pipe(
+ take(1)
+ ).subscribe((href) => {
+ const request = new GetRequest(this.requestService.generateRequestId(), href);
+ this.requestService.configure(request);
+ });
+
+ return this.rdbService.buildList(hrefObs);
+ }
+
+ /**
+ * Create a new bundle on an item
+ * @param itemId The item's ID
+ * @param bundleName The new bundle's name
+ * @param metadata Optional metadata for the bundle
+ */
+ public createBundle(itemId: string, bundleName: string, metadata?: MetadataMap): Observable> {
+ const requestId = this.requestService.generateRequestId();
+ const hrefObs = this.getBundlesEndpoint(itemId);
+
+ const bundleJson = {
+ name: bundleName,
+ metadata: metadata ? metadata : {}
+ };
+
+ hrefObs.pipe(
+ take(1)
+ ).subscribe((href) => {
+ const options: HttpOptions = Object.create({});
+ let headers = new HttpHeaders();
+ headers = headers.append('Content-Type', 'application/json');
+ options.headers = headers;
+ const request = new PostRequest(requestId, href, JSON.stringify(bundleJson), options);
+ this.requestService.configure(request);
+ });
+
+ const selfLink$ = this.requestService.getByUUID(requestId).pipe(
+ getResponseFromEntry(),
+ map((response: any) => {
+ if (isNotEmpty(response.resourceSelfLinks)) {
+ return response.resourceSelfLinks[0];
+ }
+ }),
+ distinctUntilChanged()
+ ) as Observable;
+
+ return selfLink$.pipe(
+ switchMap((selfLink: string) => this.bundleService.findByHref(selfLink)),
+ );
+ }
+
/**
* Get the endpoint to move the item
* @param itemId
diff --git a/src/app/core/data/object-updates/object-updates.actions.ts b/src/app/core/data/object-updates/object-updates.actions.ts
index 9df9acec8f..94918157ee 100644
--- a/src/app/core/data/object-updates/object-updates.actions.ts
+++ b/src/app/core/data/object-updates/object-updates.actions.ts
@@ -8,6 +8,7 @@ import {INotification} from '../../../shared/notifications/models/notification.m
*/
export const ObjectUpdatesActionTypes = {
INITIALIZE_FIELDS: type('dspace/core/cache/object-updates/INITIALIZE_FIELDS'),
+ ADD_PAGE_TO_CUSTOM_ORDER: type('dspace/core/cache/object-updates/ADD_PAGE_TO_CUSTOM_ORDER'),
SET_EDITABLE_FIELD: type('dspace/core/cache/object-updates/SET_EDITABLE_FIELD'),
SET_VALID_FIELD: type('dspace/core/cache/object-updates/SET_VALID_FIELD'),
ADD_FIELD: type('dspace/core/cache/object-updates/ADD_FIELD'),
@@ -15,7 +16,9 @@ export const ObjectUpdatesActionTypes = {
DISCARD: type('dspace/core/cache/object-updates/DISCARD'),
REINSTATE: type('dspace/core/cache/object-updates/REINSTATE'),
REMOVE: type('dspace/core/cache/object-updates/REMOVE'),
+ REMOVE_ALL: type('dspace/core/cache/object-updates/REMOVE_ALL'),
REMOVE_FIELD: type('dspace/core/cache/object-updates/REMOVE_FIELD'),
+ MOVE: type('dspace/core/cache/object-updates/MOVE'),
};
/* tslint:disable:max-classes-per-file */
@@ -26,7 +29,8 @@ export const ObjectUpdatesActionTypes = {
export enum FieldChangeType {
UPDATE = 0,
ADD = 1,
- REMOVE = 2
+ REMOVE = 2,
+ MOVE = 3
}
/**
@@ -37,7 +41,10 @@ export class InitializeFieldsAction implements Action {
payload: {
url: string,
fields: Identifiable[],
- lastModified: Date
+ lastModified: Date,
+ order: string[],
+ pageSize: number,
+ page: number
};
/**
@@ -47,13 +54,49 @@ export class InitializeFieldsAction implements Action {
* the unique url of the page for which the fields are being initialized
* @param fields The identifiable fields of which the updates are kept track of
* @param lastModified The last modified date of the object that belongs to the page
+ * @param order A custom order to keep track of objects moving around
+ * @param pageSize The page size used to fill empty pages for the custom order
+ * @param page The first page to populate in the custom order
*/
constructor(
url: string,
fields: Identifiable[],
- lastModified: Date
+ lastModified: Date,
+ order: string[] = [],
+ pageSize: number = 9999,
+ page: number = 0
) {
- this.payload = { url, fields, lastModified };
+ this.payload = { url, fields, lastModified, order, pageSize, page };
+ }
+}
+
+/**
+ * An ngrx action to initialize a new page's fields in the ObjectUpdates state
+ */
+export class AddPageToCustomOrderAction implements Action {
+ type = ObjectUpdatesActionTypes.ADD_PAGE_TO_CUSTOM_ORDER;
+ payload: {
+ url: string,
+ fields: Identifiable[],
+ order: string[],
+ page: number
+ };
+
+ /**
+ * Create a new AddPageToCustomOrderAction
+ *
+ * @param url The unique url of the page for which the fields are being added
+ * @param fields The identifiable fields of which the updates are kept track of
+ * @param order A custom order to keep track of objects moving around
+ * @param page The page to populate in the custom order
+ */
+ constructor(
+ url: string,
+ fields: Identifiable[],
+ order: string[] = [],
+ page: number = 0
+ ) {
+ this.payload = { url, fields, order, page };
}
}
@@ -180,7 +223,8 @@ export class DiscardObjectUpdatesAction implements Action {
type = ObjectUpdatesActionTypes.DISCARD;
payload: {
url: string,
- notification: INotification
+ notification: INotification,
+ discardAll: boolean;
};
/**
@@ -189,12 +233,14 @@ export class DiscardObjectUpdatesAction implements Action {
* @param url
* the unique url of the page for which the changes should be discarded
* @param notification The notification that is raised when changes are discarded
+ * @param discardAll discard all
*/
constructor(
url: string,
- notification: INotification
+ notification: INotification,
+ discardAll = false
) {
- this.payload = { url, notification };
+ this.payload = { url, notification, discardAll };
}
}
@@ -242,6 +288,13 @@ export class RemoveObjectUpdatesAction implements Action {
}
}
+/**
+ * An ngrx action to remove all previously discarded updates in the ObjectUpdates state
+ */
+export class RemoveAllObjectUpdatesAction implements Action {
+ type = ObjectUpdatesActionTypes.REMOVE_ALL;
+}
+
/**
* An ngrx action to remove a single field update in the ObjectUpdates state for a certain page url and field uuid
*/
@@ -267,6 +320,43 @@ export class RemoveFieldUpdateAction implements Action {
}
}
+/**
+ * An ngrx action to remove a single field update in the ObjectUpdates state for a certain page url and field uuid
+ */
+export class MoveFieldUpdateAction implements Action {
+ type = ObjectUpdatesActionTypes.MOVE;
+ payload: {
+ url: string,
+ from: number,
+ to: number,
+ fromPage: number,
+ toPage: number,
+ field?: Identifiable
+ };
+
+ /**
+ * Create a new RemoveObjectUpdatesAction
+ *
+ * @param url
+ * the unique url of the page for which a field's change should be removed
+ * @param from The index of the object to move
+ * @param to The index to move the object to
+ * @param fromPage The page to move the object from
+ * @param toPage The page to move the object to
+ * @param field Optional field to add to the fieldUpdates list (useful when we want to track updates across multiple pages)
+ */
+ constructor(
+ url: string,
+ from: number,
+ to: number,
+ fromPage: number,
+ toPage: number,
+ field?: Identifiable
+ ) {
+ this.payload = { url, from, to, fromPage, toPage, field };
+ }
+}
+
/* tslint:enable:max-classes-per-file */
/**
@@ -279,6 +369,9 @@ export type ObjectUpdatesAction
| ReinstateObjectUpdatesAction
| RemoveObjectUpdatesAction
| RemoveFieldUpdateAction
+ | MoveFieldUpdateAction
+ | AddPageToCustomOrderAction
+ | RemoveAllObjectUpdatesAction
| SelectVirtualMetadataAction
| SetEditableFieldUpdateAction
| SetValidFieldUpdateAction;
diff --git a/src/app/core/data/object-updates/object-updates.effects.ts b/src/app/core/data/object-updates/object-updates.effects.ts
index 88cd3bc718..239fee9477 100644
--- a/src/app/core/data/object-updates/object-updates.effects.ts
+++ b/src/app/core/data/object-updates/object-updates.effects.ts
@@ -3,12 +3,12 @@ import { Actions, Effect, ofType } from '@ngrx/effects';
import {
DiscardObjectUpdatesAction,
ObjectUpdatesAction,
- ObjectUpdatesActionTypes,
+ ObjectUpdatesActionTypes, RemoveAllObjectUpdatesAction,
RemoveObjectUpdatesAction
} from './object-updates.actions';
import { delay, filter, map, switchMap, take, tap } from 'rxjs/operators';
import { of as observableOf, race as observableRace, Subject } from 'rxjs';
-import { hasNoValue } from '../../../shared/empty.util';
+import { hasNoValue, hasValue } from '../../../shared/empty.util';
import { NotificationsService } from '../../../shared/notifications/notifications.service';
import { INotification } from '../../../shared/notifications/models/notification.model';
import {
@@ -16,6 +16,7 @@ import {
NotificationsActionTypes,
RemoveNotificationAction
} from '../../../shared/notifications/notifications.actions';
+import { Action } from '@ngrx/store';
/**
* NGRX effects for ObjectUpdatesActions
@@ -53,13 +54,14 @@ export class ObjectUpdatesEffects {
.pipe(
ofType(...Object.values(ObjectUpdatesActionTypes)),
map((action: ObjectUpdatesAction) => {
- const url: string = action.payload.url;
+ if (hasValue((action as any).payload)) {
+ const url: string = (action as any).payload.url;
if (hasNoValue(this.actionMap$[url])) {
this.actionMap$[url] = new Subject();
}
this.actionMap$[url].next(action);
}
- )
+ })
);
/**
@@ -91,9 +93,15 @@ export class ObjectUpdatesEffects {
const url: string = action.payload.url;
const notification: INotification = action.payload.notification;
const timeOut = notification.options.timeOut;
+
+ let removeAction: Action = new RemoveObjectUpdatesAction(action.payload.url);
+ if (action.payload.discardAll) {
+ removeAction = new RemoveAllObjectUpdatesAction();
+ }
+
return observableRace(
// Either wait for the delay and perform a remove action
- observableOf(new RemoveObjectUpdatesAction(action.payload.url)).pipe(delay(timeOut)),
+ observableOf(removeAction).pipe(delay(timeOut)),
// Or wait for a a user action
this.actionMap$[url].pipe(
take(1),
@@ -106,19 +114,19 @@ export class ObjectUpdatesEffects {
return { type: 'NO_ACTION' }
}
// If someone performed another action, assume the user does not want to reinstate and remove all changes
- return new RemoveObjectUpdatesAction(action.payload.url);
+ return removeAction
})
),
this.notificationActionMap$[notification.id].pipe(
filter((notificationsAction: NotificationsActions) => notificationsAction.type === NotificationsActionTypes.REMOVE_NOTIFICATION),
map(() => {
- return new RemoveObjectUpdatesAction(action.payload.url);
+ return removeAction;
})
),
this.notificationActionMap$[this.allIdentifier].pipe(
filter((notificationsAction: NotificationsActions) => notificationsAction.type === NotificationsActionTypes.REMOVE_ALL_NOTIFICATIONS),
map(() => {
- return new RemoveObjectUpdatesAction(action.payload.url);
+ return removeAction;
})
)
)
diff --git a/src/app/core/data/object-updates/object-updates.reducer.spec.ts b/src/app/core/data/object-updates/object-updates.reducer.spec.ts
index faae4732bc..bdf202049e 100644
--- a/src/app/core/data/object-updates/object-updates.reducer.spec.ts
+++ b/src/app/core/data/object-updates/object-updates.reducer.spec.ts
@@ -1,10 +1,10 @@
import * as deepFreeze from 'deep-freeze';
import {
- AddFieldUpdateAction,
+ AddFieldUpdateAction, AddPageToCustomOrderAction,
DiscardObjectUpdatesAction,
FieldChangeType,
- InitializeFieldsAction,
- ReinstateObjectUpdatesAction,
+ InitializeFieldsAction, MoveFieldUpdateAction,
+ ReinstateObjectUpdatesAction, RemoveAllObjectUpdatesAction,
RemoveFieldUpdateAction, RemoveObjectUpdatesAction, SelectVirtualMetadataAction,
SetEditableFieldUpdateAction, SetValidFieldUpdateAction
} from './object-updates.actions';
@@ -85,6 +85,16 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
+ customOrder: {
+ initialOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ newOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ pageSize: 10,
+ changed: false
+ }
}
};
@@ -111,6 +121,16 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
+ customOrder: {
+ initialOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ newOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ pageSize: 10,
+ changed: false
+ }
},
[url + OBJECT_UPDATES_TRASH_PATH]: {
fieldStates: {
@@ -145,6 +165,16 @@ describe('objectUpdatesReducer', () => {
virtualMetadataSources: {
[relationship.uuid]: {[identifiable1.uuid]: true}
},
+ customOrder: {
+ initialOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ newOrderPages: [
+ { order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid] }
+ ],
+ pageSize: 10,
+ changed: false
+ }
}
};
@@ -213,7 +243,7 @@ describe('objectUpdatesReducer', () => {
});
it('should initialize all fields when the INITIALIZE action is dispatched, based on the payload', () => {
- const action = new InitializeFieldsAction(url, [identifiable1, identifiable3], modDate);
+ const action = new InitializeFieldsAction(url, [identifiable1, identifiable3], modDate, [identifiable1.uuid, identifiable3.uuid], 10, 0);
const expectedState = {
[url]: {
@@ -231,7 +261,17 @@ describe('objectUpdatesReducer', () => {
},
fieldUpdates: {},
virtualMetadataSources: {},
- lastModified: modDate
+ lastModified: modDate,
+ customOrder: {
+ initialOrderPages: [
+ { order: [identifiable1.uuid, identifiable3.uuid] }
+ ],
+ newOrderPages: [
+ { order: [identifiable1.uuid, identifiable3.uuid] }
+ ],
+ pageSize: 10,
+ changed: false
+ }
}
};
const newState = objectUpdatesReducer(testState, action);
@@ -283,10 +323,44 @@ describe('objectUpdatesReducer', () => {
expect(newState[url + OBJECT_UPDATES_TRASH_PATH]).toBeUndefined();
});
+ it('should remove all updates from the state when the REMOVE_ALL action is dispatched', () => {
+ const action = new RemoveAllObjectUpdatesAction();
+
+ const newState = objectUpdatesReducer(discardedTestState, action as any);
+ expect(newState[url].fieldUpdates).toBeUndefined();
+ expect(newState[url + OBJECT_UPDATES_TRASH_PATH]).toBeUndefined();
+ });
+
it('should remove a given field\'s update from the state when the REMOVE_FIELD action is dispatched, based on the payload', () => {
const action = new RemoveFieldUpdateAction(url, uuid);
const newState = objectUpdatesReducer(testState, action);
expect(newState[url].fieldUpdates[uuid]).toBeUndefined();
});
+
+ it('should move the custom order from the state when the MOVE action is dispatched', () => {
+ const action = new MoveFieldUpdateAction(url, 0, 1, 0, 0);
+
+ const newState = objectUpdatesReducer(testState, action);
+ expect(newState[url].customOrder.newOrderPages[0].order[0]).toEqual(testState[url].customOrder.newOrderPages[0].order[1]);
+ expect(newState[url].customOrder.newOrderPages[0].order[1]).toEqual(testState[url].customOrder.newOrderPages[0].order[0]);
+ expect(newState[url].customOrder.changed).toEqual(true);
+ });
+
+ it('should add a new page to the custom order and add empty pages in between when the ADD_PAGE_TO_CUSTOM_ORDER action is dispatched', () => {
+ const identifiable4 = {
+ uuid: 'a23eae5a-7857-4ef9-8e52-989436ad2955',
+ key: 'dc.description.abstract',
+ language: null,
+ value: 'Extra value'
+ };
+ const action = new AddPageToCustomOrderAction(url, [identifiable4], [identifiable4.uuid], 2);
+
+ const newState = objectUpdatesReducer(testState, action);
+ // Confirm the page in between the two pages (index 1) has been filled with 10 (page size) undefined values
+ expect(newState[url].customOrder.newOrderPages[1].order.length).toEqual(10);
+ expect(newState[url].customOrder.newOrderPages[1].order[0]).toBeUndefined();
+ // Verify the new page is correct
+ expect(newState[url].customOrder.newOrderPages[2].order[0]).toEqual(identifiable4.uuid);
+ });
});
diff --git a/src/app/core/data/object-updates/object-updates.reducer.ts b/src/app/core/data/object-updates/object-updates.reducer.ts
index cffd41856d..759a9f5c87 100644
--- a/src/app/core/data/object-updates/object-updates.reducer.ts
+++ b/src/app/core/data/object-updates/object-updates.reducer.ts
@@ -1,8 +1,8 @@
import {
- AddFieldUpdateAction,
+ AddFieldUpdateAction, AddPageToCustomOrderAction,
DiscardObjectUpdatesAction,
FieldChangeType,
- InitializeFieldsAction,
+ InitializeFieldsAction, MoveFieldUpdateAction,
ObjectUpdatesAction,
ObjectUpdatesActionTypes,
ReinstateObjectUpdatesAction,
@@ -12,7 +12,9 @@ import {
SetValidFieldUpdateAction,
SelectVirtualMetadataAction,
} from './object-updates.actions';
-import { hasNoValue, hasValue } from '../../../shared/empty.util';
+import { hasNoValue, hasValue, isEmpty, isNotEmpty } from '../../../shared/empty.util';
+import { moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';
+import { from } from 'rxjs/internal/observable/from';
import {Relationship} from '../../shared/item-relationships/relationship.model';
/**
@@ -46,7 +48,7 @@ export interface Identifiable {
/**
* The state of a single field update
*/
-export interface FieldUpdate {
+export interface FieldUpdate {
field: Identifiable,
changeType: FieldChangeType
}
@@ -81,6 +83,20 @@ export interface DeleteRelationship extends Relationship {
keepRightVirtualMetadata: boolean,
}
+/**
+ * A custom order given to the list of objects
+ */
+export interface CustomOrder {
+ initialOrderPages: OrderPage[],
+ newOrderPages: OrderPage[],
+ pageSize: number;
+ changed: boolean
+}
+
+export interface OrderPage {
+ order: string[]
+}
+
/**
* The updated state of a single page
*/
@@ -89,6 +105,7 @@ export interface ObjectUpdatesEntry {
fieldUpdates: FieldUpdates;
virtualMetadataSources: VirtualMetadataSources;
lastModified: Date;
+ customOrder: CustomOrder
}
/**
@@ -121,6 +138,9 @@ export function objectUpdatesReducer(state = initialState, action: ObjectUpdates
case ObjectUpdatesActionTypes.INITIALIZE_FIELDS: {
return initializeFieldsUpdate(state, action as InitializeFieldsAction);
}
+ case ObjectUpdatesActionTypes.ADD_PAGE_TO_CUSTOM_ORDER: {
+ return addPageToCustomOrder(state, action as AddPageToCustomOrderAction);
+ }
case ObjectUpdatesActionTypes.ADD_FIELD: {
return addFieldUpdate(state, action as AddFieldUpdateAction);
}
@@ -136,6 +156,9 @@ export function objectUpdatesReducer(state = initialState, action: ObjectUpdates
case ObjectUpdatesActionTypes.REMOVE: {
return removeObjectUpdates(state, action as RemoveObjectUpdatesAction);
}
+ case ObjectUpdatesActionTypes.REMOVE_ALL: {
+ return removeAllObjectUpdates(state);
+ }
case ObjectUpdatesActionTypes.REMOVE_FIELD: {
return removeFieldUpdate(state, action as RemoveFieldUpdateAction);
}
@@ -145,6 +168,9 @@ export function objectUpdatesReducer(state = initialState, action: ObjectUpdates
case ObjectUpdatesActionTypes.SET_VALID_FIELD: {
return setValidFieldUpdate(state, action as SetValidFieldUpdateAction);
}
+ case ObjectUpdatesActionTypes.MOVE: {
+ return moveFieldUpdate(state, action as MoveFieldUpdateAction);
+ }
default: {
return state;
}
@@ -160,18 +186,50 @@ function initializeFieldsUpdate(state: any, action: InitializeFieldsAction) {
const url: string = action.payload.url;
const fields: Identifiable[] = action.payload.fields;
const lastModifiedServer: Date = action.payload.lastModified;
+ const order = action.payload.order;
+ const pageSize = action.payload.pageSize;
+ const page = action.payload.page;
const fieldStates = createInitialFieldStates(fields);
+ const initialOrderPages = addOrderToPages([], order, pageSize, page);
const newPageState = Object.assign(
{},
state[url],
{ fieldStates: fieldStates },
{ fieldUpdates: {} },
{ virtualMetadataSources: {} },
- { lastModified: lastModifiedServer }
+ { lastModified: lastModifiedServer },
+ { customOrder: {
+ initialOrderPages: initialOrderPages,
+ newOrderPages: initialOrderPages,
+ pageSize: pageSize,
+ changed: false }
+ }
);
return Object.assign({}, state, { [url]: newPageState });
}
+/**
+ * Add a page of objects to the state of a specific url and update a specific page of the custom order
+ * @param state The current state
+ * @param action The action to perform on the current state
+ */
+function addPageToCustomOrder(state: any, action: AddPageToCustomOrderAction) {
+ const url: string = action.payload.url;
+ const fields: Identifiable[] = action.payload.fields;
+ const fieldStates = createInitialFieldStates(fields);
+ const order = action.payload.order;
+ const page = action.payload.page;
+ const pageState: ObjectUpdatesEntry = state[url] || {};
+ const newPageState = Object.assign({}, pageState, {
+ fieldStates: Object.assign({}, pageState.fieldStates, fieldStates),
+ customOrder: Object.assign({}, pageState.customOrder, {
+ newOrderPages: addOrderToPages(pageState.customOrder.newOrderPages, order, pageState.customOrder.pageSize, page),
+ initialOrderPages: addOrderToPages(pageState.customOrder.initialOrderPages, order, pageState.customOrder.pageSize, page)
+ })
+ });
+ return Object.assign({}, state, { [url]: newPageState });
+}
+
/**
* Add a new update for a specific field to the store
* @param state The current state
@@ -252,7 +310,24 @@ function selectVirtualMetadata(state: any, action: SelectVirtualMetadataAction)
* @param action The action to perform on the current state
*/
function discardObjectUpdates(state: any, action: DiscardObjectUpdatesAction) {
- const url: string = action.payload.url;
+ if (action.payload.discardAll) {
+ let newState = Object.assign({}, state);
+ Object.keys(state).filter((path: string) => !path.endsWith(OBJECT_UPDATES_TRASH_PATH)).forEach((path: string) => {
+ newState = discardObjectUpdatesFor(path, newState);
+ });
+ return newState;
+ } else {
+ const url: string = action.payload.url;
+ return discardObjectUpdatesFor(url, state);
+ }
+}
+
+/**
+ * Discard all updates for a specific action's url in the store
+ * @param url The action's url
+ * @param state The current state
+ */
+function discardObjectUpdatesFor(url: string, state: any) {
const pageState: ObjectUpdatesEntry = state[url];
const newFieldStates = {};
Object.keys(pageState.fieldStates).forEach((uuid: string) => {
@@ -263,9 +338,19 @@ function discardObjectUpdates(state: any, action: DiscardObjectUpdatesAction) {
}
});
+ const newCustomOrder = Object.assign({}, pageState.customOrder);
+ if (pageState.customOrder.changed) {
+ const initialOrder = pageState.customOrder.initialOrderPages;
+ if (isNotEmpty(initialOrder)) {
+ newCustomOrder.newOrderPages = initialOrder;
+ newCustomOrder.changed = false;
+ }
+ }
+
const discardedPageState = Object.assign({}, pageState, {
fieldUpdates: {},
- fieldStates: newFieldStates
+ fieldStates: newFieldStates,
+ customOrder: newCustomOrder
});
return Object.assign({}, state, { [url]: discardedPageState }, { [url + OBJECT_UPDATES_TRASH_PATH]: pageState });
}
@@ -305,6 +390,18 @@ function removeObjectUpdatesByURL(state: any, url: string) {
return newState;
}
+/**
+ * Remove all updates in the store
+ * @param state The current state
+ */
+function removeAllObjectUpdates(state: any) {
+ const newState = Object.assign({}, state);
+ Object.keys(state).filter((path: string) => path.endsWith(OBJECT_UPDATES_TRASH_PATH)).forEach((path: string) => {
+ delete newState[path];
+ });
+ return newState;
+}
+
/**
* Discard the update for a specific action's url and field UUID in the store
* @param state The current state
@@ -407,3 +504,121 @@ function createInitialFieldStates(fields: Identifiable[]) {
uuids.forEach((uuid: string) => fieldStates[uuid] = initialFieldState);
return fieldStates;
}
+
+/**
+ * Method to add a list of objects to an existing FieldStates object
+ * @param fieldStates FieldStates to add states to
+ * @param fields Identifiable objects The list of objects to add to the FieldStates
+ */
+function addFieldStates(fieldStates: FieldStates, fields: Identifiable[]) {
+ const uuids = fields.map((field: Identifiable) => field.uuid);
+ uuids.forEach((uuid: string) => fieldStates[uuid] = initialFieldState);
+ return fieldStates;
+}
+
+/**
+ * Move an object within the custom order of a page state
+ * @param state The current state
+ * @param action The move action to perform
+ */
+function moveFieldUpdate(state: any, action: MoveFieldUpdateAction) {
+ const url = action.payload.url;
+ const fromIndex = action.payload.from;
+ const toIndex = action.payload.to;
+ const fromPage = action.payload.fromPage;
+ const toPage = action.payload.toPage;
+ const field = action.payload.field;
+
+ const pageState: ObjectUpdatesEntry = state[url];
+ const initialOrderPages = pageState.customOrder.initialOrderPages;
+ const customOrderPages = [...pageState.customOrder.newOrderPages];
+
+ // Create a copy of the custom orders for the from- and to-pages
+ const fromPageOrder = [...customOrderPages[fromPage].order];
+ const toPageOrder = [...customOrderPages[toPage].order];
+ if (fromPage === toPage) {
+ if (isNotEmpty(customOrderPages[fromPage]) && isNotEmpty(customOrderPages[fromPage].order[fromIndex]) && isNotEmpty(customOrderPages[fromPage].order[toIndex])) {
+ // Move an item from one index to another within the same page
+ moveItemInArray(fromPageOrder, fromIndex, toIndex);
+ // Update the custom order for this page
+ customOrderPages[fromPage] = { order: fromPageOrder };
+ }
+ } else {
+ if (isNotEmpty(customOrderPages[fromPage]) && hasValue(customOrderPages[toPage]) && isNotEmpty(customOrderPages[fromPage].order[fromIndex])) {
+ // Move an item from one index of one page to an index in another page
+ transferArrayItem(fromPageOrder, toPageOrder, fromIndex, toIndex);
+ // Update the custom order for both pages
+ customOrderPages[fromPage] = { order: fromPageOrder };
+ customOrderPages[toPage] = { order: toPageOrder };
+ }
+ }
+
+ // Create a field update if it doesn't exist for this field yet
+ let fieldUpdate = {};
+ if (hasValue(field)) {
+ fieldUpdate = pageState.fieldUpdates[field.uuid];
+ if (hasNoValue(fieldUpdate)) {
+ fieldUpdate = { field: field, changeType: undefined }
+ }
+ }
+
+ // Update the store's state with new values and return
+ return Object.assign({}, state, { [url]: Object.assign({}, pageState, {
+ fieldUpdates: Object.assign({}, pageState.fieldUpdates, hasValue(field) ? { [field.uuid]: fieldUpdate } : {}),
+ customOrder: Object.assign({}, pageState.customOrder, { newOrderPages: customOrderPages, changed: checkForOrderChanges(initialOrderPages, customOrderPages) })
+ })})
+}
+
+/**
+ * Compare two lists of OrderPage objects and return whether there's at least one change in the order of objects within
+ * @param initialOrderPages The initial list of OrderPages
+ * @param customOrderPages The changed list of OrderPages
+ */
+function checkForOrderChanges(initialOrderPages: OrderPage[], customOrderPages: OrderPage[]) {
+ let changed = false;
+ initialOrderPages.forEach((orderPage: OrderPage, page: number) => {
+ if (isNotEmpty(orderPage) && isNotEmpty(orderPage.order) && isNotEmpty(customOrderPages[page]) && isNotEmpty(customOrderPages[page].order)) {
+ orderPage.order.forEach((id: string, index: number) => {
+ if (id !== customOrderPages[page].order[index]) {
+ changed = true;
+ return;
+ }
+ });
+ if (changed) {
+ return;
+ }
+ }
+ });
+ return changed;
+}
+
+/**
+ * Initialize a custom order page by providing the list of all pages, a list of UUIDs, pageSize and the page to populate
+ * @param initialPages The initial list of OrderPage objects
+ * @param order The list of UUIDs to create a page for
+ * @param pageSize The pageSize used to populate empty spacer pages
+ * @param page The index of the page to add
+ */
+function addOrderToPages(initialPages: OrderPage[], order: string[], pageSize: number, page: number): OrderPage[] {
+ const result = [...initialPages];
+ const orderPage: OrderPage = { order: order };
+ if (page < result.length) {
+ // The page we're trying to add already exists in the list. Overwrite it.
+ result[page] = orderPage;
+ } else if (page === result.length) {
+ // The page we're trying to add is the next page in the list, add it.
+ result.push(orderPage);
+ } else {
+ // The page we're trying to add is at least one page ahead of the list, fill the list with empty pages before adding the page.
+ const emptyOrder = [];
+ for (let i = 0; i < pageSize; i++) {
+ emptyOrder.push(undefined);
+ }
+ const emptyOrderPage: OrderPage = { order: emptyOrder };
+ for (let i = result.length; i < page; i++) {
+ result.push(emptyOrderPage);
+ }
+ result.push(orderPage);
+ }
+ return result;
+}
diff --git a/src/app/core/data/object-updates/object-updates.service.spec.ts b/src/app/core/data/object-updates/object-updates.service.spec.ts
index 730ee5ad43..780a402a84 100644
--- a/src/app/core/data/object-updates/object-updates.service.spec.ts
+++ b/src/app/core/data/object-updates/object-updates.service.spec.ts
@@ -2,6 +2,7 @@ import { Store } from '@ngrx/store';
import { CoreState } from '../../core.reducers';
import { ObjectUpdatesService } from './object-updates.service';
import {
+ AddPageToCustomOrderAction,
DiscardObjectUpdatesAction,
FieldChangeType,
InitializeFieldsAction, ReinstateObjectUpdatesAction, RemoveFieldUpdateAction, SelectVirtualMetadataAction,
@@ -12,6 +13,8 @@ import { Notification } from '../../../shared/notifications/models/notification.
import { NotificationType } from '../../../shared/notifications/models/notification-type';
import { OBJECT_UPDATES_TRASH_PATH } from './object-updates.reducer';
import {Relationship} from '../../shared/item-relationships/relationship.model';
+import { MoveOperation } from 'fast-json-patch/lib/core';
+import { ArrayMoveChangeAnalyzer } from '../array-move-change-analyzer.service';
describe('ObjectUpdatesService', () => {
let service: ObjectUpdatesService;
@@ -44,7 +47,7 @@ describe('ObjectUpdatesService', () => {
};
store = new Store(undefined, undefined, undefined);
spyOn(store, 'dispatch');
- service = (new ObjectUpdatesService(store));
+ service = new ObjectUpdatesService(store, new ArrayMoveChangeAnalyzer());
spyOn(service as any, 'getObjectEntry').and.returnValue(observableOf(objectEntry));
spyOn(service as any, 'getFieldState').and.callFake((uuid) => {
@@ -60,6 +63,25 @@ describe('ObjectUpdatesService', () => {
});
});
+ describe('initializeWithCustomOrder', () => {
+ const pageSize = 20;
+ const page = 0;
+
+ it('should dispatch an INITIALIZE action with the correct URL, initial identifiables, last modified , custom order, page size and page', () => {
+ service.initializeWithCustomOrder(url, identifiables, modDate, pageSize, page);
+ expect(store.dispatch).toHaveBeenCalledWith(new InitializeFieldsAction(url, identifiables, modDate, identifiables.map((identifiable) => identifiable.uuid), pageSize, page));
+ });
+ });
+
+ describe('addPageToCustomOrder', () => {
+ const page = 2;
+
+ it('should dispatch an ADD_PAGE_TO_CUSTOM_ORDER action with the correct URL, identifiables, custom order and page number to add', () => {
+ service.addPageToCustomOrder(url, identifiables, page);
+ expect(store.dispatch).toHaveBeenCalledWith(new AddPageToCustomOrderAction(url, identifiables, identifiables.map((identifiable) => identifiable.uuid), page));
+ });
+ });
+
describe('getFieldUpdates', () => {
it('should return the list of all fields, including their update if there is one', () => {
const result$ = service.getFieldUpdates(url, identifiables);
@@ -77,6 +99,66 @@ describe('ObjectUpdatesService', () => {
});
});
+ describe('getFieldUpdatesExclusive', () => {
+ it('should return the list of all fields, including their update if there is one, excluding updates that aren\'t part of the initial values provided', (done) => {
+ const result$ = service.getFieldUpdatesExclusive(url, identifiables);
+ expect((service as any).getObjectEntry).toHaveBeenCalledWith(url);
+
+ const expectedResult = {
+ [identifiable1.uuid]: { field: identifiable1Updated, changeType: FieldChangeType.UPDATE },
+ [identifiable2.uuid]: { field: identifiable2, changeType: undefined }
+ };
+
+ result$.subscribe((result) => {
+ expect(result).toEqual(expectedResult);
+ done();
+ });
+ });
+ });
+
+ describe('getFieldUpdatesByCustomOrder', () => {
+ beforeEach(() => {
+ const fieldStates = {
+ [identifiable1.uuid]: { editable: false, isNew: false, isValid: true },
+ [identifiable2.uuid]: { editable: true, isNew: false, isValid: false },
+ [identifiable3.uuid]: { editable: true, isNew: true, isValid: true },
+ };
+
+ const customOrder = {
+ initialOrderPages: [{
+ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid]
+ }],
+ newOrderPages: [{
+ order: [identifiable2.uuid, identifiable3.uuid, identifiable1.uuid]
+ }],
+ pageSize: 20,
+ changed: true
+ };
+
+ const objectEntry = {
+ fieldStates, fieldUpdates, lastModified: modDate, virtualMetadataSources: {}, customOrder
+ };
+
+ (service as any).getObjectEntry.and.returnValue(observableOf(objectEntry))
+ });
+
+ it('should return the list of all fields, including their update if there is one, ordered by their custom order', (done) => {
+ const result$ = service.getFieldUpdatesByCustomOrder(url, identifiables);
+ expect((service as any).getObjectEntry).toHaveBeenCalledWith(url);
+
+ const expectedResult = {
+ [identifiable2.uuid]: { field: identifiable2, changeType: undefined },
+ [identifiable3.uuid]: { field: identifiable3, changeType: FieldChangeType.ADD },
+ [identifiable1.uuid]: { field: identifiable1Updated, changeType: FieldChangeType.UPDATE }
+ };
+
+ result$.subscribe((result) => {
+ expect(result).toEqual(expectedResult);
+ done();
+ });
+ });
+ });
+
describe('isEditable', () => {
it('should return false if this identifiable is currently not editable in the store', () => {
const result$ = service.isEditable(url, identifiable1.uuid);
@@ -192,7 +274,11 @@ describe('ObjectUpdatesService', () => {
});
describe('when updates are emtpy', () => {
beforeEach(() => {
- (service as any).getObjectEntry.and.returnValue(observableOf({}))
+ (service as any).getObjectEntry.and.returnValue(observableOf({
+ customOrder: {
+ changed: false
+ }
+ }))
});
it('should return false when there are no updates', () => {
@@ -259,4 +345,45 @@ describe('ObjectUpdatesService', () => {
expect(store.dispatch).toHaveBeenCalledWith(new SelectVirtualMetadataAction(url, relationship.uuid, identifiable1.uuid, true));
});
});
+
+ describe('getMoveOperations', () => {
+ beforeEach(() => {
+ const fieldStates = {
+ [identifiable1.uuid]: { editable: false, isNew: false, isValid: true },
+ [identifiable2.uuid]: { editable: true, isNew: false, isValid: false },
+ [identifiable3.uuid]: { editable: true, isNew: true, isValid: true },
+ };
+
+ const customOrder = {
+ initialOrderPages: [{
+ order: [identifiable1.uuid, identifiable2.uuid, identifiable3.uuid]
+ }],
+ newOrderPages: [{
+ order: [identifiable2.uuid, identifiable3.uuid, identifiable1.uuid]
+ }],
+ pageSize: 20,
+ changed: true
+ };
+
+ const objectEntry = {
+ fieldStates, fieldUpdates, lastModified: modDate, virtualMetadataSources: {}, customOrder
+ };
+
+ (service as any).getObjectEntry.and.returnValue(observableOf(objectEntry))
+ });
+
+ it('should return the expected move operations', (done) => {
+ const result$ = service.getMoveOperations(url);
+
+ const expectedResult = [
+ { op: 'move', from: '/0', path: '/2' }
+ ] as MoveOperation[];
+
+ result$.subscribe((result) => {
+ expect(result).toEqual(expectedResult);
+ done();
+ });
+ });
+ });
+
});
diff --git a/src/app/core/data/object-updates/object-updates.service.ts b/src/app/core/data/object-updates/object-updates.service.ts
index 367b73ee30..c9a7f47e81 100644
--- a/src/app/core/data/object-updates/object-updates.service.ts
+++ b/src/app/core/data/object-updates/object-updates.service.ts
@@ -8,15 +8,16 @@ import {
Identifiable,
OBJECT_UPDATES_TRASH_PATH,
ObjectUpdatesEntry,
- ObjectUpdatesState,
+ ObjectUpdatesState, OrderPage,
VirtualMetadataSource
} from './object-updates.reducer';
import { Observable } from 'rxjs';
import {
- AddFieldUpdateAction,
+ AddFieldUpdateAction, AddPageToCustomOrderAction,
DiscardObjectUpdatesAction,
FieldChangeType,
InitializeFieldsAction,
+ MoveFieldUpdateAction,
ReinstateObjectUpdatesAction,
RemoveFieldUpdateAction,
SelectVirtualMetadataAction,
@@ -26,6 +27,9 @@ import {
import { distinctUntilChanged, filter, map, switchMap } from 'rxjs/operators';
import { hasNoValue, hasValue, isEmpty, isNotEmpty } from '../../../shared/empty.util';
import { INotification } from '../../../shared/notifications/models/notification.model';
+import { ArrayMoveChangeAnalyzer } from '../array-move-change-analyzer.service';
+import { MoveOperation } from 'fast-json-patch/lib/core';
+import { flatten } from '@angular/compiler';
function objectUpdatesStateSelector(): MemoizedSelector {
return createSelector(coreSelector, (state: CoreState) => state['cache/object-updates']);
@@ -48,7 +52,8 @@ function virtualMetadataSourceSelector(url: string, source: string): MemoizedSel
*/
@Injectable()
export class ObjectUpdatesService {
- constructor(private store: Store) {
+ constructor(private store: Store,
+ private comparator: ArrayMoveChangeAnalyzer) {
}
@@ -62,6 +67,28 @@ export class ObjectUpdatesService {
this.store.dispatch(new InitializeFieldsAction(url, fields, lastModified));
}
+ /**
+ * Method to dispatch an InitializeFieldsAction to the store and keeping track of the order objects are stored
+ * @param url The page's URL for which the changes are being mapped
+ * @param fields The initial fields for the page's object
+ * @param lastModified The date the object was last modified
+ * @param pageSize The page size to use for adding pages to the custom order
+ * @param page The first page to populate the custom order with
+ */
+ initializeWithCustomOrder(url, fields: Identifiable[], lastModified: Date, pageSize = 9999, page = 0): void {
+ this.store.dispatch(new InitializeFieldsAction(url, fields, lastModified, fields.map((field) => field.uuid), pageSize, page));
+ }
+
+ /**
+ * Method to dispatch an AddPageToCustomOrderAction, adding a new page to an already existing custom order tracking
+ * @param url The URL for which the changes are being mapped
+ * @param fields The fields to add a new page for
+ * @param page The page number (starting from index 0)
+ */
+ addPageToCustomOrder(url, fields: Identifiable[], page: number): void {
+ this.store.dispatch(new AddPageToCustomOrderAction(url, fields, fields.map((field) => field.uuid), page));
+ }
+
/**
* Method to dispatch an AddFieldUpdateAction to the store
* @param url The page's URL for which the changes are saved
@@ -94,14 +121,15 @@ export class ObjectUpdatesService {
* a FieldUpdates object
* @param url The URL of the page for which the FieldUpdates should be requested
* @param initialFields The initial values of the fields
+ * @param ignoreStates Ignore the fieldStates to loop over the fieldUpdates instead
*/
- getFieldUpdates(url: string, initialFields: Identifiable[]): Observable {
+ getFieldUpdates(url: string, initialFields: Identifiable[], ignoreStates?: boolean): Observable {
const objectUpdates = this.getObjectEntry(url);
return objectUpdates.pipe(
switchMap((objectEntry) => {
const fieldUpdates: FieldUpdates = {};
if (hasValue(objectEntry)) {
- Object.keys(objectEntry.fieldStates).forEach((uuid) => {
+ Object.keys(ignoreStates ? objectEntry.fieldUpdates : objectEntry.fieldStates).forEach((uuid) => {
fieldUpdates[uuid] = objectEntry.fieldUpdates[uuid];
});
}
@@ -138,6 +166,31 @@ export class ObjectUpdatesService {
}))
}
+ /**
+ * Method that combines the state's updates with the initial values (when there's no update),
+ * sorted by their custom order to create a FieldUpdates object
+ * @param url The URL of the page for which the FieldUpdates should be requested
+ * @param initialFields The initial values of the fields
+ * @param page The page to retrieve
+ */
+ getFieldUpdatesByCustomOrder(url: string, initialFields: Identifiable[], page = 0): Observable {
+ const objectUpdates = this.getObjectEntry(url);
+ return objectUpdates.pipe(map((objectEntry) => {
+ const fieldUpdates: FieldUpdates = {};
+ if (hasValue(objectEntry) && hasValue(objectEntry.customOrder) && isNotEmpty(objectEntry.customOrder.newOrderPages) && page < objectEntry.customOrder.newOrderPages.length) {
+ for (const uuid of objectEntry.customOrder.newOrderPages[page].order) {
+ let fieldUpdate = objectEntry.fieldUpdates[uuid];
+ if (isEmpty(fieldUpdate)) {
+ const identifiable = initialFields.find((object: Identifiable) => object.uuid === uuid);
+ fieldUpdate = {field: identifiable, changeType: undefined};
+ }
+ fieldUpdates[uuid] = fieldUpdate;
+ }
+ }
+ return fieldUpdates;
+ }))
+ }
+
/**
* Method to check if a specific field is currently editable in the store
* @param url The URL of the page on which the field resides
@@ -207,6 +260,19 @@ export class ObjectUpdatesService {
this.saveFieldUpdate(url, field, FieldChangeType.UPDATE);
}
+ /**
+ * Dispatches a MoveFieldUpdateAction
+ * @param url The page's URL for which the changes are saved
+ * @param from The index of the object to move
+ * @param to The index to move the object to
+ * @param fromPage The page to move the object from
+ * @param toPage The page to move the object to
+ * @param field Optional field to add to the fieldUpdates list (useful if we want to track updates across multiple pages)
+ */
+ saveMoveFieldUpdate(url: string, from: number, to: number, fromPage = 0, toPage = 0, field?: Identifiable) {
+ this.store.dispatch(new MoveFieldUpdateAction(url, from, to, fromPage, toPage, field));
+ }
+
/**
* Check whether the virtual metadata of a given item is selected to be saved as real metadata
* @param url The URL of the page on which the field resides
@@ -264,6 +330,15 @@ export class ObjectUpdatesService {
this.store.dispatch(new DiscardObjectUpdatesAction(url, undoNotification));
}
+ /**
+ * Method to dispatch a DiscardObjectUpdatesAction to the store with discardAll set to true
+ * @param url The page's URL for which the changes should be discarded
+ * @param undoNotification The notification which is should possibly be canceled
+ */
+ discardAllFieldUpdates(url: string, undoNotification: INotification) {
+ this.store.dispatch(new DiscardObjectUpdatesAction(url, undoNotification, true));
+ }
+
/**
* Method to dispatch an ReinstateObjectUpdatesAction to the store
* @param url The page's URL for which the changes should be reinstated
@@ -312,7 +387,7 @@ export class ObjectUpdatesService {
* @param url The page's url to check for in the store
*/
hasUpdates(url: string): Observable {
- return this.getObjectEntry(url).pipe(map((objectEntry) => hasValue(objectEntry) && isNotEmpty(objectEntry.fieldUpdates)));
+ return this.getObjectEntry(url).pipe(map((objectEntry) => hasValue(objectEntry) && (isNotEmpty(objectEntry.fieldUpdates) || objectEntry.customOrder.changed)));
}
/**
@@ -330,4 +405,19 @@ export class ObjectUpdatesService {
getLastModified(url: string): Observable {
return this.getObjectEntry(url).pipe(map((entry: ObjectUpdatesEntry) => entry.lastModified));
}
+
+ /**
+ * Get move operations based on the custom order
+ * @param url The page's url
+ */
+ getMoveOperations(url: string): Observable {
+ return this.getObjectEntry(url).pipe(
+ map((objectEntry) => objectEntry.customOrder),
+ map((customOrder) => this.comparator.diff(
+ flatten(customOrder.initialOrderPages.map((orderPage: OrderPage) => orderPage.order)),
+ flatten(customOrder.newOrderPages.map((orderPage: OrderPage) => orderPage.order)))
+ )
+ );
+ }
+
}
diff --git a/src/app/core/data/request.service.spec.ts b/src/app/core/data/request.service.spec.ts
index 2789f6df54..253577a701 100644
--- a/src/app/core/data/request.service.spec.ts
+++ b/src/app/core/data/request.service.spec.ts
@@ -22,6 +22,7 @@ import {
} from './request.models';
import { RequestEntry } from './request.reducer';
import { RequestService } from './request.service';
+import { parseJsonSchemaToCommandDescription } from '@angular/cli/utilities/json-schema';
describe('RequestService', () => {
let scheduler: TestScheduler;
@@ -139,13 +140,21 @@ describe('RequestService', () => {
describe('getByUUID', () => {
describe('if the request with the specified UUID exists in the store', () => {
beforeEach(() => {
+ let callCounter = 0;
+ const responses = [
+ cold('a', { // A direct hit in the request cache
+ a: {
+ completed: true
+ }
+ }),
+ cold('b', { b: undefined }), // No hit in the index
+ cold('c', { c: undefined }) // So no mapped hit in the request cache
+ ];
selectSpy.and.callFake(() => {
return () => {
- return () => hot('a', {
- a: {
- completed: true
- }
- });
+ const response = responses[callCounter];
+ callCounter++;
+ return () => response;
};
});
});
@@ -162,11 +171,19 @@ describe('RequestService', () => {
});
});
- describe('if the request with the specified UUID doesn\'t exist in the store', () => {
+ describe(`if the request with the specified UUID doesn't exist in the store `, () => {
beforeEach(() => {
+ let callCounter = 0;
+ const responses = [
+ cold('a', { a: undefined }), // No direct hit in the request cache
+ cold('b', { b: undefined }), // No hit in the index
+ cold('c', { c: undefined }), // So no mapped hit in the request cache
+ ];
selectSpy.and.callFake(() => {
return () => {
- return () => hot('a', { a: undefined });
+ const response = responses[callCounter];
+ callCounter++;
+ return () => response;
};
});
});
@@ -174,11 +191,43 @@ describe('RequestService', () => {
it('should return an Observable of undefined', () => {
const result = service.getByUUID(testUUID);
- scheduler.expectObservable(result).toBe('b', { b: undefined });
+ scheduler.expectObservable(result).toBe('a', { a: undefined });
});
});
- });
+ describe(`if the request with the specified UUID wasn't sent, because it was already cached`, () => {
+ beforeEach(() => {
+ let callCounter = 0;
+ const responses = [
+ cold('a', { a: undefined }), // No direct hit in the request cache with that UUID
+ cold('b', { b: 'otherRequestUUID' }), // A hit in the index, which returns the uuid of the cached request
+ cold('c', { // the call to retrieve the cached request using the UUID from the index
+ c: {
+ completed: true
+ }
+ })
+ ];
+ selectSpy.and.callFake(() => {
+ return () => {
+ const response = responses[callCounter];
+ callCounter++;
+ return () => response;
+ };
+ });
+ });
+
+ it(`it should return the cached request`, () => {
+ const result = service.getByUUID(testUUID);
+
+ scheduler.expectObservable(result).toBe('c', {
+ c: {
+ completed: true
+ }
+ });
+ });
+ });
+
+ });
describe('getByHref', () => {
describe('when the request with the specified href exists in the store', () => {
diff --git a/src/app/core/data/request.service.ts b/src/app/core/data/request.service.ts
index 810b0721ae..105d84cf4a 100644
--- a/src/app/core/data/request.service.ts
+++ b/src/app/core/data/request.service.ts
@@ -2,10 +2,10 @@ import { Injectable } from '@angular/core';
import { HttpHeaders } from '@angular/common/http';
import { createSelector, MemoizedSelector, select, Store } from '@ngrx/store';
-import { Observable, race as observableRace } from 'rxjs';
-import { filter, map, mergeMap, take } from 'rxjs/operators';
+import { Observable, combineLatest as observableCombineLatest } from 'rxjs';
+import { filter, map, mergeMap, take, switchMap, startWith } from 'rxjs/operators';
import { cloneDeep, remove } from 'lodash';
-import { hasValue, isEmpty, isNotEmpty } from '../../shared/empty.util';
+import { hasValue, isEmpty, isNotEmpty, hasValueOperator } from '../../shared/empty.util';
import { CacheableObject } from '../cache/object-cache.reducer';
import { ObjectCacheService } from '../cache/object-cache.service';
import { CoreState } from '../core.reducers';
@@ -110,15 +110,19 @@ export class RequestService {
* Retrieve a RequestEntry based on their uuid
*/
getByUUID(uuid: string): Observable {
- return observableRace(
- this.store.pipe(select(entryFromUUIDSelector(uuid))),
+ return observableCombineLatest([
+ this.store.pipe(
+ select(entryFromUUIDSelector(uuid))
+ ),
this.store.pipe(
select(originalRequestUUIDFromRequestUUIDSelector(uuid)),
- mergeMap((originalUUID) => {
- return this.store.pipe(select(entryFromUUIDSelector(originalUUID)))
+ switchMap((originalUUID) => {
+ return this.store.pipe(select(entryFromUUIDSelector(originalUUID)))
},
- ))
- ).pipe(
+ ),
+ ),
+ ]).pipe(
+ map((entries: RequestEntry[]) => entries.find((entry: RequestEntry) => hasValue(entry))),
map((entry: RequestEntry) => {
// Headers break after being retrieved from the store (because of lazy initialization)
// Combining them with a new object fixes this issue
@@ -137,7 +141,13 @@ export class RequestService {
getByHref(href: string): Observable {
return this.store.pipe(
select(uuidFromHrefSelector(href)),
- mergeMap((uuid: string) => this.getByUUID(uuid))
+ mergeMap((uuid: string) => {
+ if (isNotEmpty(uuid)) {
+ return this.getByUUID(uuid);
+ } else {
+ return [undefined];
+ }
+ })
);
}
diff --git a/src/app/core/data/workflow-action-data.service.ts b/src/app/core/data/workflow-action-data.service.ts
new file mode 100644
index 0000000000..be2a170ac5
--- /dev/null
+++ b/src/app/core/data/workflow-action-data.service.ts
@@ -0,0 +1,41 @@
+import { DataService } from './data.service';
+import { WorkflowAction } from '../tasks/models/workflow-action-object.model';
+import { RequestService } from './request.service';
+import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import { Store } from '@ngrx/store';
+import { CoreState } from '../core.reducers';
+import { ObjectCacheService } from '../cache/object-cache.service';
+import { HALEndpointService } from '../shared/hal-endpoint.service';
+import { NotificationsService } from '../../shared/notifications/notifications.service';
+import { HttpClient } from '@angular/common/http';
+import { DefaultChangeAnalyzer } from './default-change-analyzer.service';
+import { FindListOptions } from './request.models';
+import { Observable } from 'rxjs/internal/Observable';
+import { Injectable } from '@angular/core';
+import { dataService } from '../cache/builders/build-decorators';
+import { WORKFLOW_ACTION } from '../tasks/models/workflow-action-object.resource-type';
+
+/**
+ * A service responsible for fetching/sending data from/to the REST API on the workflowactions endpoint
+ */
+@Injectable()
+@dataService(WORKFLOW_ACTION)
+export class WorkflowActionDataService extends DataService {
+ protected linkPath = 'workflowactions';
+
+ constructor(
+ protected requestService: RequestService,
+ protected rdbService: RemoteDataBuildService,
+ protected store: Store,
+ protected objectCache: ObjectCacheService,
+ protected halService: HALEndpointService,
+ protected notificationsService: NotificationsService,
+ protected http: HttpClient,
+ protected comparator: DefaultChangeAnalyzer) {
+ super();
+ }
+
+ getBrowseEndpoint(options: FindListOptions, linkPath?: string): Observable {
+ return this.halService.getEndpoint(this.linkPath);
+ }
+}
diff --git a/src/app/core/eperson/eperson-data.service.spec.ts b/src/app/core/eperson/eperson-data.service.spec.ts
index b60816c050..d83a376da9 100644
--- a/src/app/core/eperson/eperson-data.service.spec.ts
+++ b/src/app/core/eperson/eperson-data.service.spec.ts
@@ -10,7 +10,6 @@ import { Observable } from 'rxjs/internal/Observable';
import { TestScheduler } from 'rxjs/testing';
import { EPeopleRegistryCancelEPersonAction, EPeopleRegistryEditEPersonAction } from '../../+admin/admin-access-control/epeople-registry/epeople-registry.actions';
import { SearchParam } from '../cache/models/search-param.model';
-import { ObjectCacheService } from '../cache/object-cache.service';
import { CoreState } from '../core.reducers';
import { ChangeAnalyzer } from '../data/change-analyzer';
import { PaginatedList } from '../data/paginated-list';
@@ -36,43 +35,15 @@ describe('EPersonDataService', () => {
let requestService: RequestService;
let scheduler: TestScheduler;
- const epeople = [EPersonMock, EPersonMock2];
+ let epeople;
- const restEndpointURL = 'https://dspace.4science.it/dspace-spring-rest/api/eperson';
- const epersonsEndpoint = `${restEndpointURL}/epersons`;
- let halService: any = new HALEndpointServiceStub(restEndpointURL);
- const epeople$ = createSuccessfulRemoteDataObject$(new PaginatedList(new PageInfo(), [epeople]));
- const rdbService = getMockRemoteDataBuildServiceHrefMap(undefined, { 'https://dspace.4science.it/dspace-spring-rest/api/eperson/epersons': epeople$ });
- const objectCache = Object.assign({
- /* tslint:disable:no-empty */
- remove: () => {
- },
- hasBySelfLinkObservable: () => observableOf(false)
- /* tslint:enable:no-empty */
- }) as ObjectCacheService;
+ let restEndpointURL;
+ let epersonsEndpoint;
+ let halService: any;
+ let epeople$;
+ let rdbService;
- TestBed.configureTestingModule({
- imports: [
- CommonModule,
- StoreModule.forRoot({}),
- TranslateModule.forRoot({
- loader: {
- provide: TranslateLoader,
- useClass: TranslateLoaderMock
- }
- }),
- ],
- declarations: [],
- providers: [],
- schemas: [CUSTOM_ELEMENTS_SCHEMA]
- });
-
- const getRequestEntry$ = (successful: boolean) => {
- return observableOf({
- completed: true,
- response: { isSuccessful: successful, payload: epeople } as any
- } as RequestEntry)
- };
+ let getRequestEntry$;
function initTestService() {
return new EPersonDataService(
@@ -87,7 +58,39 @@ describe('EPersonDataService', () => {
);
}
+ function init() {
+ getRequestEntry$ = (successful: boolean) => {
+ return observableOf({
+ completed: true,
+ response: { isSuccessful: successful, payload: epeople } as any
+ } as RequestEntry)
+ };
+ restEndpointURL = 'https://dspace.4science.it/dspace-spring-rest/api/eperson';
+ epersonsEndpoint = `${restEndpointURL}/epersons`;
+ epeople = [EPersonMock, EPersonMock2];
+ epeople$ = createSuccessfulRemoteDataObject$(new PaginatedList(new PageInfo(), [epeople]));
+ rdbService = getMockRemoteDataBuildServiceHrefMap(undefined, { 'https://dspace.4science.it/dspace-spring-rest/api/eperson/epersons': epeople$ });
+ halService = new HALEndpointServiceStub(restEndpointURL);
+
+ TestBed.configureTestingModule({
+ imports: [
+ CommonModule,
+ StoreModule.forRoot({}),
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: TranslateLoaderMock
+ }
+ }),
+ ],
+ declarations: [],
+ providers: [],
+ schemas: [CUSTOM_ELEMENTS_SCHEMA]
+ });
+ }
+
beforeEach(() => {
+ init();
requestService = getMockRequestService(getRequestEntry$(true));
store = new Store(undefined, undefined, undefined);
service = initTestService();
diff --git a/src/app/core/eperson/eperson-data.service.ts b/src/app/core/eperson/eperson-data.service.ts
index ec8b96d1cd..a8cee6f1de 100644
--- a/src/app/core/eperson/eperson-data.service.ts
+++ b/src/app/core/eperson/eperson-data.service.ts
@@ -181,7 +181,7 @@ export class EPersonDataService extends DataService {
}
/**
- * Method that clears a cached EPerson request and returns its REST url
+ * Method that clears a cached EPerson request
*/
public clearEPersonRequests(): void {
this.getBrowseEndpoint().pipe(take(1)).subscribe((link: string) => {
@@ -189,6 +189,13 @@ export class EPersonDataService extends DataService {
});
}
+ /**
+ * Method that clears a link's requests in cache
+ */
+ public clearLinkRequests(href: string): void {
+ this.requestService.removeByHrefSubstring(href);
+ }
+
/**
* Method to retrieve the eperson that is currently being edited
*/
@@ -219,4 +226,27 @@ export class EPersonDataService extends DataService {
return this.delete(ePerson.id);
}
+ /**
+ * Change which ePerson is being edited and return the link for EPeople edit page
+ * @param ePerson New EPerson to edit
+ */
+ public startEditingNewEPerson(ePerson: EPerson): string {
+ this.getActiveEPerson().pipe(take(1)).subscribe((activeEPerson: EPerson) => {
+ if (ePerson === activeEPerson) {
+ this.cancelEditEPerson();
+ } else {
+ this.editEPerson(ePerson);
+ }
+ });
+ return '/admin/access-control/epeople';
+ }
+
+ /**
+ * Get EPeople admin page
+ * @param ePerson New EPerson to edit
+ */
+ public getEPeoplePageRouterLink(): string {
+ return '/admin/access-control/epeople';
+ }
+
}
diff --git a/src/app/core/eperson/group-data.service.spec.ts b/src/app/core/eperson/group-data.service.spec.ts
new file mode 100644
index 0000000000..138cf547f2
--- /dev/null
+++ b/src/app/core/eperson/group-data.service.spec.ts
@@ -0,0 +1,198 @@
+import { CommonModule } from '@angular/common';
+import { HttpHeaders } from '@angular/common/http';
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { Store, StoreModule } from '@ngrx/store';
+import { of as observableOf } from 'rxjs';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { compare, Operation } from 'fast-json-patch';
+import {
+ GroupRegistryCancelGroupAction,
+ GroupRegistryEditGroupAction
+} from '../../+admin/admin-access-control/group-registry/group-registry.actions';
+import { getMockRemoteDataBuildServiceHrefMap } from '../../shared/mocks/mock-remote-data-build.service';
+import { getMockRequestService } from '../../shared/mocks/mock-request.service';
+import { MockTranslateLoader } from '../../shared/mocks/mock-translate-loader';
+import { EPersonMock, EPersonMock2 } from '../../shared/testing/eperson-mock';
+import { GroupMock, GroupMock2 } from '../../shared/testing/group-mock';
+import { HALEndpointServiceStub } from '../../shared/testing/hal-endpoint-service-stub';
+import { createSuccessfulRemoteDataObject$ } from '../../shared/testing/utils';
+import { SearchParam } from '../cache/models/search-param.model';
+import { CoreState } from '../core.reducers';
+import { ChangeAnalyzer } from '../data/change-analyzer';
+import { PaginatedList } from '../data/paginated-list';
+import { DeleteByIDRequest, DeleteRequest, FindListOptions, PostRequest } from '../data/request.models';
+import { RequestEntry } from '../data/request.reducer';
+import { RequestService } from '../data/request.service';
+import { HttpOptions } from '../dspace-rest-v2/dspace-rest-v2.service';
+import { Item } from '../shared/item.model';
+import { PageInfo } from '../shared/page-info.model';
+import { GroupDataService } from './group-data.service';
+
+describe('GroupDataService', () => {
+ let service: GroupDataService;
+ let store: Store;
+ let requestService: RequestService;
+
+ let restEndpointURL;
+ let groupsEndpoint;
+ let groups;
+ let groups$;
+ let halService;
+ let rdbService;
+
+ let getRequestEntry$;
+
+ function init() {
+ getRequestEntry$ = (successful: boolean) => {
+ return observableOf({
+ completed: true,
+ response: { isSuccessful: successful, payload: groups } as any
+ } as RequestEntry)
+ };
+ restEndpointURL = 'https://dspace.4science.it/dspace-spring-rest/api/eperson';
+ groupsEndpoint = `${restEndpointURL}/groups`;
+ groups = [GroupMock, GroupMock2];
+ groups$ = createSuccessfulRemoteDataObject$(new PaginatedList(new PageInfo(), groups));
+ rdbService = getMockRemoteDataBuildServiceHrefMap(undefined, { 'https://dspace.4science.it/dspace-spring-rest/api/eperson/groups': groups$ });
+ halService = new HALEndpointServiceStub(restEndpointURL);
+ TestBed.configureTestingModule({
+ imports: [
+ CommonModule,
+ StoreModule.forRoot({}),
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: MockTranslateLoader
+ }
+ }),
+ ],
+ declarations: [],
+ providers: [],
+ schemas: [CUSTOM_ELEMENTS_SCHEMA]
+ });
+ }
+
+ function initTestService() {
+ return new GroupDataService(
+ new DummyChangeAnalyzer() as any,
+ null,
+ null,
+ requestService,
+ rdbService,
+ store,
+ null,
+ halService,
+ null,
+ );
+ };
+
+ beforeEach(() => {
+ init();
+ requestService = getMockRequestService(getRequestEntry$(true));
+ store = new Store(undefined, undefined, undefined);
+ service = initTestService();
+ spyOn(store, 'dispatch');
+ });
+
+ describe('searchGroups', () => {
+ beforeEach(() => {
+ spyOn(service, 'searchBy');
+ });
+
+ it('search with empty query', () => {
+ service.searchGroups('');
+ const options = Object.assign(new FindListOptions(), {
+ searchParams: [Object.assign(new SearchParam('query', ''))]
+ });
+ expect(service.searchBy).toHaveBeenCalledWith('byMetadata', options);
+ });
+
+ it('search with query', () => {
+ service.searchGroups('test');
+ const options = Object.assign(new FindListOptions(), {
+ searchParams: [Object.assign(new SearchParam('query', 'test'))]
+ });
+ expect(service.searchBy).toHaveBeenCalledWith('byMetadata', options);
+ });
+ });
+
+ describe('deleteGroup', () => {
+ beforeEach(() => {
+ service.deleteGroup(GroupMock2).subscribe();
+ });
+
+ it('should send DeleteRequest', () => {
+ const expected = new DeleteByIDRequest(requestService.generateRequestId(), groupsEndpoint + '/' + GroupMock2.uuid, GroupMock2.uuid);
+ expect(requestService.configure).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ describe('addSubGroupToGroup', () => {
+ beforeEach(() => {
+ service.addSubGroupToGroup(GroupMock, GroupMock2).subscribe();
+ });
+ it('should send PostRequest to eperson/groups/group-id/subgroups endpoint with new subgroup link in body', () => {
+ let headers = new HttpHeaders();
+ const options: HttpOptions = Object.create({});
+ headers = headers.append('Content-Type', 'text/uri-list');
+ options.headers = headers;
+ const expected = new PostRequest(requestService.generateRequestId(), GroupMock.self + '/' + service.subgroupsEndpoint, GroupMock2.self, options);
+ expect(requestService.configure).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ describe('deleteSubGroupFromGroup', () => {
+ beforeEach(() => {
+ service.deleteSubGroupFromGroup(GroupMock, GroupMock2).subscribe();
+ });
+ it('should send DeleteRequest to eperson/groups/group-id/subgroups/group-id endpoint', () => {
+ const expected = new DeleteRequest(requestService.generateRequestId(), GroupMock.self + '/' + service.subgroupsEndpoint + '/' + GroupMock2.id);
+ expect(requestService.configure).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ describe('addMemberToGroup', () => {
+ beforeEach(() => {
+ service.addMemberToGroup(GroupMock, EPersonMock2).subscribe();
+ });
+ it('should send PostRequest to eperson/groups/group-id/epersons endpoint with new eperson member in body', () => {
+ let headers = new HttpHeaders();
+ const options: HttpOptions = Object.create({});
+ headers = headers.append('Content-Type', 'text/uri-list');
+ options.headers = headers;
+ const expected = new PostRequest(requestService.generateRequestId(), GroupMock.self + '/' + service.ePersonsEndpoint, EPersonMock2.self, options);
+ expect(requestService.configure).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ describe('deleteMemberFromGroup', () => {
+ beforeEach(() => {
+ service.deleteMemberFromGroup(GroupMock, EPersonMock).subscribe();
+ });
+ it('should send DeleteRequest to eperson/groups/group-id/epersons/eperson-id endpoint', () => {
+ const expected = new DeleteRequest(requestService.generateRequestId(), GroupMock.self + '/' + service.ePersonsEndpoint + '/' + EPersonMock.id);
+ expect(requestService.configure).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ describe('editGroup', () => {
+ it('should dispatch a EDIT_GROUP action with the groupp to start editing', () => {
+ service.editGroup(GroupMock);
+ expect(store.dispatch).toHaveBeenCalledWith(new GroupRegistryEditGroupAction(GroupMock));
+ });
+ });
+
+ describe('cancelEditGroup', () => {
+ it('should dispatch a CANCEL_EDIT_GROUP action', () => {
+ service.cancelEditGroup();
+ expect(store.dispatch).toHaveBeenCalledWith(new GroupRegistryCancelGroupAction());
+ });
+ });
+});
+
+class DummyChangeAnalyzer implements ChangeAnalyzer
- {
+ diff(object1: Item, object2: Item): Operation[] {
+ return compare((object1 as any).metadata, (object2 as any).metadata);
+ }
+}
diff --git a/src/app/core/eperson/group-data.service.ts b/src/app/core/eperson/group-data.service.ts
index 532f42323a..574b4d997a 100644
--- a/src/app/core/eperson/group-data.service.ts
+++ b/src/app/core/eperson/group-data.service.ts
@@ -1,28 +1,52 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { Store } from '@ngrx/store';
+import { createSelector, select, Store } from '@ngrx/store';
import { Observable } from 'rxjs';
-import { filter, map, take } from 'rxjs/operators';
+import { distinctUntilChanged, filter, map, switchMap, take, tap } from 'rxjs/operators';
+import {
+ GroupRegistryCancelGroupAction,
+ GroupRegistryEditGroupAction
+} from '../../+admin/admin-access-control/group-registry/group-registry.actions';
+import { GroupRegistryState } from '../../+admin/admin-access-control/group-registry/group-registry.reducers';
+import { AppState } from '../../app.reducer';
+import { hasValue } from '../../shared/empty.util';
+import { NotificationsService } from '../../shared/notifications/notifications.service';
+import { FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
+import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import { SearchParam } from '../cache/models/search-param.model';
+import { ObjectCacheService } from '../cache/object-cache.service';
+import { RestResponse } from '../cache/response.models';
import { DataService } from '../data/data.service';
+import { DSOChangeAnalyzer } from '../data/dso-change-analyzer.service';
+import { PaginatedList } from '../data/paginated-list';
+import { RemoteData } from '../data/remote-data';
+import {
+ CreateRequest,
+ DeleteRequest,
+ FindListOptions,
+ FindListRequest,
+ PostRequest
+} from '../data/request.models';
import { RequestService } from '../data/request.service';
-import { FindListOptions } from '../data/request.models';
+import { HttpOptions } from '../dspace-rest-v2/dspace-rest-v2.service';
import { HALEndpointService } from '../shared/hal-endpoint.service';
+import { configureRequest, getResponseFromEntry} from '../shared/operators';
+import { EPerson } from './models/eperson.model';
import { Group } from './models/group.model';
-import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
-import { CoreState } from '../core.reducers';
-import { ObjectCacheService } from '../cache/object-cache.service';
-import { SearchParam } from '../cache/models/search-param.model';
-import { RemoteData } from '../data/remote-data';
-import { PaginatedList } from '../data/paginated-list';
-import { NotificationsService } from '../../shared/notifications/notifications.service';
-import { DSOChangeAnalyzer } from '../data/dso-change-analyzer.service';
import { dataService } from '../cache/builders/build-decorators';
import { GROUP } from './models/group.resource-type';
+import { DSONameService } from '../breadcrumbs/dso-name.service';
+import { Community } from '../shared/community.model';
+import { Collection } from '../shared/collection.model';
+import { ComcolRole } from '../../shared/comcol-forms/edit-comcol-page/comcol-role/comcol-role';
+
+const groupRegistryStateSelector = (state: AppState) => state.groupRegistry;
+const editGroupSelector = createSelector(groupRegistryStateSelector, (groupRegistryState: GroupRegistryState) => groupRegistryState.editGroup);
/**
- * Provides methods to retrieve eperson group resources.
+ * Provides methods to retrieve eperson group resources from the REST API & Group related CRUD actions.
*/
@Injectable({
providedIn: 'root'
@@ -31,6 +55,8 @@ import { GROUP } from './models/group.resource-type';
export class GroupDataService extends DataService {
protected linkPath = 'groups';
protected browseEndpoint = '';
+ public ePersonsEndpoint = 'epersons';
+ public subgroupsEndpoint = 'subgroups';
constructor(
protected comparator: DSOChangeAnalyzer,
@@ -38,13 +64,52 @@ export class GroupDataService extends DataService {
protected notificationsService: NotificationsService,
protected requestService: RequestService,
protected rdbService: RemoteDataBuildService,
- protected store: Store,
+ protected store: Store,
protected objectCache: ObjectCacheService,
- protected halService: HALEndpointService
+ protected halService: HALEndpointService,
+ protected nameService: DSONameService,
) {
super();
}
+ /**
+ * Retrieves all groups
+ * @param pagination The pagination info used to retrieve the groups
+ */
+ public getGroups(options: FindListOptions = {}, ...linksToFollow: Array>): Observable>> {
+ const hrefObs = this.getFindAllHref(options, this.linkPath, ...linksToFollow);
+ hrefObs.pipe(
+ filter((href: string) => hasValue(href)),
+ take(1))
+ .subscribe((href: string) => {
+ const request = new FindListRequest(this.requestService.generateRequestId(), href, options);
+ this.requestService.configure(request);
+ });
+
+ return this.rdbService.buildList(hrefObs) as Observable>>;
+ }
+
+ /**
+ * Returns a search result list of groups, with certain query (searches in group name and by exact uuid)
+ * Endpoint used: /eperson/groups/search/byMetadata?query=<:name>
+ * @param query search query param
+ * @param options
+ * @param linksToFollow
+ */
+ public searchGroups(query: string, options?: FindListOptions, ...linksToFollow: Array>): Observable>> {
+ const searchParams = [new SearchParam('query', query)];
+ let findListOptions = new FindListOptions();
+ if (options) {
+ findListOptions = Object.assign(new FindListOptions(), options);
+ }
+ if (findListOptions.searchParams) {
+ findListOptions.searchParams = [...findListOptions.searchParams, ...searchParams];
+ } else {
+ findListOptions.searchParams = searchParams;
+ }
+ return this.searchBy('byMetadata', findListOptions, ...linksToFollow);
+ }
+
/**
* Check if the current user is member of to the indicated group
*
@@ -59,10 +124,252 @@ export class GroupDataService extends DataService {
options.searchParams = [new SearchParam('groupName', groupName)];
return this.searchBy(searchHref, options).pipe(
- filter((groups: RemoteData>) => !groups.isResponsePending),
- take(1),
- map((groups: RemoteData>) => groups.payload.totalElements > 0)
- );
+ filter((groups: RemoteData>) => !groups.isResponsePending),
+ take(1),
+ map((groups: RemoteData>) => groups.payload.totalElements > 0)
+ );
}
+ /**
+ * Method to delete a group
+ * @param id The group id to delete
+ */
+ public deleteGroup(group: Group): Observable {
+ return this.delete(group.id);
+ }
+
+ /**
+ * Create or Update a group
+ * If the group contains an id, it is assumed the eperson already exists and is updated instead
+ * @param group The group to create or update
+ */
+ public createOrUpdateGroup(group: Group): Observable> {
+ const isUpdate = hasValue(group.id);
+ if (isUpdate) {
+ return this.updateGroup(group);
+ } else {
+ return this.create(group, null);
+ }
+ }
+
+ /**
+ * // TODO
+ * @param {DSpaceObject} ePerson The given object
+ */
+ updateGroup(group: Group): Observable> {
+ // TODO
+ return null;
+ }
+
+ /**
+ * Adds given subgroup as a subgroup to the given active group
+ * @param activeGroup Group we want to add subgroup to
+ * @param subgroup Group we want to add as subgroup to activeGroup
+ */
+ addSubGroupToGroup(activeGroup: Group, subgroup: Group): Observable {
+ const requestId = this.requestService.generateRequestId();
+ const options: HttpOptions = Object.create({});
+ let headers = new HttpHeaders();
+ headers = headers.append('Content-Type', 'text/uri-list');
+ options.headers = headers;
+ const postRequest = new PostRequest(requestId, activeGroup.self + '/' + this.subgroupsEndpoint, subgroup.self, options);
+ this.requestService.configure(postRequest);
+
+ return this.fetchResponse(requestId);
+ }
+
+ /**
+ * Deletes a given subgroup from the subgroups of the given active group
+ * @param activeGroup Group we want to delete subgroup from
+ * @param subgroup Subgroup we want to delete from activeGroup
+ */
+ deleteSubGroupFromGroup(activeGroup: Group, subgroup: Group): Observable {
+ const requestId = this.requestService.generateRequestId();
+ const deleteRequest = new DeleteRequest(requestId, activeGroup.self + '/' + this.subgroupsEndpoint + '/' + subgroup.id);
+ this.requestService.configure(deleteRequest);
+
+ return this.fetchResponse(requestId);
+ }
+
+ /**
+ * Adds given ePerson as member to given group
+ * @param activeGroup Group we want to add member to
+ * @param ePerson EPerson we want to add as member to given activeGroup
+ */
+ addMemberToGroup(activeGroup: Group, ePerson: EPerson): Observable {
+ const requestId = this.requestService.generateRequestId();
+ const options: HttpOptions = Object.create({});
+ let headers = new HttpHeaders();
+ headers = headers.append('Content-Type', 'text/uri-list');
+ options.headers = headers;
+ const postRequest = new PostRequest(requestId, activeGroup.self + '/' + this.ePersonsEndpoint, ePerson.self, options);
+ this.requestService.configure(postRequest);
+
+ return this.fetchResponse(requestId);
+ }
+
+ /**
+ * Deletes a given ePerson from the members of the given active group
+ * @param activeGroup Group we want to delete member from
+ * @param ePerson EPerson we want to delete from members of given activeGroup
+ */
+ deleteMemberFromGroup(activeGroup: Group, ePerson: EPerson): Observable {
+ const requestId = this.requestService.generateRequestId();
+ const deleteRequest = new DeleteRequest(requestId, activeGroup.self + '/' + this.ePersonsEndpoint + '/' + ePerson.id);
+ this.requestService.configure(deleteRequest);
+
+ return this.fetchResponse(requestId);
+ }
+
+ /**
+ * Gets the restResponse from the requestService
+ * @param requestId
+ */
+ protected fetchResponse(requestId: string): Observable {
+ return this.requestService.getByUUID(requestId).pipe(
+ getResponseFromEntry(),
+ map((response: RestResponse) => {
+ return response;
+ })
+ );
+ }
+
+ /**
+ * Method to retrieve the group that is currently being edited
+ */
+ public getActiveGroup(): Observable {
+ return this.store.pipe(select(editGroupSelector))
+ }
+
+ /**
+ * Method to cancel editing a group, dispatches a cancel group action
+ */
+ public cancelEditGroup() {
+ this.store.dispatch(new GroupRegistryCancelGroupAction());
+ }
+
+ /**
+ * Method to set the group being edited, dispatches an edit group action
+ * @param group The group to edit
+ */
+ public editGroup(group: Group) {
+ this.store.dispatch(new GroupRegistryEditGroupAction(group));
+ }
+
+ /**
+ * Method that clears a cached groups request
+ */
+ public clearGroupsRequests(): void {
+ this.getBrowseEndpoint().pipe(take(1)).subscribe((link: string) => {
+ this.requestService.removeByHrefSubstring(link);
+ });
+ }
+
+ /**
+ * Method that clears a cached get subgroups of certain group request
+ */
+ public clearGroupLinkRequests(href: string): void {
+ this.requestService.removeByHrefSubstring(href);
+ }
+
+ public getGroupRegistryRouterLink(): string {
+ return '/admin/access-control/groups';
+ }
+
+ /**
+ * Change which group is being edited and return the link for the edit page of the new group being edited
+ * @param newGroup New group to edit
+ */
+ public startEditingNewGroup(newGroup: Group): string {
+ this.getActiveGroup().pipe(take(1)).subscribe((activeGroup: Group) => {
+ if (newGroup === activeGroup) {
+ this.cancelEditGroup()
+ } else {
+ this.editGroup(newGroup)
+ }
+ });
+ return this.getGroupEditPageRouterLinkWithID(newGroup.id)
+ }
+
+ /**
+ * Get Edit page of group
+ * @param group Group we want edit page for
+ */
+ public getGroupEditPageRouterLink(group: Group): string {
+ return this.getGroupEditPageRouterLinkWithID(group.id);
+ }
+
+ /**
+ * Get Edit page of group
+ * @param groupID Group ID we want edit page for
+ */
+ public getGroupEditPageRouterLinkWithID(groupId: string): string {
+ return '/admin/access-control/groups/' + groupId;
+ }
+
+ /**
+ * Extract optional UUID from a string
+ * @param stringWithUUID String with possible UUID
+ */
+ public getUUIDFromString(stringWithUUID: string): string {
+ let foundUUID = '';
+ const uuidMatches = stringWithUUID.match(/[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/g);
+ if (uuidMatches != null) {
+ foundUUID = uuidMatches[0];
+ }
+ return foundUUID;
+ }
+
+ /**
+ * Create a group for a given role for a given community or collection.
+ *
+ * @param dso The community or collection for which to create a group
+ * @param link The REST endpoint to create the group
+ */
+ createComcolGroup(dso: Community|Collection, link: string): Observable {
+
+ const requestId = this.requestService.generateRequestId();
+ const group = Object.assign(new Group(), {
+ metadata: {
+ 'dc.description': [
+ {
+ value: `${this.nameService.getName(dso)} admin group`,
+ }
+ ],
+ },
+ });
+
+ this.requestService.configure(
+ new CreateRequest(
+ requestId,
+ link,
+ JSON.stringify(group),
+ ));
+
+ return this.requestService.getByUUID(requestId).pipe(
+ getResponseFromEntry(),
+ tap(() => this.requestService.removeByHrefSubstring(link)),
+ );
+ }
+
+ /**
+ * Delete the group for a given role for a given community or collection.
+ *
+ * @param link The REST endpoint to delete the group
+ */
+ deleteComcolGroup(link: string): Observable {
+
+ const requestId = this.requestService.generateRequestId();
+
+ this.requestService.configure(
+ new DeleteRequest(
+ requestId,
+ link,
+ ));
+
+ return this.requestService.getByUUID(requestId).pipe(
+ getResponseFromEntry(),
+ tap(() => this.requestService.removeByHrefSubstring(link)),
+ );
+ }
}
diff --git a/src/app/core/eperson/models/group.model.ts b/src/app/core/eperson/models/group.model.ts
index 5d531800b8..e496babddc 100644
--- a/src/app/core/eperson/models/group.model.ts
+++ b/src/app/core/eperson/models/group.model.ts
@@ -6,6 +6,8 @@ import { RemoteData } from '../../data/remote-data';
import { DSpaceObject } from '../../shared/dspace-object.model';
import { HALLink } from '../../shared/hal-link.model';
+import { EPerson } from './eperson.model';
+import { EPERSON } from './eperson.resource-type';
import { GROUP } from './group.resource-type';
@typedObject
@@ -13,6 +15,12 @@ import { GROUP } from './group.resource-type';
export class Group extends DSpaceObject {
static type = GROUP;
+ /**
+ * A string representing the unique name of this Group
+ */
+ @autoserialize
+ public name: string;
+
/**
* A string representing the unique handle of this Group
*/
@@ -31,7 +39,8 @@ export class Group extends DSpaceObject {
@deserialize
_links: {
self: HALLink;
- groups: HALLink;
+ subgroups: HALLink;
+ epersons: HALLink;
};
/**
@@ -39,6 +48,13 @@ export class Group extends DSpaceObject {
* Will be undefined unless the groups {@link HALLink} has been resolved.
*/
@link(GROUP, true)
- public groups?: Observable>>;
+ public subgroups?: Observable>>;
+
+ /**
+ * The list of EPeople in this group
+ * Will be undefined unless the epersons {@link HALLink} has been resolved.
+ */
+ @link(EPERSON, true)
+ public epersons?: Observable>>;
}
diff --git a/src/app/core/shared/bitstream.model.ts b/src/app/core/shared/bitstream.model.ts
index 231d44eeff..ab9d1548b7 100644
--- a/src/app/core/shared/bitstream.model.ts
+++ b/src/app/core/shared/bitstream.model.ts
@@ -54,7 +54,7 @@ export class Bitstream extends DSpaceObject implements HALResource {
* The BitstreamFormat of this Bitstream
* Will be undefined unless the format {@link HALLink} has been resolved.
*/
- @link(BITSTREAM_FORMAT)
+ @link(BITSTREAM_FORMAT, false, 'format')
format?: Observable>;
}
diff --git a/src/app/core/shared/collection.model.ts b/src/app/core/shared/collection.model.ts
index ba2f448bba..4e0b5ead83 100644
--- a/src/app/core/shared/collection.model.ts
+++ b/src/app/core/shared/collection.model.ts
@@ -15,6 +15,8 @@ import { RESOURCE_POLICY } from './resource-policy.resource-type';
import { COMMUNITY } from './community.resource-type';
import { Community } from './community.model';
import { ChildHALResource } from './child-hal-resource.model';
+import { GROUP } from '../eperson/models/group.resource-type';
+import { Group } from '../eperson/models/group.model';
@typedObject
@inheritSerialization(DSpaceObject)
@@ -70,6 +72,12 @@ export class Collection extends DSpaceObject implements ChildHALResource {
@link(COMMUNITY, false)
parentCommunity?: Observable>;
+ /**
+ * The administrators group of this community.
+ */
+ @link(GROUP)
+ adminGroup?: Observable>;
+
/**
* The introductory text of this Collection
* Corresponds to the metadata field dc.description
diff --git a/src/app/core/shared/community.model.ts b/src/app/core/shared/community.model.ts
index e18ec743e8..bdcda70e9b 100644
--- a/src/app/core/shared/community.model.ts
+++ b/src/app/core/shared/community.model.ts
@@ -3,6 +3,8 @@ import { Observable } from 'rxjs';
import { link, typedObject } from '../cache/builders/build-decorators';
import { PaginatedList } from '../data/paginated-list';
import { RemoteData } from '../data/remote-data';
+import { Group } from '../eperson/models/group.model';
+import { GROUP } from '../eperson/models/group.resource-type';
import { Bitstream } from './bitstream.model';
import { BITSTREAM } from './bitstream.resource-type';
import { Collection } from './collection.model';
@@ -32,6 +34,7 @@ export class Community extends DSpaceObject implements ChildHALResource {
logo: HALLink;
subcommunities: HALLink;
parentCommunity: HALLink;
+ adminGroup: HALLink;
self: HALLink;
};
@@ -63,6 +66,12 @@ export class Community extends DSpaceObject implements ChildHALResource {
@link(COMMUNITY, false)
parentCommunity?: Observable>;
+ /**
+ * The administrators group of this community.
+ */
+ @link(GROUP)
+ adminGroup?: Observable>;
+
/**
* The introductory text of this Community
* Corresponds to the metadata field dc.description
diff --git a/src/app/core/shared/dspace-object.model.ts b/src/app/core/shared/dspace-object.model.ts
index 60a1160d3e..a9256fbb7f 100644
--- a/src/app/core/shared/dspace-object.model.ts
+++ b/src/app/core/shared/dspace-object.model.ts
@@ -1,5 +1,5 @@
import { autoserialize, autoserializeAs, deserialize, deserializeAs } from 'cerialize';
-import { hasNoValue, isUndefined } from '../../shared/empty.util';
+import { hasNoValue, hasValue, isUndefined } from '../../shared/empty.util';
import { ListableObject } from '../../shared/object-collection/shared/listable-object.model';
import { typedObject } from '../cache/builders/build-decorators';
import { CacheableObject } from '../cache/object-cache.reducer';
@@ -79,6 +79,9 @@ export class DSpaceObject extends ListableObject implements CacheableObject {
* The name for this DSpaceObject
*/
set name(name) {
+ if (hasValue(this.firstMetadata('dc.title'))) {
+ this.firstMetadata('dc.title').value = name;
+ }
this._name = name;
}
diff --git a/src/app/core/shared/metadata.utils.spec.ts b/src/app/core/shared/metadata.utils.spec.ts
index f4b3517649..016ef594b1 100644
--- a/src/app/core/shared/metadata.utils.spec.ts
+++ b/src/app/core/shared/metadata.utils.spec.ts
@@ -7,6 +7,7 @@ import {
MetadatumViewModel
} from './metadata.models';
import { Metadata } from './metadata.utils';
+import { beforeEach } from 'selenium-webdriver/testing';
const mdValue = (value: string, language?: string, authority?: string): MetadataValue => {
return Object.assign(new MetadataValue(), { uuid: uuidv4(), value: value, language: isUndefined(language) ? null : language, place: 0, authority: isUndefined(authority) ? null : authority, confidence: undefined });
@@ -216,4 +217,26 @@ describe('Metadata', () => {
testToMetadataMap(multiViewModelList, multiMap);
});
+ describe('setFirstValue method', () => {
+
+ const metadataMap = {
+ 'dc.description': [mdValue('Test description')],
+ 'dc.title': [mdValue('Test title 1'), mdValue('Test title 2')]
+ };
+
+ const testSetFirstValue = (map: MetadataMap, key: string, value: string) => {
+ describe(`with field ${key} and value ${value}`, () => {
+ Metadata.setFirstValue(map, key, value);
+ it(`should set first value of ${key} to ${value}`, () => {
+ expect(map[key][0].value).toEqual(value);
+ });
+ });
+ };
+
+ testSetFirstValue(metadataMap, 'dc.description', 'New Description');
+ testSetFirstValue(metadataMap, 'dc.title', 'New Title');
+ testSetFirstValue(metadataMap, 'dc.format', 'Completely new field and value');
+
+ });
+
});
diff --git a/src/app/core/shared/metadata.utils.ts b/src/app/core/shared/metadata.utils.ts
index 334c430968..24ff06f4c9 100644
--- a/src/app/core/shared/metadata.utils.ts
+++ b/src/app/core/shared/metadata.utils.ts
@@ -1,4 +1,4 @@
-import { isEmpty, isNotUndefined, isUndefined } from '../../shared/empty.util';
+import { isEmpty, isNotEmpty, isNotUndefined, isUndefined } from '../../shared/empty.util';
import {
MetadataMapInterface,
MetadataValue,
@@ -217,4 +217,19 @@ export class Metadata {
});
return metadataMap;
}
+
+ /**
+ * Set the first value of a metadata by field key
+ * Creates a new MetadataValue if the field doesn't exist yet
+ * @param mdMap The map to add/change values in
+ * @param key The metadata field
+ * @param value The value to add
+ */
+ public static setFirstValue(mdMap: MetadataMapInterface, key: string, value: string) {
+ if (isNotEmpty(mdMap[key])) {
+ mdMap[key][0].value = value;
+ } else {
+ mdMap[key] = [Object.assign(new MetadataValue(), { value: value })]
+ }
+ }
}
diff --git a/src/app/core/shared/operators.ts b/src/app/core/shared/operators.ts
index 14d101a448..a51e711d26 100644
--- a/src/app/core/shared/operators.ts
+++ b/src/app/core/shared/operators.ts
@@ -1,6 +1,6 @@
import { Router } from '@angular/router';
import { Observable } from 'rxjs';
-import { filter, find, flatMap, map, tap } from 'rxjs/operators';
+import { filter, find, flatMap, map, take, tap } from 'rxjs/operators';
import { hasValue, hasValueOperator, isNotEmpty } from '../../shared/empty.util';
import { SearchResult } from '../../shared/search/search-result.model';
import { DSOSuccessResponse, RestResponse } from '../cache/response.models';
@@ -207,3 +207,13 @@ export const getFirstOccurrence = () =>
source.pipe(
map((rd) => Object.assign(rd, { payload: rd.payload.page.length > 0 ? rd.payload.page[0] : undefined }))
);
+
+/**
+ * Operator for turning the current page of bitstreams into an array
+ */
+export const paginatedListToArray = () =>
+ (source: Observable>>): Observable =>
+ source.pipe(
+ hasValueOperator(),
+ map((objectRD: RemoteData>) => objectRD.payload.page.filter((object: T) => hasValue(object)))
+ );
diff --git a/src/app/core/tasks/claimed-task-data.service.spec.ts b/src/app/core/tasks/claimed-task-data.service.spec.ts
index ac5f211682..c787d01282 100644
--- a/src/app/core/tasks/claimed-task-data.service.spec.ts
+++ b/src/app/core/tasks/claimed-task-data.service.spec.ts
@@ -52,8 +52,7 @@ describe('ClaimedTaskDataService', () => {
options.headers = headers;
});
- describe('approveTask', () => {
-
+ describe('submitTask', () => {
it('should call postToEndpoint method', () => {
const scopeId = '1234';
const body = {
@@ -63,33 +62,13 @@ describe('ClaimedTaskDataService', () => {
spyOn(service, 'postToEndpoint');
requestService.uriEncodeBody.and.returnValue(body);
- service.approveTask(scopeId);
-
- expect(service.postToEndpoint).toHaveBeenCalledWith(linkPath, body, scopeId, options);
- });
- });
-
- describe('rejectTask', () => {
-
- it('should call postToEndpoint method', () => {
- const scopeId = '1234';
- const reason = 'test reject';
- const body = {
- submit_reject: 'true',
- reason
- };
-
- spyOn(service, 'postToEndpoint');
- requestService.uriEncodeBody.and.returnValue(body);
-
- service.rejectTask(reason, scopeId);
+ service.submitTask(scopeId, body);
expect(service.postToEndpoint).toHaveBeenCalledWith(linkPath, body, scopeId, options);
});
});
describe('returnToPoolTask', () => {
-
it('should call deleteById method', () => {
const scopeId = '1234';
diff --git a/src/app/core/tasks/claimed-task-data.service.ts b/src/app/core/tasks/claimed-task-data.service.ts
index 0a9de20530..5815dad6e5 100644
--- a/src/app/core/tasks/claimed-task-data.service.ts
+++ b/src/app/core/tasks/claimed-task-data.service.ts
@@ -35,7 +35,6 @@ export class ClaimedTaskDataService extends TasksService {
*
* @param {RequestService} requestService
* @param {RemoteDataBuildService} rdbService
- * @param {NormalizedObjectBuildService} linkService
* @param {Store} store
* @param {ObjectCacheService} objectCache
* @param {HALEndpointService} halService
@@ -56,35 +55,16 @@ export class ClaimedTaskDataService extends TasksService {
}
/**
- * Make a request to approve the given task
+ * Make a request for the given task
*
* @param scopeId
* The task id
+ * @param body
+ * The request body
* @return {Observable}
* Emit the server response
*/
- public approveTask(scopeId: string): Observable {
- const body = {
- submit_approve: 'true'
- };
- return this.postToEndpoint(this.linkPath, this.requestService.uriEncodeBody(body), scopeId, this.makeHttpOptions());
- }
-
- /**
- * Make a request to reject the given task
- *
- * @param reason
- * The reason of reject
- * @param scopeId
- * The task id
- * @return {Observable}
- * Emit the server response
- */
- public rejectTask(reason: string, scopeId: string): Observable {
- const body = {
- submit_reject: 'true',
- reason
- };
+ public submitTask(scopeId: string, body: any): Observable {
return this.postToEndpoint(this.linkPath, this.requestService.uriEncodeBody(body), scopeId, this.makeHttpOptions());
}
diff --git a/src/app/core/tasks/models/task-object.model.ts b/src/app/core/tasks/models/task-object.model.ts
index 4ad6188d46..d90c7a19c0 100644
--- a/src/app/core/tasks/models/task-object.model.ts
+++ b/src/app/core/tasks/models/task-object.model.ts
@@ -13,6 +13,8 @@ import { HALLink } from '../../shared/hal-link.model';
import { WorkflowItem } from '../../submission/models/workflowitem.model';
import { TASK_OBJECT } from './task-object.resource-type';
import { WORKFLOWITEM } from '../../eperson/models/workflowitem.resource-type';
+import { WORKFLOW_ACTION } from './workflow-action-object.resource-type';
+import { WorkflowAction } from './workflow-action-object.model';
/**
* An abstract model class for a TaskObject.
@@ -34,12 +36,6 @@ export class TaskObject extends DSpaceObject implements CacheableObject {
@autoserialize
step: string;
- /**
- * The task action type
- */
- @autoserialize
- action: string;
-
/**
* The {@link HALLink}s for this TaskObject
*/
@@ -49,6 +45,7 @@ export class TaskObject extends DSpaceObject implements CacheableObject {
owner: HALLink;
group: HALLink;
workflowitem: HALLink;
+ action: HALLink;
};
/**
@@ -73,4 +70,11 @@ export class TaskObject extends DSpaceObject implements CacheableObject {
/* This was changed from 'WorkflowItem | Observable>' to 'any' to prevent issues in templates with async */
workflowitem?: any;
+ /**
+ * The task action type
+ * Will be undefined unless the group {@link HALLink} has been resolved.
+ */
+ @link(WORKFLOW_ACTION, false, 'action')
+ action: Observable>;
+
}
diff --git a/src/app/core/tasks/models/workflow-action-object.model.ts b/src/app/core/tasks/models/workflow-action-object.model.ts
new file mode 100644
index 0000000000..720d817859
--- /dev/null
+++ b/src/app/core/tasks/models/workflow-action-object.model.ts
@@ -0,0 +1,25 @@
+import { inheritSerialization, autoserialize } from 'cerialize';
+import { typedObject } from '../../cache/builders/build-decorators';
+import { DSpaceObject } from '../../shared/dspace-object.model';
+import { WORKFLOW_ACTION } from './workflow-action-object.resource-type';
+
+/**
+ * A model class for a WorkflowAction
+ */
+@typedObject
+@inheritSerialization(DSpaceObject)
+export class WorkflowAction extends DSpaceObject {
+ static type = WORKFLOW_ACTION;
+
+ /**
+ * The workflow action's identifier
+ */
+ @autoserialize
+ id: string;
+
+ /**
+ * The options available for this workflow action
+ */
+ @autoserialize
+ options: string[];
+}
diff --git a/src/app/core/tasks/models/workflow-action-object.resource-type.ts b/src/app/core/tasks/models/workflow-action-object.resource-type.ts
new file mode 100644
index 0000000000..d48ffd18f4
--- /dev/null
+++ b/src/app/core/tasks/models/workflow-action-object.resource-type.ts
@@ -0,0 +1,9 @@
+import { ResourceType } from '../../shared/resource-type';
+
+/**
+ * The resource type for WorkflowAction
+ *
+ * Needs to be in a separate file to prevent circular
+ * dependencies in webpack.
+ */
+export const WORKFLOW_ACTION = new ResourceType('workflowaction');
diff --git a/src/app/shared/comcol-forms/edit-comcol-page/comcol-role/comcol-role.component.html b/src/app/shared/comcol-forms/edit-comcol-page/comcol-role/comcol-role.component.html
new file mode 100644
index 0000000000..1e89e3facf
--- /dev/null
+++ b/src/app/shared/comcol-forms/edit-comcol-page/comcol-role/comcol-role.component.html
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+ {{'comcol-role.edit.' + comcolRole.name + '.name' | translate}}
+
+
+
+
+
+ {{'comcol-role.edit.no-group' | translate}}
+
+
+ {{'comcol-role.edit.' + comcolRole.name + '.anonymous-group' | translate}}
+
+
+ {{group.name}}
+
+
+
+
+
+ {{'comcol-role.edit.create' | translate}}
+
+
+ {{'comcol-role.edit.restrict' | translate}}
+
+
+ {{'comcol-role.edit.delete' | translate}}
+
+
+
+
+
+
+ {{'comcol-role.edit.' + comcolRole.name + '.description' | translate}}
+
+
+
+
+
+
+
+
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.scss b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.spec.ts
new file mode 100644
index 0000000000..6c2502a92b
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.spec.ts
@@ -0,0 +1,99 @@
+import { DynamicFormsCoreModule, DynamicFormService } from '@ng-dynamic-forms/core';
+import { FormGroup, ReactiveFormsModule } from '@angular/forms';
+import { async, ComponentFixture, inject, TestBed } from '@angular/core/testing';
+import { DebugElement } from '@angular/core';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { TextMaskModule } from 'angular2-text-mask';
+import { By } from '@angular/platform-browser';
+import { DynamicCustomSwitchModel } from './custom-switch.model';
+import { CustomSwitchComponent } from './custom-switch.component';
+
+describe('CustomSwitchComponent', () => {
+
+ const testModel = new DynamicCustomSwitchModel({id: 'switch'});
+ const formModel = [testModel];
+ let formGroup: FormGroup;
+ let fixture: ComponentFixture;
+ let component: CustomSwitchComponent;
+ let debugElement: DebugElement;
+ let testElement: DebugElement;
+
+ beforeEach(async(() => {
+ TestBed.configureTestingModule({
+ imports: [
+ ReactiveFormsModule,
+ NoopAnimationsModule,
+ TextMaskModule,
+ DynamicFormsCoreModule.forRoot()
+ ],
+ declarations: [CustomSwitchComponent]
+
+ }).compileComponents().then(() => {
+ fixture = TestBed.createComponent(CustomSwitchComponent);
+
+ component = fixture.componentInstance;
+ debugElement = fixture.debugElement;
+ });
+ }));
+
+ beforeEach(inject([DynamicFormService], (service: DynamicFormService) => {
+ formGroup = service.createFormGroup(formModel);
+
+ component.group = formGroup;
+ component.model = testModel;
+
+ fixture.detectChanges();
+
+ testElement = debugElement.query(By.css(`input[id='${testModel.id}']`));
+ }));
+
+ it('should initialize correctly', () => {
+ expect(component.bindId).toBe(true);
+ expect(component.group instanceof FormGroup).toBe(true);
+ expect(component.model instanceof DynamicCustomSwitchModel).toBe(true);
+
+ expect(component.blur).toBeDefined();
+ expect(component.change).toBeDefined();
+ expect(component.focus).toBeDefined();
+
+ expect(component.onBlur).toBeDefined();
+ expect(component.onChange).toBeDefined();
+ expect(component.onFocus).toBeDefined();
+
+ expect(component.hasFocus).toBe(false);
+ expect(component.isValid).toBe(true);
+ expect(component.isInvalid).toBe(false);
+ });
+
+ it('should have an input element', () => {
+ expect(testElement instanceof DebugElement).toBe(true);
+ });
+
+ it('should have an input element of type checkbox', () => {
+ expect(testElement.nativeElement.getAttribute('type')).toEqual('checkbox');
+ });
+
+ it('should emit blur event', () => {
+ spyOn(component.blur, 'emit');
+
+ component.onBlur(null);
+
+ expect(component.blur.emit).toHaveBeenCalled();
+ });
+
+ it('should emit change event', () => {
+ spyOn(component.change, 'emit');
+
+ component.onChange(null);
+
+ expect(component.change.emit).toHaveBeenCalled();
+ });
+
+ it('should emit focus event', () => {
+ spyOn(component.focus, 'emit');
+
+ component.onFocus(null);
+
+ expect(component.focus.emit).toHaveBeenCalled();
+ });
+});
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.ts
new file mode 100644
index 0000000000..ab02fc159d
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.component.ts
@@ -0,0 +1,55 @@
+import { DynamicNGBootstrapCheckboxComponent } from '@ng-dynamic-forms/ui-ng-bootstrap';
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { DynamicCustomSwitchModel } from './custom-switch.model';
+
+@Component({
+ selector: 'ds-custom-switch',
+ styleUrls: ['./custom-switch.component.scss'],
+ templateUrl: './custom-switch.component.html',
+})
+/**
+ * Component displaying a custom switch usable in dynamic forms
+ * Extends from bootstrap's checkbox component but displays a switch instead
+ */
+export class CustomSwitchComponent extends DynamicNGBootstrapCheckboxComponent {
+ /**
+ * Use the model's ID for the input element
+ */
+ @Input() bindId = true;
+
+ /**
+ * The formgroup containing this component
+ */
+ @Input() group: FormGroup;
+
+ /**
+ * The model used for displaying the switch
+ */
+ @Input() model: DynamicCustomSwitchModel;
+
+ /**
+ * Emit an event when the input is selected
+ */
+ @Output() selected = new EventEmitter();
+
+ /**
+ * Emit an event when the input value is removed
+ */
+ @Output() remove = new EventEmitter();
+
+ /**
+ * Emit an event when the input is blurred out
+ */
+ @Output() blur = new EventEmitter();
+
+ /**
+ * Emit an event when the input value changes
+ */
+ @Output() change = new EventEmitter();
+
+ /**
+ * Emit an event when the input is focused
+ */
+ @Output() focus = new EventEmitter();
+}
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.model.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.model.ts
new file mode 100644
index 0000000000..97cf71c4a0
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/custom-switch/custom-switch.model.ts
@@ -0,0 +1,20 @@
+import {
+ DynamicCheckboxModel,
+ DynamicCheckboxModelConfig,
+ DynamicFormControlLayout,
+ serializable
+} from '@ng-dynamic-forms/core';
+
+export const DYNAMIC_FORM_CONTROL_TYPE_CUSTOM_SWITCH = 'CUSTOM_SWITCH';
+
+/**
+ * Model class for displaying a custom switch input in a form
+ * Functions like a checkbox, but displays a switch instead
+ */
+export class DynamicCustomSwitchModel extends DynamicCheckboxModel {
+ @serializable() readonly type: string = DYNAMIC_FORM_CONTROL_TYPE_CUSTOM_SWITCH;
+
+ constructor(config: DynamicCheckboxModelConfig, layout?: DynamicFormControlLayout) {
+ super(config, layout);
+ }
+}
diff --git a/src/app/shared/form/form.component.html b/src/app/shared/form/form.component.html
index 510bf7291b..24948680c7 100644
--- a/src/app/shared/form/form.component.html
+++ b/src/app/shared/form/form.component.html
@@ -50,9 +50,9 @@
diff --git a/src/app/shared/form/form.component.ts b/src/app/shared/form/form.component.ts
index 077def0060..def61cb5b2 100644
--- a/src/app/shared/form/form.component.ts
+++ b/src/app/shared/form/form.component.ts
@@ -53,6 +53,16 @@ export class FormComponent implements OnDestroy, OnInit {
*/
@Input() formId: string;
+ /**
+ * i18n key for the submit button
+ */
+ @Input() submitLabel = 'form.submit';
+
+ /**
+ * i18n key for the cancel button
+ */
+ @Input() cancelLabel = 'form.cancel';
+
/**
* An array of DynamicFormControlModel type
*/
diff --git a/src/app/shared/mocks/request.service.mock.ts b/src/app/shared/mocks/request.service.mock.ts
index 23101b6feb..da297f56ac 100644
--- a/src/app/shared/mocks/request.service.mock.ts
+++ b/src/app/shared/mocks/request.service.mock.ts
@@ -11,9 +11,7 @@ export function getMockRequestService(requestEntry$: Observable =
getByUUID: requestEntry$,
uriEncodeBody: jasmine.createSpy('uriEncodeBody'),
isCachedOrPending: false,
- hasByHrefObservable: observableOf(false),
- /* tslint:disable:no-empty */
- removeByHrefSubstring: () => {}
- /* tslint:enable:no-empty */
+ removeByHrefSubstring: jasmine.createSpy('removeByHrefSubstring'),
+ hasByHrefObservable: observableOf(false)
});
}
diff --git a/src/app/shared/mydspace-actions/claimed-task/abstract/claimed-task-actions-abstract.component.ts b/src/app/shared/mydspace-actions/claimed-task/abstract/claimed-task-actions-abstract.component.ts
new file mode 100644
index 0000000000..dafc148147
--- /dev/null
+++ b/src/app/shared/mydspace-actions/claimed-task/abstract/claimed-task-actions-abstract.component.ts
@@ -0,0 +1,61 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { ClaimedTask } from '../../../../core/tasks/models/claimed-task-object.model';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { ClaimedTaskDataService } from '../../../../core/tasks/claimed-task-data.service';
+import { ProcessTaskResponse } from '../../../../core/tasks/models/process-task-response';
+
+/**
+ * Abstract component for rendering a claimed task's action
+ * To create a child-component for a new option:
+ * - Set the "option" of the component
+ * - Add a @rendersWorkflowTaskOption annotation to your component providing the same enum value
+ * - Optionally overwrite createBody if the request body requires more than just the option
+ */
+export abstract class ClaimedTaskActionsAbstractComponent {
+ /**
+ * The workflow task option the child component represents
+ */
+ abstract option: string;
+
+ /**
+ * The Claimed Task to display an action for
+ */
+ @Input() object: ClaimedTask;
+
+ /**
+ * Emits the success or failure of a processed action
+ */
+ @Output() processCompleted: EventEmitter = new EventEmitter();
+
+ /**
+ * A boolean representing if the operation is pending
+ */
+ processing$ = new BehaviorSubject(false);
+
+ constructor(protected claimedTaskService: ClaimedTaskDataService) {
+ }
+
+ /**
+ * Create a request body for submitting the task
+ * Overwrite this method in the child component if the body requires more than just the option
+ */
+ createbody(): any {
+ return {
+ [this.option]: 'true'
+ };
+ }
+
+ /**
+ * Submit the task for this option
+ * While the task is submitting, processing$ is set to true and processCompleted emits the response's status when
+ * completed
+ */
+ submitTask() {
+ this.processing$.next(true);
+ this.claimedTaskService.submitTask(this.object.id, this.createbody())
+ .subscribe((res: ProcessTaskResponse) => {
+ this.processing$.next(false);
+ this.processCompleted.emit(res.hasSucceeded);
+ });
+ }
+}
diff --git a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.html b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.html
index 3c41fdbb07..7944d24d96 100644
--- a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.html
+++ b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.html
@@ -1,8 +1,8 @@
diff --git a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.spec.ts b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.spec.ts
index d30c1b7e34..0b276625ba 100644
--- a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.spec.ts
+++ b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.spec.ts
@@ -2,14 +2,23 @@ import { ChangeDetectionStrategy, NO_ERRORS_SCHEMA } from '@angular/core';
import { async, ComponentFixture, TestBed } from '@angular/core/testing';
import { By } from '@angular/platform-browser';
import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { of as observableOf } from 'rxjs';
import { ClaimedTaskActionsApproveComponent } from './claimed-task-actions-approve.component';
import { TranslateLoaderMock } from '../../../mocks/translate-loader.mock';
+import { ClaimedTaskDataService } from '../../../../core/tasks/claimed-task-data.service';
+import { ClaimedTask } from '../../../../core/tasks/models/claimed-task-object.model';
+import { ProcessTaskResponse } from '../../../../core/tasks/models/process-task-response';
let component: ClaimedTaskActionsApproveComponent;
let fixture: ComponentFixture;
describe('ClaimedTaskActionsApproveComponent', () => {
+ const object = Object.assign(new ClaimedTask(), { id: 'claimed-task-1' });
+ const claimedTaskService = jasmine.createSpyObj('claimedTaskService', {
+ submitTask: observableOf(new ProcessTaskResponse(true))
+ });
+
beforeEach(async(() => {
TestBed.configureTestingModule({
imports: [
@@ -20,6 +29,9 @@ describe('ClaimedTaskActionsApproveComponent', () => {
}
})
],
+ providers: [
+ { provide: ClaimedTaskDataService, useValue: claimedTaskService }
+ ],
declarations: [ClaimedTaskActionsApproveComponent],
schemas: [NO_ERRORS_SCHEMA]
}).overrideComponent(ClaimedTaskActionsApproveComponent, {
@@ -30,14 +42,10 @@ describe('ClaimedTaskActionsApproveComponent', () => {
beforeEach(() => {
fixture = TestBed.createComponent(ClaimedTaskActionsApproveComponent);
component = fixture.componentInstance;
+ component.object = object;
fixture.detectChanges();
});
- afterEach(() => {
- fixture = null;
- component = null;
- });
-
it('should display approve button', () => {
const btn = fixture.debugElement.query(By.css('.btn-success'));
@@ -45,7 +53,7 @@ describe('ClaimedTaskActionsApproveComponent', () => {
});
it('should display spin icon when approve is pending', () => {
- component.processingApprove = true;
+ component.processing$.next(true);
fixture.detectChanges();
const span = fixture.debugElement.query(By.css('.btn-success .fa-spin'));
@@ -53,13 +61,27 @@ describe('ClaimedTaskActionsApproveComponent', () => {
expect(span).toBeDefined();
});
- it('should emit approve event', () => {
- spyOn(component.approve, 'emit');
+ describe('submitTask', () => {
+ let expectedBody;
- component.confirmApprove();
- fixture.detectChanges();
+ beforeEach(() => {
+ spyOn(component.processCompleted, 'emit');
- expect(component.approve.emit).toHaveBeenCalled();
+ expectedBody = {
+ [component.option]: 'true'
+ };
+
+ component.submitTask();
+ fixture.detectChanges();
+ });
+
+ it('should call claimedTaskService\'s submitTask with the expected body', () => {
+ expect(claimedTaskService.submitTask).toHaveBeenCalledWith(object.id, expectedBody)
+ });
+
+ it('should emit a successful processCompleted event', () => {
+ expect(component.processCompleted.emit).toHaveBeenCalledWith(true);
+ });
});
});
diff --git a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.ts b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.ts
index 8e7c0dab60..8f51ac393c 100644
--- a/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.ts
+++ b/src/app/shared/mydspace-actions/claimed-task/approve/claimed-task-actions-approve.component.ts
@@ -1,32 +1,26 @@
-import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { Component } from '@angular/core';
+import { ClaimedTaskActionsAbstractComponent } from '../abstract/claimed-task-actions-abstract.component';
+import { rendersWorkflowTaskOption } from '../switcher/claimed-task-actions-decorator';
+import { ClaimedTaskDataService } from '../../../../core/tasks/claimed-task-data.service';
+export const WORKFLOW_TASK_OPTION_APPROVE = 'submit_approve';
+
+@rendersWorkflowTaskOption(WORKFLOW_TASK_OPTION_APPROVE)
@Component({
selector: 'ds-claimed-task-actions-approve',
styleUrls: ['./claimed-task-actions-approve.component.scss'],
templateUrl: './claimed-task-actions-approve.component.html',
})
-
-export class ClaimedTaskActionsApproveComponent {
-
+/**
+ * Component for displaying and processing the approve action on a workflow task item
+ */
+export class ClaimedTaskActionsApproveComponent extends ClaimedTaskActionsAbstractComponent {
/**
- * A boolean representing if a reject operation is pending
+ * This component represents the approve option
*/
- @Input() processingApprove: boolean;
+ option = WORKFLOW_TASK_OPTION_APPROVE;
- /**
- * CSS classes to append to reject button
- */
- @Input() wrapperClass: string;
-
- /**
- * An event fired when a approve action is confirmed.
- */
- @Output() approve: EventEmitter = new EventEmitter();
-
- /**
- * Emit approve event
- */
- confirmApprove() {
- this.approve.emit();
+ constructor(protected claimedTaskService: ClaimedTaskDataService) {
+ super(claimedTaskService);
}
}
diff --git a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.html b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.html
index df8fb0eae7..aa569bbfc8 100644
--- a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.html
+++ b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.html
@@ -1,20 +1,13 @@
-
-
- {{'submission.workflow.tasks.claimed.edit' | translate}}
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
diff --git a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.spec.ts b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.spec.ts
index 36c807bce0..3c134831d9 100644
--- a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.spec.ts
+++ b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.spec.ts
@@ -1,7 +1,6 @@
import { ChangeDetectionStrategy, Injector, NO_ERRORS_SCHEMA } from '@angular/core';
-import { async, ComponentFixture, fakeAsync, TestBed } from '@angular/core/testing';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
import { Router } from '@angular/router';
-import { By } from '@angular/platform-browser';
import { of as observableOf } from 'rxjs';
import { cold } from 'jasmine-marbles';
@@ -16,11 +15,14 @@ import { ClaimedTaskDataService } from '../../../core/tasks/claimed-task-data.se
import { ClaimedTaskActionsComponent } from './claimed-task-actions.component';
import { ClaimedTask } from '../../../core/tasks/models/claimed-task-object.model';
import { WorkflowItem } from '../../../core/submission/models/workflowitem.model';
-import { createSuccessfulRemoteDataObject } from '../../remote-data.utils';
+import { createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../testing/utils';
import { getMockSearchService } from '../../mocks/search-service.mock';
import { getMockRequestService } from '../../mocks/request.service.mock';
import { RequestService } from '../../../core/data/request.service';
import { SearchService } from '../../../core/shared/search/search.service';
+import { WorkflowActionDataService } from '../../../core/data/workflow-action-data.service';
+import { WorkflowAction } from '../../../core/tasks/models/workflow-action-object.model';
+import { VarDirective } from '../../utils/var.directive';
let component: ClaimedTaskActionsComponent;
let fixture: ComponentFixture;
@@ -30,15 +32,15 @@ let notificationsServiceStub: NotificationsServiceStub;
let router: RouterStub;
let mockDataService;
-
let searchService;
-
let requestServce;
+let workflowActionService: WorkflowActionDataService;
let item;
let rdItem;
let workflowitem;
let rdWorkflowitem;
+let workflowAction;
function init() {
mockDataService = jasmine.createSpyObj('ClaimedTaskDataService', {
@@ -46,9 +48,7 @@ function init() {
rejectTask: jasmine.createSpy('rejectTask'),
returnToPoolTask: jasmine.createSpy('returnToPoolTask'),
});
-
searchService = getMockSearchService();
-
requestServce = getMockRequestService();
item = Object.assign(new Item(), {
@@ -84,7 +84,11 @@ function init() {
workflowitem = Object.assign(new WorkflowItem(), { item: observableOf(rdItem) });
rdWorkflowitem = createSuccessfulRemoteDataObject(workflowitem);
mockObject = Object.assign(new ClaimedTask(), { workflowitem: observableOf(rdWorkflowitem), id: '1234' });
+ workflowAction = Object.assign(new WorkflowAction(), { id: 'action-1', options: ['option-1', 'option-2'] });
+ workflowActionService = jasmine.createSpyObj('workflowActionService', {
+ findById: createSuccessfulRemoteDataObject$(workflowAction)
+ });
}
describe('ClaimedTaskActionsComponent', () => {
@@ -99,14 +103,15 @@ describe('ClaimedTaskActionsComponent', () => {
}
})
],
- declarations: [ClaimedTaskActionsComponent],
+ declarations: [ClaimedTaskActionsComponent, VarDirective],
providers: [
{ provide: Injector, useValue: {} },
{ provide: NotificationsService, useValue: new NotificationsServiceStub() },
{ provide: Router, useValue: new RouterStub() },
{ provide: ClaimedTaskDataService, useValue: mockDataService },
{ provide: SearchService, useValue: searchService },
- { provide: RequestService, useValue: requestServce }
+ { provide: RequestService, useValue: requestServce },
+ { provide: WorkflowActionDataService, useValue: workflowActionService }
],
schemas: [NO_ERRORS_SCHEMA]
}).overrideComponent(ClaimedTaskActionsComponent, {
@@ -123,11 +128,6 @@ describe('ClaimedTaskActionsComponent', () => {
fixture.detectChanges();
});
- afterEach(() => {
- fixture = null;
- component = null;
- });
-
it('should init objects properly', () => {
component.object = null;
component.initObjects(mockObject);
@@ -136,46 +136,14 @@ describe('ClaimedTaskActionsComponent', () => {
expect(component.workflowitem$).toBeObservable(cold('(b|)', {
b: rdWorkflowitem.payload
- }))
+ }));
});
- it('should display edit task button', () => {
- const btn = fixture.debugElement.query(By.css('.btn-info'));
-
- expect(btn).toBeDefined();
- });
-
- it('should call approveTask method when approving a task', fakeAsync(() => {
- spyOn(component, 'reload');
- mockDataService.approveTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.approve();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(mockDataService.approveTask).toHaveBeenCalledWith(mockObject.id);
- });
-
- }));
-
- it('should display a success notification on approve success', async(() => {
- spyOn(component, 'reload');
- mockDataService.approveTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.approve();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(notificationsServiceStub.success).toHaveBeenCalled();
- });
- }));
-
- it('should reload page on approve success', async(() => {
+ it('should reload page on process completed', async(() => {
spyOn(router, 'navigateByUrl');
router.url = 'test.url/test';
- mockDataService.approveTask.and.returnValue(observableOf({hasSucceeded: true}));
- component.approve();
+ component.handleActionResponse(true);
fixture.detectChanges();
fixture.whenStable().then(() => {
@@ -183,108 +151,8 @@ describe('ClaimedTaskActionsComponent', () => {
});
}));
- it('should display an error notification on approve failure', async(() => {
- mockDataService.approveTask.and.returnValue(observableOf({hasSucceeded: false}));
-
- component.approve();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(notificationsServiceStub.error).toHaveBeenCalled();
- });
- }));
-
- it('should call rejectTask method when rejecting a task', fakeAsync(() => {
- spyOn(component, 'reload');
- mockDataService.rejectTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.reject('test reject');
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(mockDataService.rejectTask).toHaveBeenCalledWith('test reject', mockObject.id);
- });
-
- }));
-
- it('should display a success notification on reject success', async(() => {
- spyOn(component, 'reload');
- mockDataService.rejectTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.reject('test reject');
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(notificationsServiceStub.success).toHaveBeenCalled();
- });
- }));
-
- it('should reload page on reject success', async(() => {
- spyOn(router, 'navigateByUrl');
- router.url = 'test.url/test';
- mockDataService.rejectTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.reject('test reject');
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(router.navigateByUrl).toHaveBeenCalledWith('test.url/test');
- });
- }));
-
- it('should display an error notification on reject failure', async(() => {
- mockDataService.rejectTask.and.returnValue(observableOf({hasSucceeded: false}));
-
- component.reject('test reject');
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(notificationsServiceStub.error).toHaveBeenCalled();
- });
- }));
-
- it('should call returnToPoolTask method when returning a task to pool', fakeAsync(() => {
- spyOn(component, 'reload');
- mockDataService.returnToPoolTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.returnToPool();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(mockDataService.returnToPoolTask).toHaveBeenCalledWith( mockObject.id);
- });
-
- }));
-
- it('should display a success notification on return to pool success', async(() => {
- spyOn(component, 'reload');
- mockDataService.returnToPoolTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.returnToPool();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(notificationsServiceStub.success).toHaveBeenCalled();
- });
- }));
-
- it('should reload page on return to pool success', async(() => {
- spyOn(router, 'navigateByUrl');
- router.url = 'test.url/test';
- mockDataService.returnToPoolTask.and.returnValue(observableOf({hasSucceeded: true}));
-
- component.returnToPool();
- fixture.detectChanges();
-
- fixture.whenStable().then(() => {
- expect(router.navigateByUrl).toHaveBeenCalledWith('test.url/test');
- });
- }));
-
- it('should display an error notification on return to pool failure', async(() => {
- mockDataService.returnToPoolTask.and.returnValue(observableOf({hasSucceeded: false}));
-
- component.returnToPool();
+ it('should display an error notification on process failure', async(() => {
+ component.handleActionResponse(false);
fixture.detectChanges();
fixture.whenStable().then(() => {
diff --git a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.ts b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.ts
index 81d24fa1d7..c82154af09 100644
--- a/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.ts
+++ b/src/app/shared/mydspace-actions/claimed-task/claimed-task-actions.component.ts
@@ -1,13 +1,12 @@
import { Component, Injector, Input, OnInit } from '@angular/core';
import { Router } from '@angular/router';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { Observable } from 'rxjs';
import { filter, map } from 'rxjs/operators';
import { TranslateService } from '@ngx-translate/core';
import { ClaimedTaskDataService } from '../../../core/tasks/claimed-task-data.service';
import { ClaimedTask } from '../../../core/tasks/models/claimed-task-object.model';
-import { ProcessTaskResponse } from '../../../core/tasks/models/process-task-response';
import { isNotUndefined } from '../../empty.util';
import { WorkflowItem } from '../../../core/submission/models/workflowitem.model';
import { RemoteData } from '../../../core/data/remote-data';
@@ -15,6 +14,9 @@ import { MyDSpaceActionsComponent } from '../mydspace-actions';
import { NotificationsService } from '../../notifications/notifications.service';
import { RequestService } from '../../../core/data/request.service';
import { SearchService } from '../../../core/shared/search/search.service';
+import { WorkflowAction } from '../../../core/tasks/models/workflow-action-object.model';
+import { WorkflowActionDataService } from '../../../core/data/workflow-action-data.service';
+import { WORKFLOW_TASK_OPTION_RETURN_TO_POOL } from './return-to-pool/claimed-task-actions-return-to-pool.component';
/**
* This component represents actions related to ClaimedTask object.
@@ -37,19 +39,15 @@ export class ClaimedTaskActionsComponent extends MyDSpaceActionsComponent;
/**
- * A boolean representing if an approve operation is pending
+ * The workflow action available for this task
*/
- public processingApprove$ = new BehaviorSubject(false);
+ public actionRD$: Observable>;
/**
- * A boolean representing if a reject operation is pending
+ * The option used to render the "return to pool" component
+ * Every claimed task contains this option
*/
- public processingReject$ = new BehaviorSubject(false);
-
- /**
- * A boolean representing if a return to pool operation is pending
- */
- public processingReturnToPool$ = new BehaviorSubject(false);
+ public returnToPoolOption = WORKFLOW_TASK_OPTION_RETURN_TO_POOL;
/**
* Initialize instance variables
@@ -60,13 +58,15 @@ export class ClaimedTaskActionsComponent extends MyDSpaceActionsComponent {
- this.processingApprove$.next(false);
- this.handleActionResponse(res.hasSucceeded);
- });
- }
-
- /**
- * Reject the task.
- */
- reject(reason) {
- this.processingReject$.next(true);
- this.objectDataService.rejectTask(reason, this.object.id)
- .subscribe((res: ProcessTaskResponse) => {
- this.processingReject$.next(false);
- this.handleActionResponse(res.hasSucceeded);
- });
- }
-
- /**
- * Return task to the pool.
- */
- returnToPool() {
- this.processingReturnToPool$.next(true);
- this.objectDataService.returnToPoolTask(this.object.id)
- .subscribe((res: ProcessTaskResponse) => {
- this.processingReturnToPool$.next(false);
- this.handleActionResponse(res.hasSucceeded);
- });
+ initAction(object: ClaimedTask) {
+ this.actionRD$ = object.action;
}
}
diff --git a/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.html b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.html
new file mode 100644
index 0000000000..4a42378f7e
--- /dev/null
+++ b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.html
@@ -0,0 +1,7 @@
+
+ {{'submission.workflow.tasks.claimed.edit' | translate}}
+
diff --git a/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.scss b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.spec.ts b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.spec.ts
new file mode 100644
index 0000000000..912671bd4b
--- /dev/null
+++ b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.spec.ts
@@ -0,0 +1,50 @@
+import { ChangeDetectionStrategy, NO_ERRORS_SCHEMA } from '@angular/core';
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+
+import { ClaimedTaskActionsEditMetadataComponent } from './claimed-task-actions-edit-metadata.component';
+import { MockTranslateLoader } from '../../../mocks/mock-translate-loader';
+import { ClaimedTask } from '../../../../core/tasks/models/claimed-task-object.model';
+import { ClaimedTaskDataService } from '../../../../core/tasks/claimed-task-data.service';
+
+let component: ClaimedTaskActionsEditMetadataComponent;
+let fixture: ComponentFixture;
+
+describe('ClaimedTaskActionsEditMetadataComponent', () => {
+ const object = Object.assign(new ClaimedTask(), { id: 'claimed-task-1' });
+
+ beforeEach(async(() => {
+ TestBed.configureTestingModule({
+ imports: [
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: MockTranslateLoader
+ }
+ })
+ ],
+ providers: [
+ { provide: ClaimedTaskDataService, useValue: {} }
+ ],
+ declarations: [ClaimedTaskActionsEditMetadataComponent],
+ schemas: [NO_ERRORS_SCHEMA]
+ }).overrideComponent(ClaimedTaskActionsEditMetadataComponent, {
+ set: { changeDetection: ChangeDetectionStrategy.Default }
+ }).compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(ClaimedTaskActionsEditMetadataComponent);
+ component = fixture.componentInstance;
+ component.object = object;
+ fixture.detectChanges();
+ });
+
+ it('should display edit button', () => {
+ const btn = fixture.debugElement.query(By.css('.btn-primary'));
+
+ expect(btn).toBeDefined();
+ });
+
+});
diff --git a/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.ts b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.ts
new file mode 100644
index 0000000000..c0ce9cd4e5
--- /dev/null
+++ b/src/app/shared/mydspace-actions/claimed-task/edit-metadata/claimed-task-actions-edit-metadata.component.ts
@@ -0,0 +1,26 @@
+import { Component } from '@angular/core';
+import { ClaimedTaskActionsAbstractComponent } from '../abstract/claimed-task-actions-abstract.component';
+import { rendersWorkflowTaskOption } from '../switcher/claimed-task-actions-decorator';
+import { ClaimedTaskDataService } from '../../../../core/tasks/claimed-task-data.service';
+
+export const WORKFLOW_TASK_OPTION_EDIT_METADATA = 'submit_edit_metadata';
+
+@rendersWorkflowTaskOption(WORKFLOW_TASK_OPTION_EDIT_METADATA)
+@Component({
+ selector: 'ds-claimed-task-actions-edit-metadata',
+ styleUrls: ['./claimed-task-actions-edit-metadata.component.scss'],
+ templateUrl: './claimed-task-actions-edit-metadata.component.html',
+})
+/**
+ * Component for displaying the edit metadata action on a workflow task item
+ */
+export class ClaimedTaskActionsEditMetadataComponent extends ClaimedTaskActionsAbstractComponent {
+ /**
+ * This component represents the edit metadata option
+ */
+ option = WORKFLOW_TASK_OPTION_EDIT_METADATA;
+
+ constructor(protected claimedTaskService: ClaimedTaskDataService) {
+ super(claimedTaskService);
+ }
+}
diff --git a/src/app/shared/mydspace-actions/claimed-task/reject/claimed-task-actions-reject.component.html b/src/app/shared/mydspace-actions/claimed-task/reject/claimed-task-actions-reject.component.html
index 5ab45f32c7..7c7b83cd8a 100644
--- a/src/app/shared/mydspace-actions/claimed-task/reject/claimed-task-actions-reject.component.html
+++ b/src/app/shared/mydspace-actions/claimed-task/reject/claimed-task-actions-reject.component.html
@@ -1,10 +1,10 @@
-
@@ -21,17 +21,17 @@
{{'submission.workflow.tasks.claimed.reject.reason.info' | translate}}
-