Added JDocs

src/app/+admin/admin-registries/metadata-registry/metadata-registry.reducers.ts

@@ -32,6 +32,11 @@ const initialState: MetadataRegistryState = {
   selectedFields: []
 };
 
+/**
+ * Reducer that handles MetadataRegistryActions to modify metadata schema and/or field states
+ * @param state   The current MetadataRegistryState
+ * @param action  The MetadataRegistryAction to perform on the state
+ */
 export function metadataRegistryReducer(state = initialState, action: MetadataRegistryAction): MetadataRegistryState {
 
   switch (action.type) {

src/app/+admin/admin-registries/metadata-schema/metadata-field-form/metadata-field-form.component.ts

@@ -95,6 +95,9 @@ export class MetadataFieldFormComponent implements OnInit, OnDestroy {
               private translateService: TranslateService) {
   }
 
+  /**
+   * Initialize the component, setting up the necessary Models for the dynamic form
+   */
   ngOnInit() {
     combineLatest(
       this.translateService.get(`${this.messagePrefix}.element`),

src/app/core/cache/response.models.ts

@@ -33,6 +33,9 @@ export class DSOSuccessResponse extends RestResponse {
   }
 }
 
+/**
+ * A successful response containing a list of MetadataSchemas wrapped in a RegistryMetadataschemasResponse
+ */
 export class RegistryMetadataschemasSuccessResponse extends RestResponse {
   constructor(
     public metadataschemasResponse: RegistryMetadataschemasResponse,
@@ -43,6 +46,9 @@ export class RegistryMetadataschemasSuccessResponse extends RestResponse {
   }
 }
 
+/**
+ * A successful response containing a list of MetadataFields wrapped in a RegistryMetadatafieldsResponse
+ */
 export class RegistryMetadatafieldsSuccessResponse extends RestResponse {
   constructor(
     public metadatafieldsResponse: RegistryMetadatafieldsResponse,
@@ -53,6 +59,9 @@ export class RegistryMetadatafieldsSuccessResponse extends RestResponse {
   }
 }
 
+/**
+ * A successful response containing a list of BitstreamFormats wrapped in a RegistryBitstreamformatsResponse
+ */
 export class RegistryBitstreamformatsSuccessResponse extends RestResponse {
   constructor(
     public bitstreamformatsResponse: RegistryBitstreamformatsResponse,
@@ -63,6 +72,9 @@ export class RegistryBitstreamformatsSuccessResponse extends RestResponse {
   }
 }
 
+/**
+ * A successful response containing exactly one MetadataSchema
+ */
 export class MetadataschemaSuccessResponse extends RestResponse {
   constructor(
     public metadataschema: MetadataSchema,
@@ -72,6 +84,9 @@ export class MetadataschemaSuccessResponse extends RestResponse {
   }
 }
 
+/**
+ * A successful response containing exactly one MetadataField
+ */
 export class MetadatafieldSuccessResponse extends RestResponse {
   constructor(
     public metadatafield: MetadataField,

src/app/core/data/metadata-schema-data.service.ts

@@ -17,6 +17,9 @@ import { HttpClient } from '@angular/common/http';
 import { ChangeAnalyzer } from './change-analyzer';
 import { NormalizedObjectBuildService } from '../cache/builders/normalized-object-build.service';
 
+/**
+ * A service responsible for fetching/sending data from/to the REST API on the metadataschemas endpoint
+ */
 @Injectable()
 export class MetadataSchemaDataService extends DataService<NormalizedMetadataSchema, MetadataSchema> {
   protected linkPath = 'metadataschemas';

src/app/core/data/metadatafield-parsing.service.ts

@@ -6,6 +6,9 @@ import { Injectable } from '@angular/core';
 import { MetadatafieldSuccessResponse, MetadataschemaSuccessResponse, RestResponse } from '../cache/response.models';
 import { MetadataField } from '../metadata/metadatafield.model';
 
+/**
+ * A service responsible for parsing DSpaceRESTV2Response data related to a single MetadataField to a valid RestResponse
+ */
 @Injectable()
 export class MetadatafieldParsingService implements ResponseParsingService {
 

src/app/core/data/request.models.ts

@@ -220,6 +220,9 @@ export class IntegrationRequest extends GetRequest {
   }
 }
 
+/**
+ * Request to create a MetadataSchema
+ */
 export class CreateMetadataSchemaRequest extends PostRequest {
   constructor(uuid: string, href: string, public body?: any, public options?: HttpOptions) {
     super(uuid, href, body, options);
@@ -230,6 +233,9 @@ export class CreateMetadataSchemaRequest extends PostRequest {
   }
 }
 
+/**
+ * Request to update a MetadataSchema
+ */
 export class UpdateMetadataSchemaRequest extends PutRequest {
   constructor(uuid: string, href: string, public body?: any, public options?: HttpOptions) {
     super(uuid, href, body, options);
@@ -240,6 +246,9 @@ export class UpdateMetadataSchemaRequest extends PutRequest {
   }
 }
 
+/**
+ * Request to create a MetadataField
+ */
 export class CreateMetadataFieldRequest extends PostRequest {
   constructor(uuid: string, href: string, public body?: any, public options?: HttpOptions) {
     super(uuid, href, body, options);
@@ -250,6 +259,9 @@ export class CreateMetadataFieldRequest extends PostRequest {
   }
 }
 
+/**
+ * Request to update a MetadataField
+ */
 export class UpdateMetadataFieldRequest extends PutRequest {
   constructor(uuid: string, href: string, public body?: any, public options?: HttpOptions) {
     super(uuid, href, body, options);

src/app/core/data/request.reducer.ts

@@ -110,6 +110,11 @@ function resetResponseTimestamps(state: RequestState, action: ResetResponseTimes
   return newState;
 }
 
+/**
+ * Remove a request from the RequestState
+ * @param state   The current RequestState
+ * @param action  The RequestRemoveAction to perform
+ */
 function removeRequest(state: RequestState, action: RequestRemoveAction): RequestState {
   const newState = Object.create(null);
   for (const value in state) {

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

@@ -55,6 +55,13 @@ export class RequestService {
     return pathSelector<CoreState, string>(coreSelector, 'index', IndexName.UUID_MAPPING, uuid);
   }
 
+  /**
+   * Create a selector that fetches a list of request UUIDs from a given index substate of which the request href
+   * contains a given substring
+   * @param selector    MemoizedSelector to start from
+   * @param name        The name of the index substate we're fetching request UUIDs from
+   * @param href        Substring that the request's href should contain
+   */
   private uuidsFromHrefSubstringSelector(selector: MemoizedSelector<any, IndexState>, name: string, href: string): MemoizedSelector<any, string[]> {
     return createSelector(selector, (state: IndexState) => this.getUuidsFromHrefSubstring(state, name, href));
   }

src/app/core/index/index.reducer.ts

@@ -65,6 +65,11 @@ function removeFromIndexByValue(state: IndexState, action: RemoveFromIndexByValu
   });
 }
 
+/**
+ * Remove values from the IndexState's substate that contain a given substring
+ * @param state     The IndexState to remove values from
+ * @param action    The RemoveFromIndexByValueAction containing the necessary information to remove the values
+ */
 function removeFromIndexBySubstring(state: IndexState, action: RemoveFromIndexByValueAction): IndexState {
   const subState = state[action.payload.name];
   const newSubState = Object.create(null);

src/app/core/metadata/normalized-metadata-schema.model.ts

@@ -5,17 +5,32 @@ import { CacheableObject } from '../cache/object-cache.reducer';
 import { ListableObject } from '../../shared/object-collection/shared/listable-object.model';
 import { MetadataSchema } from './metadataschema.model';
 
+/**
+ * Normalized class for a DSpace MetadataSchema
+ */
 @mapsTo(MetadataSchema)
 export class NormalizedMetadataSchema extends NormalizedObject implements CacheableObject, ListableObject {
+  /**
+   * The unique identifier for this schema
+   */
   @autoserialize
   id: number;
 
+  /**
+   * The REST link to itself
+   */
   @autoserialize
   self: string;
 
+  /**
+   * A unique prefix that defines this schema
+   */
   @autoserialize
   prefix: string;
 
+  /**
+   * The namespace for this schema
+   */
   @autoserialize
   namespace: string;
 }

src/app/core/registry/registry.service.ts

@@ -7,10 +7,11 @@ import { MetadataSchema } from '../metadata/metadataschema.model';
 import { MetadataField } from '../metadata/metadatafield.model';
 import { BitstreamFormat } from './mock-bitstream-format.model';
 import {
+  CreateMetadataFieldRequest,
   CreateMetadataSchemaRequest,
   DeleteRequest,
   GetRequest,
-  RestRequest,
+  RestRequest, UpdateMetadataFieldRequest,
   UpdateMetadataSchemaRequest
 } from '../data/request.models';
 import { GenericConstructor } from '../shared/generic-constructor';
@@ -314,6 +315,14 @@ export class RegistryService {
     return this.store.pipe(select(selectedMetadataFieldsSelector));
   }
 
+  /**
+   * Create or Update a MetadataSchema
+   *  If the MetadataSchema contains an id, it is assumed the schema already exists and is updated instead
+   *  Since creating or updating is nearly identical, the only real difference is the request (and slight difference in endpoint):
+   *  - On creation, a CreateMetadataSchemaRequest is used
+   *  - On update, a UpdateMetadataSchemaRequest is used
+   * @param schema    The MetadataSchema to create or update
+   */
   public createOrUpdateMetadataSchema(schema: MetadataSchema): Observable<MetadataSchema> {
     const isUpdate = hasValue(schema.id);
     const requestId = this.requestService.generateRequestId();
@@ -377,6 +386,14 @@ export class RegistryService {
     )
   }
 
+  /**
+   * Create or Update a MetadataField
+   *  If the MetadataField contains an id, it is assumed the field already exists and is updated instead
+   *  Since creating or updating is nearly identical, the only real difference is the request (and slight difference in endpoint):
+   *  - On creation, a CreateMetadataFieldRequest is used
+   *  - On update, a UpdateMetadataFieldRequest is used
+   * @param field    The MetadataField to create or update
+   */
   public createOrUpdateMetadataField(field: MetadataField): Observable<MetadataField> {
     const isUpdate = hasValue(field.id);
     const requestId = this.requestService.generateRequestId();
@@ -394,9 +411,9 @@ export class RegistryService {
           let headers = new HttpHeaders();
           headers = headers.append('Content-Type', 'application/json');
           options.headers = headers;
-          return new UpdateMetadataSchemaRequest(requestId, endpoint, JSON.stringify(field), options);
+          return new UpdateMetadataFieldRequest(requestId, endpoint, JSON.stringify(field), options);
         } else {
-          return new CreateMetadataSchemaRequest(requestId, endpoint, JSON.stringify(field));
+          return new CreateMetadataFieldRequest(requestId, endpoint, JSON.stringify(field));
         }
       })
     );