Adds create dataset use case

src/core/domain/useCases/validators/NewResourceValidator.ts

@@ -0,0 +1,6 @@
+import { ResourceValidationError } from './errors/ResourceValidationError';
+
+export interface NewResourceValidator {
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  validate(...args: any[]): Promise<void | ResourceValidationError>;
+}

src/core/domain/useCases/validators/errors/ResourceValidationError.ts

@@ -0,0 +1,5 @@
+export class ResourceValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

src/datasets/domain/dtos/NewDatasetDTO.ts

@@ -0,0 +1,21 @@
+import { DatasetLicense } from '../models/Dataset';
+
+export interface NewDatasetDTO {
+  license?: DatasetLicense;
+  metadataBlockValues: NewDatasetMetadataBlockValuesDTO[];
+}
+
+export interface NewDatasetMetadataBlockValuesDTO {
+  name: string;
+  fields: NewDatasetMetadataFieldsDTO;
+}
+
+export type NewDatasetMetadataFieldsDTO = Record<string, NewDatasetMetadataFieldValueDTO>;
+
+export type NewDatasetMetadataFieldValueDTO =
+  | string
+  | string[]
+  | NewDatasetMetadataChildFieldValueDTO
+  | NewDatasetMetadataChildFieldValueDTO[];
+
+export type NewDatasetMetadataChildFieldValueDTO = Record<string, string>;

src/datasets/domain/models/CreatedDatasetIdentifiers.ts

@@ -0,0 +1,4 @@
+export interface CreatedDatasetIdentifiers {
+  persistentId: string;
+  numericId: number;
+}

src/datasets/domain/repositories/IDatasetsRepository.ts

@@ -2,6 +2,9 @@ import { Dataset } from '../models/Dataset';
 import { DatasetUserPermissions } from '../models/DatasetUserPermissions';
 import { DatasetLock } from '../models/DatasetLock';
 import { DatasetPreviewSubset } from '../models/DatasetPreviewSubset';
