add use cases for editing template to TemplatesRepository.ts

src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO.ts

@@ -0,0 +1,6 @@
+import { CustomTerms } from '../../../datasets/domain/models/Dataset'
+
+export interface UpdateTemplateLicenseTermsDTO {
+  name?: string
+  customTerms?: CustomTerms
+}

src/templates/domain/dtos/UpdateTemplateMetadataDTO.ts

@@ -0,0 +1,7 @@
+import { TemplateFieldDTO, TemplateInstructionDTO } from './CreateTemplateDTO'
+
+export interface UpdateTemplateMetadataDTO {
+  name?: string
+  fields?: TemplateFieldDTO[]
+  instructions?: TemplateInstructionDTO[]
+}

src/templates/domain/repositories/ITemplatesRepository.ts

@@ -1,8 +1,21 @@
 import { CreateTemplateDTO } from '../dtos/CreateTemplateDTO'
+import { UpdateTemplateLicenseTermsDTO } from '../dtos/UpdateTemplateLicenseTermsDTO'
+import { UpdateTemplateMetadataDTO } from '../dtos/UpdateTemplateMetadataDTO'
 import { Template } from '../models/Template'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
 
 export interface ITemplatesRepository {
   createTemplate(collectionIdOrAlias: number | string, template: CreateTemplateDTO): Promise<void>
+  updateTemplateMetadata(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace?: boolean
+  ): Promise<void>
+  updateTemplateLicenseTerms(
+    templateId: number,
+    payload: UpdateTemplateLicenseTermsDTO
+  ): Promise<void>
+  updateTemplateTermsOfAccess(templateId: number, termsOfAccess: TermsOfAccess): Promise<void>
   getTemplate(templateId: number): Promise<Template>
   getTemplatesByCollectionId(collectionIdOrAlias: number | string): Promise<Template[]>
   deleteTemplate(templateId: number): Promise<void>

src/templates/domain/useCases/UpdateTemplateLicenseTerms.ts

@@ -0,0 +1,15 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { UpdateTemplateLicenseTermsDTO } from '../dtos/UpdateTemplateLicenseTermsDTO'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateLicenseTerms implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(templateId: number, payload: UpdateTemplateLicenseTermsDTO): Promise<void> {
+    return await this.templatesRepository.updateTemplateLicenseTerms(templateId, payload)
+  }
+}

src/templates/domain/useCases/UpdateTemplateMetadata.ts

@@ -0,0 +1,19 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { UpdateTemplateMetadataDTO } from '../dtos/UpdateTemplateMetadataDTO'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateMetadata implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace = false
+  ): Promise<void> {
+    return await this.templatesRepository.updateTemplateMetadata(templateId, payload, replace)
+  }
+}

src/templates/domain/useCases/UpdateTemplateTermsOfAccess.ts

@@ -0,0 +1,15 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateTermsOfAccess implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(templateId: number, termsOfAccess: TermsOfAccess): Promise<void> {
+    return await this.templatesRepository.updateTemplateTermsOfAccess(templateId, termsOfAccess)
+  }
+}

src/templates/index.ts

@@ -3,15 +3,29 @@ import { CreateTemplate } from './domain/useCases/CreateTemplate'
 import { DeleteTemplate } from './domain/useCases/DeleteTemplate'
 import { GetTemplatesByCollectionId } from './domain/useCases/GetTemplatesByCollectionId'
 import { GetTemplate } from './domain/useCases/GetTemplate'
+import { UpdateTemplateMetadata } from './domain/useCases/UpdateTemplateMetadata'
+import { UpdateTemplateLicenseTerms } from './domain/useCases/UpdateTemplateLicenseTerms'
+import { UpdateTemplateTermsOfAccess } from './domain/useCases/UpdateTemplateTermsOfAccess'
 
 const templatesRepository = new TemplatesRepository()
 
 const createTemplate = new CreateTemplate(templatesRepository)
 const deleteTemplate = new DeleteTemplate(templatesRepository)
 const getTemplatesByCollectionId = new GetTemplatesByCollectionId(templatesRepository)
 const getTemplate = new GetTemplate(templatesRepository)
