61142: Working submit (except reloading lists) and JSDocs

src/app/+item-page/edit-item-page/item-relationships/item-relationships.component.ts

@@ -69,7 +69,12 @@ export class ItemRelationshipsComponent extends AbstractItemUpdateComponent {
     this.notificationsPrefix = 'item.edit.relationships.notifications.';
   }
 
+  /**
+   * Resolve the currently selected related items back to relationships and send a delete request
+   * Make sure the lists are refreshed afterwards
+   */
   public submit(): void {
+    // Get all IDs of related items of which their relationship with the current item is about to be removed
     const removedItemIds$ = this.relationshipService.getRelatedItems(this.item).pipe(
       switchMap((items: Item[]) => this.objectUpdatesService.getFieldUpdatesExclusive(this.url, items) as Observable<FieldUpdates>),
       map((fieldUpdates: FieldUpdates) => Object.values(fieldUpdates).filter((fieldUpdate: FieldUpdate) => fieldUpdate.changeType === FieldChangeType.REMOVE)),
@@ -80,18 +85,21 @@ export class ItemRelationshipsComponent extends AbstractItemUpdateComponent {
       this.relationshipService.getItemRelationshipsArray(this.item),
       removedItemIds$
     );
+    // Get all IDs of the relationships that should be removed
     const removedRelationshipIds$ = allRelationshipsAndRemovedItemIds$.pipe(
       map(([relationships, itemIds]) =>
         relationships
           .filter((relationship: Relationship) => itemIds.indexOf(relationship.leftId) > -1 || itemIds.indexOf(relationship.rightId) > -1)
           .map((relationship: Relationship) => relationship.id))
     );
+    // Request a delete for every relationship found in the observable created above
     removedRelationshipIds$.pipe(
       take(1),
-      switchMap((removedIds: string[]) => observableZip(removedIds.map((uuid: string) => this.relationshipService.deleteRelationship(uuid)))),
+      switchMap((removedIds: string[]) => observableZip(...removedIds.map((uuid: string) => this.relationshipService.deleteRelationship(uuid)))),
       map((responses: RestResponse[]) => responses.filter((response: RestResponse) => response.isSuccessful))
     ).subscribe((responses: RestResponse[]) => {
-      console.log(responses);
+      // Make sure the lists are up-to-date and send a notification that the removal was successful
+      // TODO: Fix lists refreshing correctly
       this.initializeOriginalFields();
       this.initializeUpdates();
       this.notificationsService.success(this.getNotificationTitle('saved'), this.getNotificationContent('saved'));

src/app/core/data/object-updates/object-updates.service.ts

@@ -103,6 +103,12 @@ export class ObjectUpdatesService {
     }))
   }
 
+  /**
+   * Method that combines the state's updates (excluding updates that aren't part of the initialFields) with
+   * the initial values (when there's no update) 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
+   */
   getFieldUpdatesExclusive(url: string, initialFields: Identifiable[]): Observable<FieldUpdates> {
     const objectUpdates = this.getObjectEntry(url);
     return objectUpdates.pipe(map((objectEntry) => {

src/app/core/data/relationship.service.ts

@@ -39,12 +39,20 @@ export class RelationshipService {
               protected itemService: ItemDataService) {
   }
 
+  /**
+   * Get the endpoint for a relationship by ID
+   * @param uuid
+   */
   getRelationshipEndpoint(uuid: string) {
     return this.halService.getEndpoint(this.linkPath).pipe(
       map((href: string) => `${href}/${uuid}`)
     );
   }
 
+  /**
+   * Send a delete request for a relationship by ID
+   * @param uuid
+   */
   deleteRelationship(uuid: string): Observable<RestResponse> {
     return this.getRelationshipEndpoint(uuid).pipe(
       isNotEmptyOperator(),
@@ -56,6 +64,11 @@ export class RelationshipService {
     );
   }
 
+  /**
+   * Get a combined observable containing an array of all relationships in an item, as well as an array of the relationships their types
+   * This is used for easier access of a relationship's type because they exist as observables
+   * @param item
+   */
   getItemResolvedRelsAndTypes(item: Item): Observable<[Relationship[], RelationshipType[]]> {
     const relationships$ = this.getItemRelationshipsArray(item);
 
@@ -74,6 +87,10 @@ export class RelationshipService {
     );
   }
 
+  /**
+   * Get an item their relationships in the form of an array
+   * @param item
+   */
   getItemRelationshipsArray(item: Item): Observable<Relationship[]> {
     return item.relationships.pipe(
       getSucceededRemoteData(),
@@ -84,6 +101,11 @@ export class RelationshipService {
     );
   }
 
+  /**
+   * Get an array of an item their unique relationship type's labels
+   * The array doesn't contain any duplicate labels
+   * @param item
+   */
   getItemRelationshipLabels(item: Item): Observable<string[]> {
     return this.getItemResolvedRelsAndTypes(item).pipe(
       map(([relsCurrentPage, relTypesCurrentPage]) => {
@@ -100,12 +122,22 @@ export class RelationshipService {
     )
   }
 
+  /**
+   * Resolve a given item's relationships into related items and return the items as an array
+   * @param item
+   */
   getRelatedItems(item: Item): Observable<Item[]> {
     return this.getItemRelationshipsArray(item).pipe(
       relationsToItems(item.uuid, this.itemService)
     );
   }
 
+  /**
+   * Resolve a given item's relationships into related items, filtered by a relationship label
+   * and return the items as an array
+   * @param item
+   * @param label
+   */
   getRelatedItemsByLabel(item: Item, label: string): Observable<Item[]> {
     return this.getItemResolvedRelsAndTypes(item).pipe(
       filterRelationsByTypeLabel(label),