+import { NewDatasetDTO } from '../dtos/NewDatasetDTO';
+import { MetadataBlock } from '../../../metadataBlocks';
+import { CreatedDatasetIdentifiers } from '../models/CreatedDatasetIdentifiers';
 
 export interface IDatasetsRepository {
   getDatasetSummaryFieldNames(): Promise<string[]>;
@@ -12,4 +15,9 @@ export interface IDatasetsRepository {
   getDatasetUserPermissions(datasetId: number | string): Promise<DatasetUserPermissions>;
   getDatasetLocks(datasetId: number | string): Promise<DatasetLock[]>;
   getAllDatasetPreviews(limit?: number, offset?: number): Promise<DatasetPreviewSubset>;
+  createDataset(
+    newDataset: NewDatasetDTO,
+    datasetMetadataBlocks: MetadataBlock[],
+    collectionId: string,
+  ): Promise<CreatedDatasetIdentifiers>;
 }

src/datasets/domain/useCases/CreateDataset.ts

@@ -0,0 +1,39 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase';
+import { IDatasetsRepository } from '../repositories/IDatasetsRepository';
+import { NewDatasetDTO, NewDatasetMetadataBlockValuesDTO } from '../dtos/NewDatasetDTO';
+import { NewResourceValidator } from '../../../core/domain/useCases/validators/NewResourceValidator';
+import { IMetadataBlocksRepository } from '../../../metadataBlocks/domain/repositories/IMetadataBlocksRepository';
+import { MetadataBlock } from '../../../metadataBlocks';
+import { CreatedDatasetIdentifiers } from '../models/CreatedDatasetIdentifiers';
+
+export class CreateDataset implements UseCase<CreatedDatasetIdentifiers> {
+  private datasetsRepository: IDatasetsRepository;
+  private metadataBlocksRepository: IMetadataBlocksRepository;
+  private newDatasetValidator: NewResourceValidator;
+
+  constructor(
+    datasetsRepository: IDatasetsRepository,
+    metadataBlocksRepository: IMetadataBlocksRepository,
+    newDatasetValidator: NewResourceValidator,
+  ) {
+    this.datasetsRepository = datasetsRepository;
+    this.metadataBlocksRepository = metadataBlocksRepository;
+    this.newDatasetValidator = newDatasetValidator;
+  }
+
+  async execute(newDataset: NewDatasetDTO, collectionId: string = 'root'): Promise<CreatedDatasetIdentifiers> {
+    const metadataBlocks = await this.getNewDatasetMetadataBlocks(newDataset);
+    this.newDatasetValidator.validate(newDataset, metadataBlocks);
+    return this.datasetsRepository.createDataset(newDataset, metadataBlocks, collectionId);
+  }
+
+  async getNewDatasetMetadataBlocks(newDataset: NewDatasetDTO): Promise<MetadataBlock[]> {
+    let metadataBlocks: MetadataBlock[] = [];
+    await Promise.all(
+      newDataset.metadataBlockValues.map(async (metadataBlockValue: NewDatasetMetadataBlockValuesDTO) => {
+        metadataBlocks.push(await this.metadataBlocksRepository.getMetadataBlockByName(metadataBlockValue.name));
+      }),
+    );
+    return metadataBlocks;
+  }
+}

src/datasets/domain/useCases/validators/BaseMetadataFieldValidator.ts

@@ -0,0 +1,29 @@
+import { NewDatasetMetadataFieldValueDTO } from '../../dtos/NewDatasetDTO';
+import { FieldValidationError } from './errors/FieldValidationError';
+import { MetadataFieldInfo } from '../../../../metadataBlocks';
+
+export interface NewDatasetMetadataFieldAndValueInfo {
+  metadataFieldInfo: MetadataFieldInfo;
+  metadataFieldKey: string;
+  metadataFieldValue: NewDatasetMetadataFieldValueDTO;
+  metadataBlockName: string;
+  metadataParentFieldKey?: string;
+  metadataFieldPosition?: number;
+}
+
+export abstract class BaseMetadataFieldValidator {
+  abstract validate(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo): void;
+
+  protected createGeneralValidationError(
+    newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo,
+    reason: string,
+  ): FieldValidationError {
+    return new FieldValidationError(
+      newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+      newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+      newDatasetMetadataFieldAndValueInfo.metadataParentFieldKey,
+      newDatasetMetadataFieldAndValueInfo.metadataFieldPosition,
+      reason,
+    );
+  }
+}

src/datasets/domain/useCases/validators/MetadataFieldValidator.ts

@@ -0,0 +1,51 @@
+import { BaseMetadataFieldValidator, NewDatasetMetadataFieldAndValueInfo } from './BaseMetadataFieldValidator';
+import { MultipleMetadataFieldValidator } from './MultipleMetadataFieldValidator';
+import { SingleMetadataFieldValidator } from './SingleMetadataFieldValidator';
+import { EmptyFieldError } from './errors/EmptyFieldError';
+import { NewDatasetMetadataFieldValueDTO } from '../../dtos/NewDatasetDTO';
+
+export class MetadataFieldValidator extends BaseMetadataFieldValidator {
+  constructor(
+    private singleMetadataFieldValidator: SingleMetadataFieldValidator,
+    private multipleMetadataFieldValidator: MultipleMetadataFieldValidator,
+  ) {
+    super();
+  }
+
+  validate(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo): void {
+    const metadataFieldValue = newDatasetMetadataFieldAndValueInfo.metadataFieldValue;
+    const metadataFieldInfo = newDatasetMetadataFieldAndValueInfo.metadataFieldInfo;
+    if (
+      metadataFieldValue == undefined ||
+      metadataFieldValue == null ||
+      this.isEmptyString(metadataFieldValue) ||
+      this.isEmptyArray(metadataFieldValue)
+    ) {
+      if (metadataFieldInfo.isRequired) {
+        throw new EmptyFieldError(
+          newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+          newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+          newDatasetMetadataFieldAndValueInfo.metadataParentFieldKey,
+          newDatasetMetadataFieldAndValueInfo.metadataFieldPosition,
+        );
+      } else {
+        return;
+      }
+    }
+    if (newDatasetMetadataFieldAndValueInfo.metadataFieldInfo.multiple) {
+      this.multipleMetadataFieldValidator.validate(newDatasetMetadataFieldAndValueInfo);
+    } else {
+      this.singleMetadataFieldValidator.validate(newDatasetMetadataFieldAndValueInfo);
+    }
+  }
+
+  private isEmptyString(metadataFieldValue: NewDatasetMetadataFieldValueDTO): boolean {
+    return typeof metadataFieldValue == 'string' && metadataFieldValue.trim() === '';
+  }
+
+  private isEmptyArray(metadataFieldValue: NewDatasetMetadataFieldValueDTO): boolean {
+    return (
+      Array.isArray(metadataFieldValue) && (metadataFieldValue as Array<NewDatasetMetadataFieldValueDTO>).length == 0
+    );
+  }
+}

src/datasets/domain/useCases/validators/MultipleMetadataFieldValidator.ts

@@ -0,0 +1,55 @@
+import { BaseMetadataFieldValidator, NewDatasetMetadataFieldAndValueInfo } from './BaseMetadataFieldValidator';
+import { NewDatasetMetadataFieldValueDTO } from '../../dtos/NewDatasetDTO';
+import { SingleMetadataFieldValidator } from './SingleMetadataFieldValidator';
+
+export class MultipleMetadataFieldValidator extends BaseMetadataFieldValidator {
+  constructor(private singleMetadataFieldValidator: SingleMetadataFieldValidator) {
+    super();
+  }
+
+  validate(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo): void {
+    const metadataFieldValue = newDatasetMetadataFieldAndValueInfo.metadataFieldValue;
+    const metadataFieldInfo = newDatasetMetadataFieldAndValueInfo.metadataFieldInfo;
+    if (!Array.isArray(metadataFieldValue)) {
+      throw this.createGeneralValidationError(newDatasetMetadataFieldAndValueInfo, 'Expecting an array of values.');
+    }
+    if (this.isValidArrayType(metadataFieldValue, 'string') && metadataFieldInfo.type === 'NONE') {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'Expecting an array of child fields, not strings.',
+      );
+    } else if (this.isValidArrayType(metadataFieldValue, 'object') && metadataFieldInfo.type !== 'NONE') {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'Expecting an array of strings, not child fields.',
+      );
+    } else if (
+      !this.isValidArrayType(metadataFieldValue, 'object') &&
+      !this.isValidArrayType(metadataFieldValue, 'string')
+    ) {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'The provided array of values is not valid.',
+      );
+    }
+
+    const fieldValues = metadataFieldValue as NewDatasetMetadataFieldValueDTO[];
+    fieldValues.forEach((value, metadataFieldPosition) => {
+      this.singleMetadataFieldValidator.validate({
+        metadataFieldInfo: metadataFieldInfo,
+        metadataFieldKey: newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+        metadataFieldValue: value,
+        metadataBlockName: newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+        metadataParentFieldKey: newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+        metadataFieldPosition: metadataFieldPosition,
+      });
+    });
+  }
+
+  private isValidArrayType(
+    metadataFieldValue: Array<string | NewDatasetMetadataFieldValueDTO>,
+    expectedType: 'string' | 'object',
+  ): boolean {
+    return metadataFieldValue.every((item: string | NewDatasetMetadataFieldValueDTO) => typeof item === expectedType);
+  }
+}