+const updateTemplateMetadata = new UpdateTemplateMetadata(templatesRepository)
+const updateTemplateLicenseTerms = new UpdateTemplateLicenseTerms(templatesRepository)
+const updateTemplateTermsOfAccess = new UpdateTemplateTermsOfAccess(templatesRepository)
 
-export { createTemplate, deleteTemplate, getTemplatesByCollectionId, getTemplate }
+export {
+  createTemplate,
+  deleteTemplate,
+  getTemplatesByCollectionId,
+  getTemplate,
+  updateTemplateMetadata,
+  updateTemplateLicenseTerms,
+  updateTemplateTermsOfAccess
+}
 export {
   CreateTemplateDTO,
   TemplateFieldDTO,
@@ -21,4 +35,6 @@ export {
   TemplateFieldValueControlledVocabularyDTO,
   TemplateInstructionDTO
 } from './domain/dtos/CreateTemplateDTO'
+export { UpdateTemplateMetadataDTO } from './domain/dtos/UpdateTemplateMetadataDTO'
+export { UpdateTemplateLicenseTermsDTO } from './domain/dtos/UpdateTemplateLicenseTermsDTO'
 export { Template, TemplateInstruction } from './domain/models/Template'

src/templates/infra/repositories/TemplatesRepository.ts

@@ -1,9 +1,13 @@
 import { AxiosResponse } from 'axios'
 import { ApiRepository } from '../../../core/infra/repositories/ApiRepository'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
 import { CreateTemplateDTO } from '../../domain/dtos/CreateTemplateDTO'
+import { UpdateTemplateLicenseTermsDTO } from '../../domain/dtos/UpdateTemplateLicenseTermsDTO'
+import { UpdateTemplateMetadataDTO } from '../../domain/dtos/UpdateTemplateMetadataDTO'
 import { Template } from '../../domain/models/Template'
 import { ITemplatesRepository } from '../../domain/repositories/ITemplatesRepository'
 import { TemplatePayload } from './transformers/TemplatePayload'
+import { transformTemplateTermsOfAccessToUpdatePayload } from './transformers/templateTermsOfAccessTransformers'
 import {
   transformTemplatePayloadToTemplate,
   transformTemplatePayloadsToTemplates
@@ -26,6 +30,32 @@ export class TemplatesRepository extends ApiRepository implements ITemplatesRepo
       })
   }
 
+  public async updateTemplateMetadata(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace = false
+  ): Promise<void> {
+    return this.updateTemplate(templateId, 'metadata', payload, { replace })
+  }
+
+  public async updateTemplateLicenseTerms(
+    templateId: number,
+    payload: UpdateTemplateLicenseTermsDTO
+  ): Promise<void> {
+    return this.updateTemplate(templateId, 'licenseTerms', payload)
+  }
+
+  public async updateTemplateTermsOfAccess(
+    templateId: number,
+    termsOfAccess: TermsOfAccess
+  ): Promise<void> {
+    return this.updateTemplate(
+      templateId,
+      'access',
+      transformTemplateTermsOfAccessToUpdatePayload(termsOfAccess)
+    )
+  }
+
   public async getTemplate(templateId: number): Promise<Template> {
     return this.doGet(`/dataverses/${templateId}/template`, true)
       .then((response: AxiosResponse<{ data: TemplatePayload }>) =>
@@ -55,4 +85,17 @@ export class TemplatesRepository extends ApiRepository implements ITemplatesRepo
         throw error
       })
   }
+
+  private async updateTemplate(
+    templateId: number,
+    operation: 'metadata' | 'licenseTerms' | 'access',
+    payload: object,
+    queryParams: object = {}
+  ): Promise<void> {
+    return this.doPut(`/dataverses/${templateId}/${operation}`, payload, queryParams)
+      .then(() => undefined)
+      .catch((error) => {
+        throw error
+      })
+  }
 }

src/templates/infra/repositories/transformers/templateTermsOfAccessTransformers.ts

