115284: Fix issue with same type relationships

Author: YanaDePauw

src/app/item-page/edit-item-page/item-relationships/edit-item-relationships.service.spec.ts

@@ -265,6 +265,95 @@ describe('EditItemRelationshipsService', () => {
     });
   });
 
+  describe('isProvidedItemTypeLeftType', () => {
+    it('should return true if the provided item corresponds to the left type of the relationship', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id: 'leftType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id: 'rightType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'leftType' } );
+      const item = Object.assign(new Item(), { uuid: 'item-uuid' });
+
+      const result = service.isProvidedItemTypeLeftType(relationshipType, itemType, item);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeTrue();
+        done();
+      });
+    });
+
+    it('should return false if the provided item corresponds to the right type of the relationship', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id: 'leftType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id: 'rightType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'rightType' } );
+      const item = Object.assign(new Item(), { uuid: 'item-uuid' });
+
+      const result = service.isProvidedItemTypeLeftType(relationshipType, itemType, item);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeFalse();
+        done();
+      });
+    });
+
+    it('should return undefined if the provided item corresponds does not match any of the relationship types', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id: 'leftType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id: 'rightType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'something-else' } );
+      const item = Object.assign(new Item(), { uuid: 'item-uuid' });
+
+      const result = service.isProvidedItemTypeLeftType(relationshipType, itemType, item);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeUndefined();
+        done();
+      });
+    });
+  });
+
+  describe('relationshipMatchesBothSameTypes', () => {
+    it('should return true if both left and right type of the relationship type are the same and match the provided itemtype', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id:  'sameType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id:'sameType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'sameType' } );
+
+      const result = service.relationshipMatchesBothSameTypes(relationshipType, itemType);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeTrue();
+        done();
+      });
+    });
+    it('should return false if both left and right type of the relationship type are the same and do not match the provided itemtype', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id: 'sameType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id: 'sameType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'something-else' } );
+
+      const result = service.relationshipMatchesBothSameTypes(relationshipType, itemType);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeFalse();
+        done();
+      });
+    });
+    it('should return false if both left and right type of the relationship type are different', (done) => {
+      const relationshipType = Object.assign(new RelationshipType(), {
+        leftType: createSuccessfulRemoteDataObject$({ id: 'leftType' }),
+        rightType: createSuccessfulRemoteDataObject$({ id: 'rightType' }),
+      });
+      const itemType = Object.assign(new ItemType(), { id: 'leftType' } );
+
+      const result = service.relationshipMatchesBothSameTypes(relationshipType, itemType);
+      result.subscribe((resultValue) => {
+        expect(resultValue).toBeFalse();
+        done();
+      });
+    });
+  });
+
   describe('displayNotifications', () => {
     it('should show one success notification when multiple requests succeeded', () => {
       service.displayNotifications([

src/app/item-page/edit-item-page/item-relationships/edit-item-relationships.service.ts

@@ -3,6 +3,7 @@ import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
 import { TranslateService } from '@ngx-translate/core';
 import {
   BehaviorSubject,
+  combineLatest as observableCombineLatest,
   EMPTY,
   Observable,
   Subscription,
@@ -28,8 +29,14 @@ import { ObjectUpdatesService } from '../../../core/data/object-updates/object-u
 import { RelationshipDataService } from '../../../core/data/relationship-data.service';
 import { RemoteData } from '../../../core/data/remote-data';
 import { Item } from '../../../core/shared/item.model';
+import { ItemType } from '../../../core/shared/item-relationships/item-type.model';
 import { Relationship } from '../../../core/shared/item-relationships/relationship.model';
+import { RelationshipType } from '../../../core/shared/item-relationships/relationship-type.model';
 import { NoContent } from '../../../core/shared/NoContent.model';
+import {
+  getFirstSucceededRemoteData,
+  getRemoteDataPayload,
+} from '../../../core/shared/operators';
 import { hasValue } from '../../../shared/empty.util';
 import { NotificationsService } from '../../../shared/notifications/notifications.service';
 
@@ -181,6 +188,49 @@ export class EditItemRelationshipsService {
     }
   }
 
+  isProvidedItemTypeLeftType(relationshipType: RelationshipType, itemType: ItemType, item: Item): Observable<boolean> {
+    return this.getRelationshipLeftAndRightType(relationshipType).pipe(
+      map(([leftType, rightType]: [ItemType, ItemType]) => {
+        if (leftType.id === itemType.id) {
+          return true;
+        }
+
+        if (rightType.id === itemType.id) {
+          return false;
+        }
+
+        // should never happen...
+        console.warn(`The item ${item.uuid} is not on the right or the left side of relationship type ${relationshipType.uuid}`);
+        return undefined;
+      }),
+    );
+  }
+
+  relationshipMatchesBothSameTypes(relationshipType: RelationshipType, itemType: ItemType): Observable<boolean> {
+    return this.getRelationshipLeftAndRightType(relationshipType).pipe(
+      map(([leftType, rightType]: [ItemType, ItemType]) => {
+        return leftType.id === itemType.id && rightType.id === itemType.id;
+      }),
+    );
+  }
+
+  protected getRelationshipLeftAndRightType(relationshipType: RelationshipType): Observable<[ItemType, ItemType]> {
+    const leftType$: Observable<ItemType> = relationshipType.leftType.pipe(
+      getFirstSucceededRemoteData(),
+      getRemoteDataPayload(),
+    );
+
+    const rightType$: Observable<ItemType> = relationshipType.rightType.pipe(
+      getFirstSucceededRemoteData(),
+      getRemoteDataPayload(),
+    );
+
+    return observableCombineLatest([
+      leftType$,
+      rightType$,
+    ]);
+  }
+
 
 
   /**
@@ -197,6 +247,5 @@ export class EditItemRelationshipsService {
    */
   getNotificationContent(key: string): string {
     return this.translateService.instant(this.notificationsPrefix + key + '.content');
-
   }
 }

src/app/item-page/edit-item-page/item-relationships/edit-relationship-list-wrapper/edit-relationship-list-wrapper.component.html

@@ -0,0 +1,30 @@
+<ng-container *ngIf="bothItemsMatchType$ | async">
+    <ds-edit-relationship-list
+            [url]="url"
+            [item]="item"
+            [itemType]="itemType"
+            [relationshipType]="relationshipType"
+            [hasChanges]="hasChanges"
+            [currentItemIsLeftItem$]="isLeftItem$"
+    ></ds-edit-relationship-list>
+    <ds-edit-relationship-list
+            [url]="url"
+            [item]="item"
+            [itemType]="itemType"
+            [relationshipType]="relationshipType"
+            [hasChanges]="hasChanges"
+            [currentItemIsLeftItem$]="isRightItem$"
+    ></ds-edit-relationship-list>
+</ng-container>
+
+<ng-container *ngIf="(bothItemsMatchType$ | async) === false">
+    <ds-edit-relationship-list
+            [url]="url"
+            [item]="item"
+            [itemType]="itemType"
+            [relationshipType]="relationshipType"
+            [hasChanges]="hasChanges"
+            [currentItemIsLeftItem$]="currentItemIsLeftItem$"
+    ></ds-edit-relationship-list>
+</ng-container>
+

src/app/item-page/edit-item-page/item-relationships/edit-relationship-list-wrapper/edit-relationship-list-wrapper.component.scss

@@ -0,0 +1,121 @@
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import {
+  ComponentFixture,
+  TestBed,
+  waitForAsync,
+} from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { of as observableOf } from 'rxjs';
+
+import { Item } from '../../../../core/shared/item.model';
+import { ItemType } from '../../../../core/shared/item-relationships/item-type.model';
+import { RelationshipType } from '../../../../core/shared/item-relationships/relationship-type.model';
+import { createSuccessfulRemoteDataObject$ } from '../../../../shared/remote-data.utils';
+import { EditItemRelationshipsService } from '../edit-item-relationships.service';
+import { EditRelationshipListComponent } from '../edit-relationship-list/edit-relationship-list.component';
+import { EditRelationshipListWrapperComponent } from './edit-relationship-list-wrapper.component';
+
+describe('EditRelationshipListWrapperComponent', () => {
+  let editItemRelationshipsService: EditItemRelationshipsService;
+  let comp: EditRelationshipListWrapperComponent;
+  let fixture: ComponentFixture<EditRelationshipListWrapperComponent>;
+
+  const leftType = Object.assign(new ItemType(), { id: 'leftType', label: 'leftTypeString' });
+  const rightType = Object.assign(new ItemType(), { id: 'rightType', label: 'rightTypeString' });
+
+  const relationshipType = Object.assign(new RelationshipType(), {
+    id: '1',
+    leftMaxCardinality: null,
+    leftMinCardinality: 0,
+    leftType: createSuccessfulRemoteDataObject$(leftType),
+    leftwardType: 'isOrgUnitOfOrgUnit',
+    rightMaxCardinality: null,
+    rightMinCardinality: 0,
+    rightType: createSuccessfulRemoteDataObject$(rightType),
+    rightwardType: 'isOrgUnitOfOrgUnit',
+    uuid: 'relationshiptype-1',
+  });
+
+  const item = Object.assign(new Item(), { uuid: 'item-uuid' });
+
+  beforeEach(waitForAsync(() => {
+
+    editItemRelationshipsService = jasmine.createSpyObj('editItemRelationshipsService', {
+      isProvidedItemTypeLeftType: observableOf(true),
+      relationshipMatchesBothSameTypes: observableOf(false),
+    });
+
+
+    TestBed.configureTestingModule({
+      imports: [
+        EditRelationshipListWrapperComponent,
+      ],
+      providers: [
+        { provide: EditItemRelationshipsService, useValue: editItemRelationshipsService },
+      ],
+      schemas: [
+        CUSTOM_ELEMENTS_SCHEMA,
+      ],
+    }).overrideComponent(EditRelationshipListWrapperComponent, {
+      remove: {
+        imports: [
+          EditRelationshipListComponent,
+        ],
+      },
+    }).compileComponents();
+
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(EditRelationshipListWrapperComponent);
+    comp = fixture.componentInstance;
+    comp.relationshipType = relationshipType;
+    comp.itemType = leftType;
+    comp.item = item;
+
+    fixture.detectChanges();
+  });
+
+  describe('onInit', () => {
+    it('should render the component', () => {
+      expect(comp).toBeTruthy();
+    });
+    it('should set currentItemIsLeftItem$ and bothItemsMatchType$  based on the provided relationshipType, itemType and item', () => {
+      expect(editItemRelationshipsService.isProvidedItemTypeLeftType).toHaveBeenCalledWith(relationshipType, leftType, item);
+      expect(editItemRelationshipsService.relationshipMatchesBothSameTypes).toHaveBeenCalledWith(relationshipType, leftType);
+
+      expect(comp.currentItemIsLeftItem$.getValue()).toEqual(true);
+      expect(comp.bothItemsMatchType$.getValue()).toEqual(false);
+    });
+  });
+
+  describe('when the current item is left', () => {
+    it('should render one relationship list section', () => {
+      const relationshipLists = fixture.debugElement.queryAll(By.css('ds-edit-relationship-list'));
+      expect(relationshipLists.length).toEqual(1);
+    });
+  });
+
+  describe('when the current item is right', () => {
+    it('should render one relationship list section', () => {
+      (editItemRelationshipsService.isProvidedItemTypeLeftType as jasmine.Spy).and.returnValue(observableOf(false));
+      comp.ngOnInit();
+      fixture.detectChanges();
+
+      const relationshipLists = fixture.debugElement.queryAll(By.css('ds-edit-relationship-list'));
+      expect(relationshipLists.length).toEqual(1);
+    });
+  });
+
+  describe('when the current item is both left and right', () => {
+    it('should render two relationship list sections', () => {
+      (editItemRelationshipsService.relationshipMatchesBothSameTypes as jasmine.Spy).and.returnValue(observableOf(true));
+      comp.ngOnInit();
+      fixture.detectChanges();
+
+      const relationshipLists = fixture.debugElement.queryAll(By.css('ds-edit-relationship-list'));
+      expect(relationshipLists.length).toEqual(2);
+    });
+  });
+
+});