src/datasets/domain/useCases/validators/NewDatasetResourceValidator.ts

@@ -0,0 +1,33 @@
+import { NewDatasetDTO, NewDatasetMetadataBlockValuesDTO } from '../../dtos/NewDatasetDTO';
+import { NewResourceValidator } from '../../../../core/domain/useCases/validators/NewResourceValidator';
+import { MetadataBlock } from '../../../../metadataBlocks';
+import { ResourceValidationError } from '../../../../core/domain/useCases/validators/errors/ResourceValidationError';
+import { BaseMetadataFieldValidator } from './BaseMetadataFieldValidator';
+
+export class NewDatasetResourceValidator implements NewResourceValidator {
+  constructor(private metadataFieldValidator: BaseMetadataFieldValidator) {}
+
+  async validate(resource: NewDatasetDTO, metadataBlocks: MetadataBlock[]): Promise<void | ResourceValidationError> {
+    for (const metadataBlockValues of resource.metadataBlockValues) {
+      await this.validateMetadataBlock(metadataBlockValues, metadataBlocks);
+    }
+  }
+
+  private async validateMetadataBlock(
+    metadataBlockValues: NewDatasetMetadataBlockValuesDTO,
+    metadataBlocks: MetadataBlock[],
+  ) {
+    const metadataBlockName = metadataBlockValues.name;
+    const metadataBlock: MetadataBlock = metadataBlocks.find(
+      (metadataBlock) => metadataBlock.name === metadataBlockName,
+    );
+    for (const metadataFieldKey of Object.keys(metadataBlock.metadataFields)) {
+      this.metadataFieldValidator.validate({
+        metadataFieldInfo: metadataBlock.metadataFields[metadataFieldKey],
+        metadataFieldKey: metadataFieldKey,
+        metadataFieldValue: metadataBlockValues.fields[metadataFieldKey],
+        metadataBlockName: metadataBlockName,
+      });
+    }
+  }
+}

src/datasets/domain/useCases/validators/SingleMetadataFieldValidator.ts