@@ -0,0 +1,30 @@
+import { TermsOfAccess } from '../../../../datasets/domain/models/Dataset'
+
+export const transformTemplateTermsOfAccessToUpdatePayload = (
+  terms: TermsOfAccess & { termsOfAccess?: string }
+) => {
+  const {
+    fileAccessRequest,
+    dataAccessPlace,
+    originalArchive,
+    availabilityStatus,
+    contactForAccess,
+    sizeOfCollection,
+    studyCompletion
+  } = terms
+
+  const termsOfAccess = terms.termsOfAccess ?? terms.termsOfAccessForRestrictedFiles
+
+  return {
+    customTermsOfAccess: {
+      fileAccessRequest,
+      termsOfAccess,
+      dataAccessPlace,
+      originalArchive,
+      availabilityStatus,
+      contactForAccess,
+      sizeOfCollection,
+      studyCompletion
+    }
+  }
+}

test/environment/.env

@@ -1,6 +1,6 @@
 POSTGRES_VERSION=17
 DATAVERSE_DB_USER=dataverse
 SOLR_VERSION=9.8.0
-DATAVERSE_IMAGE_REGISTRY=docker.io
-DATAVERSE_IMAGE_TAG=unstable
+DATAVERSE_IMAGE_REGISTRY=ghcr.io
+DATAVERSE_IMAGE_TAG=11912-edit-template-api
 DATAVERSE_BOOTSTRAP_TIMEOUT=5m

test/functional/templates/UpdateTemplateLicenseTerms.test.ts

@@ -0,0 +1,42 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { getTemplatesByCollectionId, updateTemplateLicenseTerms } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateLicenseTerms.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template terms of use using custom terms', async () => {
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    await updateTemplateLicenseTerms.execute(createdTemplate.id, {
+      customTerms: {
+        termsOfUse: 'Updated template terms of use'
+      }
+    })
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.termsOfUse.customTerms?.termsOfUse).toBe(
+      'Updated template terms of use'
+    )
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})

test/functional/templates/UpdateTemplateMetadata.test.ts

@@ -0,0 +1,76 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { updateTemplateMetadata } from '../../../src/templates'
+import { UpdateTemplateMetadataDTO } from '../../../src/templates/domain/dtos/UpdateTemplateMetadataDTO'
+import { MetadataFieldTypeClass } from '../../../src/metadataBlocks/domain/models/MetadataBlock'
+import { getTemplatesByCollectionId } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateMetadata.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template name and instructions', async () => {
+    const updatedTemplateName = `template-metadata-updated-${Date.now()}`
+
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    const updatePayload: UpdateTemplateMetadataDTO = {
+      name: updatedTemplateName,
+      fields: [
+        {
+          typeName: 'author',
+          typeClass: MetadataFieldTypeClass.Compound,
+          multiple: true,
+          value: [
+            {
+              authorName: {
+                typeName: 'authorName',
+                typeClass: MetadataFieldTypeClass.Primitive,
+                value: 'Kraffmiller, Ellen'
+              },
+              authorAffiliation: {
+                typeName: 'authorIdentifierScheme',
+                typeClass: MetadataFieldTypeClass.Primitive,
+                value: 'ORCID'
+              }
+            }
+          ]
+        }
+      ],
+      instructions: [
+        {
+          instructionField: 'author',
+          instructionText: 'Updated author instructions'
+        }
+      ]
+    }
+
+    await updateTemplateMetadata.execute(createdTemplate.id, updatePayload, true)
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.name).toBe(updatedTemplateName)
+    expect(updatedTemplate?.instructions).toContainEqual({
+      instructionField: 'author',
+      instructionText: 'Updated author instructions'
+    })
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})

test/functional/templates/UpdateTemplateTermsOfAccess.test.ts

@@ -0,0 +1,42 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { getTemplatesByCollectionId, updateTemplateTermsOfAccess } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateTermsOfAccess.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template terms of access', async () => {
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    await updateTemplateTermsOfAccess.execute(createdTemplate.id, {
+      fileAccessRequest: true,
+      termsOfAccessForRestrictedFiles: 'Restricted access only'
+    })
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.termsOfUse.termsOfAccess.fileAccessRequest).toBe(true)
+    expect(updatedTemplate?.termsOfUse.termsOfAccess.termsOfAccessForRestrictedFiles).toBe(
+      'Restricted access only'
+    )
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})