@@ -0,0 +1,95 @@
+import { BaseMetadataFieldValidator, NewDatasetMetadataFieldAndValueInfo } from './BaseMetadataFieldValidator';
+import { ControlledVocabularyFieldError } from './errors/ControlledVocabularyFieldError';
+import { DateFormatFieldError } from './errors/DateFormatFieldError';
+import { MetadataFieldValidator } from './MetadataFieldValidator';
+import { NewDatasetMetadataChildFieldValueDTO } from '../../dtos/NewDatasetDTO';
+import { MultipleMetadataFieldValidator } from './MultipleMetadataFieldValidator';
+
+export class SingleMetadataFieldValidator extends BaseMetadataFieldValidator {
+  validate(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo): void {
+    const metadataFieldValue = newDatasetMetadataFieldAndValueInfo.metadataFieldValue;
+    const metadataFieldInfo = newDatasetMetadataFieldAndValueInfo.metadataFieldInfo;
+    if (Array.isArray(metadataFieldValue)) {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'Expecting a single field, not an array.',
+      );
+    }
+    if (typeof metadataFieldValue === 'object' && metadataFieldInfo.type !== 'NONE') {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'Expecting a string, not child fields.',
+      );
+    }
+    if (typeof metadataFieldValue === 'string' && metadataFieldInfo.type === 'NONE') {
+      throw this.createGeneralValidationError(
+        newDatasetMetadataFieldAndValueInfo,
+        'Expecting child fields, not a string.',
+      );
+    }
+    this.validateFieldValue(newDatasetMetadataFieldAndValueInfo);
+  }
+
+  private validateFieldValue(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo) {
+    const metadataFieldInfo = newDatasetMetadataFieldAndValueInfo.metadataFieldInfo;
+    if (metadataFieldInfo.isControlledVocabulary) {
+      this.validateControlledVocabularyFieldValue(newDatasetMetadataFieldAndValueInfo);
+    }
+
+    if (metadataFieldInfo.type == 'DATE') {
+      this.validateDateFieldValue(newDatasetMetadataFieldAndValueInfo);
+    }
+
+    if (metadataFieldInfo.childMetadataFields != undefined) {
+      this.validateChildMetadataFieldValues(newDatasetMetadataFieldAndValueInfo);
+    }
+  }
+
+  private validateControlledVocabularyFieldValue(
+    newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo,
+  ) {
+    if (
+      !newDatasetMetadataFieldAndValueInfo.metadataFieldInfo.controlledVocabularyValues.includes(
+        newDatasetMetadataFieldAndValueInfo.metadataFieldValue as string,
+      )
+    ) {
+      throw new ControlledVocabularyFieldError(
+        newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+        newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+        newDatasetMetadataFieldAndValueInfo.metadataParentFieldKey,
+        newDatasetMetadataFieldAndValueInfo.metadataFieldPosition,
+      );
+    }
+  }
+
+  private validateDateFieldValue(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo) {
+    const dateFormatRegex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!dateFormatRegex.test(newDatasetMetadataFieldAndValueInfo.metadataFieldValue as string)) {
+      throw new DateFormatFieldError(
+        newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+        newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+        newDatasetMetadataFieldAndValueInfo.metadataParentFieldKey,
+        newDatasetMetadataFieldAndValueInfo.metadataFieldPosition,
+      );
+    }
+  }
+
+  private validateChildMetadataFieldValues(newDatasetMetadataFieldAndValueInfo: NewDatasetMetadataFieldAndValueInfo) {
+    const metadataFieldInfo = newDatasetMetadataFieldAndValueInfo.metadataFieldInfo;
+    const childMetadataFieldKeys = Object.keys(metadataFieldInfo.childMetadataFields);
+    const metadataFieldValidator = new MetadataFieldValidator(this, new MultipleMetadataFieldValidator(this));
+    for (const childMetadataFieldKey of childMetadataFieldKeys) {
+      const childMetadataFieldInfo = metadataFieldInfo.childMetadataFields[childMetadataFieldKey];
+      metadataFieldValidator.validate({
+        metadataFieldInfo: childMetadataFieldInfo,
+        metadataFieldKey: childMetadataFieldKey,
+        metadataFieldValue: (
+          newDatasetMetadataFieldAndValueInfo.metadataFieldValue as NewDatasetMetadataChildFieldValueDTO
+        )[childMetadataFieldKey],
+        metadataBlockName: newDatasetMetadataFieldAndValueInfo.metadataBlockName,
+        metadataParentFieldKey: newDatasetMetadataFieldAndValueInfo.metadataFieldKey,
+        metadataFieldPosition: newDatasetMetadataFieldAndValueInfo.metadataFieldPosition,
+      });
+    }
+  }
+}

src/datasets/domain/useCases/validators/errors/ControlledVocabularyFieldError.ts

@@ -0,0 +1,18 @@
+import { FieldValidationError } from './FieldValidationError';
+
+export class ControlledVocabularyFieldError extends FieldValidationError {
+  constructor(
+    metadataFieldName: string,
+    citationBlockName: string,
+    parentMetadataFieldName?: string,
+    fieldPosition?: number,
+  ) {
+    super(
+      metadataFieldName,
+      citationBlockName,
+      parentMetadataFieldName,
+      fieldPosition,
+      'The field does not have a valid controlled vocabulary value.',
+    );
+  }
+}