[
  {
    "productID": 1,
    "terms": [
      {
        "contractPerformance": "PreDeal",
        "businessDayConvention": "SCF",
        "contractType": "ANN",
        "statusDate": "2023-07-31T06:30:00",
        "contractRole": "RPA",
        "creatorID": "a43c22ed-27df-4324-a453-3e7707c9b82d",
        "counterpartyID": "e548956c-1f3b-493e-952e-00cdcca6b599",
        "contractID": "a6b799db-c448-4aad-9382-3ae47383f5b2",
        "cycleAnchorDateOfInterestPayment": "2023-09-01T06:30:00",
        "cycleOfInterestPayment": "P1ML1",
        "nominalInterestRate": 0.02,
        "dayCountConvention": "30E360",
        "currency": "CHF",
        "contractDealDate": "2023-07-31T06:30:00",
        "initialExchangeDate": "2023-08-01T06:30:00",
        "maturityDate": "2024-08-01T06:30:00",
        "notionalPrincipal": 50000,
        "cycleAnchorDateOfPrincipalRedemption": "2023-09-01T06:30:00",
        "cycleOfPrincipalRedemption": "P1ML1",
        "nextPrincipalRedemptionPayment": 2312.7827499791606
      }
    ],
    "paymentDetails": {
      "recordCreatorPaymentChannelID": "e03c2694-71f8-48e0-a68d-8328630fd0c5",
      "counterpartyPaymentChannelID": "6963c361-1c1f-40b6-b8b4-47f604be36ef"
    },
    "selection": {
      "productCategory": "Loans",
      "department": "DeptB",
      "profitCenter": "A",
      "tenure": "12M"
    }
  }
]

{
  "status": 201,
  "message": "Success",
  "data": [
    {
      "productID": 1,
      "terms": [
        {
          "contractPerformance": "PreDeal",
          "businessDayConvention": "SCF",
          "contractType": "ANN",
          "statusDate": "2023-07-31T06:30:00",
          "contractRole": "RPA",
          "creatorID": "a43c22ed-27df-4324-a453-3e7707c9b82d",
          "counterpartyID": "e548956c-1f3b-493e-952e-00cdcca6b599",
          "contractID": "a6b799db-c448-4aad-9382-3ae47383f5b2",
          "cycleAnchorDateOfInterestPayment": "2023-09-01T06:30:00",
          "cycleOfInterestPayment": "P1ML1",
          "nominalInterestRate": 0.02,
          "dayCountConvention": "30E360",
          "currency": "CHF",
          "contractDealDate": "2023-07-31T06:30:00",
          "initialExchangeDate": "2023-08-01T06:30:00",
          "maturityDate": "2024-08-01T06:30:00",
          "notionalPrincipal": 50000,
          "cycleAnchorDateOfPrincipalRedemption": "2023-09-01T06:30:00",
          "cycleOfPrincipalRedemption": "P1ML1",
          "nextPrincipalRedemptionPayment": 2312.7827499791606
        }
      ],
      "paymentDetails": {
        "recordCreatorPaymentChannelID": "e03c2694-71f8-48e0-a68d-8328630fd0c5",
        "counterpartyPaymentChannelID": "6963c361-1c1f-40b6-b8b4-47f604be36ef"
      },
      "selection": {
        "productCategory": "Loans",
        "department": "DeptB",
        "profitCenter": "A",
        "tenure": "12M"
      }
    }
  ]
}

{
  "status": 400,
  "message": "Contract creation failed",
  "data": [
    {
      "contractUUID": null,
      "contractID": null,
      "errors": [
        {
          "Product data": "Specified result type [java.lang.String] did not match Query selection type [com.solitx.contracts.entity.Terms] - multiple selections: use Tuple or array"
        }
      ]
    }
  ]
}

public List<ContractsResponseDto> createContract(List<CreateContractsDto> contractDataList) {
		List<ContractsResponseDto> contractResponseDtoList = new ArrayList<>();
		ContractsResponseDto contractResponseDto;
		for (CreateContractsDto createContractDto : contractDataList) { (1)
			// Validate the contract data using the createContractValidator. (2)
			contractResponseDto = createContractValidator.validateContractData(createContractDto);
			if (contractResponseDto.getErrors().isEmpty()) {
				// If there are no validation errors, create the contract.
				contractResponseDto = contractsWorker.createContract(createContractDto); (3)
			}
			contractResponseDtoList.add(contractResponseDto); (4)
		}
		return contractResponseDtoList; (5)
	}

{
  "selection": {
    "productCategory": "Loans",
    "department": "DeptB",
    "profitCenter": "A",
    "tenure": "12M"
  }
}

// Create a new instance of CreateContractsDto
CreateContractsDto contractDto = new CreateContractsDto();
contractDto.setProductId((long) 1);
contractDto.setTerms(termsList);
contractDto.setPaymentDetails(paymentDetailsMap);
contractDto.setSelection(selectionMap);

public ContractsResponseDto validateContractData(CreateContractsDto createContractDto) {
		// Initialize data structures to store validation errors.
		HashMap<String, Object> createContractErrors = new HashMap<>();
		List<Map<String, Object>> errorList = new ArrayList<>();
		String contractID;

		try {
			// Validate the product associated with the contract.
			Products products = contractsValidator.validateProduct(createContractDto.getProductId()); (1)

			// Validate the contract and product template size.
			contractsValidator.validateContractAndProductTemplateSize(products, createContractDto.getTerms()); (2)

			// Extract contract terms and ID.
			Map<String, Object> contractTerms = createContractDto.getTerms().get(0);
			contractID = String.valueOf(contractTerms.get(Constants.CONTRACTID));

			// Perform selection validation and add any errors to the error list.
			Map<String, Object> selectionValidationErrors = this.contractSelectionValidation(products,
					createContractDto); (3)
			if (!selectionValidationErrors.isEmpty()) {
				errorList.add(selectionValidationErrors);
			}

			// Perform terms validation and add any errors to the error list.
			List<Map<String, Object>> termsValidationErrors = validateContractTerms(products, createContractDto); (4)
			errorList.addAll(termsValidationErrors);

		} catch (Exception e) { (5)
			// If an exception occurs during validation, add an error entry to the error
			// list.
			createContractErrors.put("Product data", e.getMessage());
			errorList.add(createContractErrors);
			return new ContractsResponseDto(null, null, errorList);
		}

		return new ContractsResponseDto(null, contractID, errorList);

	}

@SuppressWarnings("unchecked")
	@Test
	void evaluateContractTest() throws ParseException { (1)
		CreateContractsDto createContractsDto = createContractsDtoList.get(0);
		createContractValidator.validateContractData(createContractsDto);
		final List<Map<String, Object>> productTermsList = (List<Map<String, Object>>) product.getTemplate()
				.get(Constants.TERMS);
		List<Map<String, Object>> contractTermsList = createContractsDto.getTerms();
		Map<String, Object>   selectionMap =  createContractsDto.getSelection();
		contractsHelper.evaluateContractTerms(contractTermsList, productTermsList, selectionMap);
		contracts = contractsWorker.computeContract(product, createContractsDto);
		Terms masterTerms = contracts.getContractTerms().get(0);
		PaymentDetails paymentDetails = contracts.getPaymentDetails();

		Assertions.assertEquals(contracts.getProductID().toString(), product.getProductID().toString());
		Assertions.assertEquals(50000, masterTerms.getNotionalPrincipal().doubleValue(), 0.0);
		Assertions.assertEquals(2312.7827499791606, masterTerms.getNextPrincipalRedemptionPayment().doubleValue(), 0.01);
		Assertions.assertEquals(LocalDateTime.parse("2023-08-01T00:00:00"), masterTerms.getInitialExchangeDate());
		Assertions.assertEquals(LocalDateTime.parse("2023-07-31T00:00:00"), masterTerms.getStatusDate());
		Assertions.assertEquals(profile.getProfileID(), masterTerms.getCounterpartyID());
		Assertions.assertEquals(paymentDetails.getCounterpartyPaymentChannelID(), counterPartyPaymentChannel.getPaymentChannelID());
		Assertions.assertEquals(paymentDetails.getRecordCreatorPaymentChannelID(), recordCreatorPaymentChannel.getPaymentChannelID());

	}

	@Test
	void createContractTest() { (2)

		List<ContractsResponseDto> createContractList = contractServiceImpl.createContract(createContractsDtoList);
		System.out.println("createContractList :"+createContractList);
		String contractUUID = createContractList.get(0).getContractUUID();
		Assertions.assertEquals(contracts.getContractUUID(), UUID.fromString(contractUUID));

	}

/**
	 * Retrieves a contract based on its UUID.
	 *
	 * @param contractUUID The UUID of the contract to retrieve.
	 * @return The Contracts object representing the retrieved contract.
	 * @throws IllegalArgumentException If the contract UUID is invalid.
	 */
	public Contracts validateContractUUID(String contractUUID) {
		// Provides contract information based on contractUUID
		final Optional<Contracts> optionalContract = contractsRepo.findById(UUID.fromString(contractUUID)); (1)

		Assert.isTrue(optionalContract.isPresent(), "Invalid contractUUID " + contractUUID);
		return optionalContract.get(); (2)

	}

/**
	 * Validates the status of a contract.
	 *
	 * @param contract The Contracts object representing the contract data to
	 *                 validate.
	 * @throws IllegalArgumentException If the contract status is not "PreDeal".
	 */
	public void validateContractStatus(Contracts contract) {
		final Terms term = contract.getContractTerms().get(0);
		Assert.isTrue(term.getContractPerformance().equals("PreDeal"), "Contract already executed"); (3)
	}

@Test
	void computeContractTest() throws ContractsException { (1)

		List<BusinessEvents> eventsList = contractServiceImpl
				.computeContract(contracts.getContractUUID());
		Assertions.assertEquals(25, eventsList.size());

	}

	@TestFactory
	Stream<DynamicTest> computeContractScheduleTest() throws IOException, ContractsException { (2)
		List<DynamicTest> dynamicTests = new ArrayList<>();

		List<BusinessEventsDto> expectedEventsList = MappingUtils
				.mapToEventsList("./src/test/resources/events/events-contract-ann.json");

		List<BusinessEvents> computedEventsList = contractServiceImpl
				.computeContract(contracts.getContractUUID());

		Assertions.assertEquals(expectedEventsList.size(), computedEventsList.size(), "Number of events should match.");

		for (int i = 0; i < expectedEventsList.size(); i++) {
			BusinessEventsDto expectedEvent = expectedEventsList.get(i);
			BusinessEvents computedEvent = computedEventsList.get(i);

			dynamicTests.add(contractUtils.createDynamicTest(expectedEvent, computedEvent));
		}

		return dynamicTests.stream();
	}

public List<BusinessEvents> executeContract(String contractUUID) throws ContractsException

contractsValidator.validateContract(contractUUID); (1)

public List<BusinessEvents> executeContract(String contractUUID) throws ContractsException {
		log.info("Contract execution started by UserId : {}, ContractUUID : {}", usersHelper.getUserID(), contractUUID);
		List<BusinessEvents> businessEvents;
		Contracts contract = contractsServiceRepo.findById(UUID.fromString(contractUUID))
				.orElseThrow(() -> new IllegalArgumentException(CONTRACT_ERROR)); (2)
		Terms contractTerms = contract.getContractTerms().get(0);
		// Set the contract status to "PF".
		contractTerms.setContractPerformance("PF"); (3)
		try {

			// Save the contract schedule.
			businessEvents = saveContractSchedule(contract); (4)

			// Create a Metaco account for the contract.
			contractsHelper.createMetacoAccount(contract); (5)

			// Update contract payment channels(Linking contract to paymentChannel).
			updateContractPaymentChannel(contract); (6)

			contract.setExecutedBy(usersHelper.getUserID());
			contract.setTimeStamp(UtilityHelper.dateTime());
			contractsServiceRepo.save(contract); (7)

			// Send a request to Kafka for contract execution.
			sendKafkaContractExecutedEvent(contract); (8)

			log.info("Contract execution finished by UserId : {}, ContractUUID : {}", usersHelper.getUserID(),
					contractUUID);

		} catch (Exception e) {
			throw new ContractsException(e.getMessage()); (9)
		}

		return businessEvents;
	}

/**
	 * Retrieves a contract based on its UUID.
	 *
	 * @param contractUUID The UUID of the contract to retrieve.
	 * @return The Contracts object representing the retrieved contract.
	 * @throws IllegalArgumentException If the contract UUID is invalid.
	 */
	public Contracts validateContractUUID(String contractUUID) {
		// Provides contract information based on contractUUID
		final Optional<Contracts> optionalContract = contractsRepo.findById(UUID.fromString(contractUUID)); (1)

		Assert.isTrue(optionalContract.isPresent(), "Invalid contractUUID " + contractUUID);
		return optionalContract.get(); (2)

	}

/**
	 * Validates the status of a contract.
	 *
	 * @param contract The Contracts object representing the contract data to
	 *                 validate.
	 * @throws IllegalArgumentException If the contract status is not "PreDeal".
	 */
	public void validateContractStatus(Contracts contract) {
		final Terms term = contract.getContractTerms().get(0);
		Assert.isTrue(term.getContractPerformance().equals("PreDeal"), "Contract already executed"); (3)
	}

	@Test
	void executeContractTest() throws ContractsException { (1)

		List<BusinessEvents> executeContract = contractServiceImpl.executeContract(contracts.getContractUUID());
		System.err.println("gfjfg "+executeContract);
		Contracts contracts1 = contractsRepo.findById(contracts.getContractUUID()).get();
		String contractStatus = contracts1.getContractTerms().get(0).getContractPerformance();

		Assertions.assertEquals("PF", contractStatus);

	}

	@TestFactory
	Stream<DynamicTest> executeContractAfterTest() throws IOException, ContractsException { (2)
		List<DynamicTest> dynamicTests = new ArrayList<>();

		List<BusinessEventsDto> expectedEventsList = MappingUtils
				.mapToEventsList("./src/test/resources/events/events-contract-ann.json");

		List<BusinessEvents> computedEventsList = contractServiceImpl
				.executeContract(contracts.getContractUUID());

		Assertions.assertEquals(expectedEventsList.size(), computedEventsList.size(), "Number of events should match.");

		for (int i = 0; i < expectedEventsList.size(); i++) {
			int eventIndex = i;
			BusinessEventsDto expectedEvent = expectedEventsList.get(eventIndex);
			BusinessEvents computedEvent = computedEventsList.get(eventIndex);

			dynamicTests.add(contractUtils.createDynamicTest(expectedEvent, computedEvent));
		}

		return dynamicTests.stream();
	}

@Setter
@Getter
@NoArgsConstructor
@ToString
public class ContractsFilterDto {

	private UUID contractUUID;

	private LocalDateTime timestamp;

	private Long productID;

}

[
  {
    "contractUUID": "28ee9eb5-e4b9-491c-98ce-a451abbedae9",
    "productID": 4,
    "terms": [
      {
        "initialExchangeDate": "2023-01-02T00:00:00",
        "notionalPrincipal": "20000"
      }
    ],
    "selection": {
      "remainingValue": 5000,
      "tenure": "18M"
    }
  }
]

{
    "status": 200,
    "message": "Contracts updated successfully",
    "data": [
        {
            "contractUUID": "28ee9eb5-e4b9-491c-98ce-a451abbedae9",
            "contractID": "9ec8997e-70b5-4fa1-82fe-56cbc0fc8149",
            "errors": []
        }
    ]
}

{
  "status": 400,
  "message": "Invalid ContractUUID 28ee9eb5-e4b9-491c-98ce-a451abbedae9",
  "data": "28ee9eb5-e4b9-491c-98ce-a451abbedae9"
}

public List<ContractsResponseDto> updateContract(List<UpdateContractDto> contractDataList)

public List<ContractsResponseDto> updateContract(List<UpdateContractDto> contractDataList) {
		List<ContractsResponseDto> contractResponseDtoList = new ArrayList<>();
		ContractsResponseDto contractResponseDto;

		for (UpdateContractDto updateContractData : contractDataList) { (1)
			// Validate the contract data using the updateContractValidator.
			contractResponseDto = updateContractValidator.validateContractData(updateContractData); (2)

			// If there are no validation errors, proceed with the contract update.
			if (contractResponseDto.getErrors().isEmpty()) {
				contractResponseDto = contractsWorker.updateContract(updateContractData); (3)
			}
			contractResponseDtoList.add(contractResponseDto);
		}
		return contractResponseDtoList; (4)
	}

public ContractsResponseDto validateContractData(UpdateContractDto updateContractData) {
		String contractID = null;
		HashMap<String, Object> contractErrors = new HashMap<>();
		List<Map<String, Object>> errorList = new ArrayList<>();

		try {
			// Validate the contract UUID by calling the contractsValidator.
			contractsValidator.validateContract(updateContractData.getContractUUID()); (1)

			// If there are no errors related to the contract UUID, proceed with further
			// validation.
			return validateContractTerms(updateContractData); (2)

		} catch (Exception e) { (3)
			contractErrors.put("Contract data", e.getMessage());
			errorList.add(contractErrors);
			return new ContractsResponseDto(null, contractID, errorList);
		}

	}

@Test
	void updateContractBeforeTest() { (1)

		Terms masterTerms = contracts.getContractTerms().get(0);
		PaymentDetails paymentDetails = contracts.getPaymentDetails();

		System.err.println("paymentDetails"+paymentDetails);
		BigDecimal NotionalPrincipal = new BigDecimal("50000.0");
		BigDecimal NextPrincipalRedemptionPayment = new BigDecimal("2312.7827499791606");
		Assertions.assertEquals(contracts.getProductID(), 1L);
		Assertions.assertEquals(NotionalPrincipal, masterTerms.getNotionalPrincipal(), "0.0");
		Assertions.assertEquals(NextPrincipalRedemptionPayment, masterTerms.getNextPrincipalRedemptionPayment(), "0.01");
		Assertions.assertEquals(LocalDateTime.parse("2023-08-01T00:00:00"), masterTerms.getInitialExchangeDate());
		Assertions.assertEquals(LocalDateTime.parse("2023-07-31T00:00:00"), masterTerms.getStatusDate());
		Assertions.assertEquals(profile.getProfileID(), masterTerms.getCounterpartyID());
		Assertions.assertEquals(paymentDetails.getCounterpartyPaymentChannelID(),
				counterPartyPaymentChannel.getPaymentChannelID());
		Assertions.assertEquals(paymentDetails.getRecordCreatorPaymentChannelID(),
				recordCreatorPaymentChannel.getPaymentChannelID());

	}

	@Test
	void updateContractAfterTest() { (2)
		when(usersHelper.getUserID()).thenReturn(UUID.fromString("a43c22ed-27df-4324-a453-3e7707c9b82d"));
		when(productRepo.findById(product.getProductID())).thenReturn(Optional.of(product));
		BigDecimal NotionalPrincipal = new BigDecimal("47771.0");
		BigDecimal NextPrincipalRedemptionPayment = new BigDecimal("2312.7827499791606");
		Map<String, Object> termsMap = new HashMap<>();
		List<Map<String, Object>> termsList = new ArrayList<>();
		List<UpdateContractDto> updateContractDtoList = new ArrayList<>();
		termsMap.put("initialExchangeDate", "2023-01-01T00:00:00");
		termsMap.put("notionalPrincipal", "47771.0");
		termsMap.put("remainingValue", "2000");
		termsMap.put("remainingValue", "2000");

		UpdateContractDto updateContractDto = new UpdateContractDto();
		contracts.setContractUUID(contractUUID);
		updateContractDto.setContractUUID(contracts.getContractUUID());


		updateContractDto.setProductID(contracts.getProductID());
		termsList.add(termsMap);
		updateContractDto.setTerms(termsList);
		updateContractDtoList.add(updateContractDto);


		List<ContractsResponseDto> updateContractsResponse = contractServiceImpl.updateContract(updateContractDtoList);

		Contracts contracts2 = contractsRepo.findById(UUID.fromString(updateContractsResponse.get(0).getContractUUID()))
				.get();
		Terms masterTerms = contracts2.getContractTerms().get(0);
		PaymentDetails paymentDetails = contracts2.getPaymentDetails();

		Assertions.assertEquals(contracts2.getProductID(), 1L);
		Assertions.assertEquals(NotionalPrincipal, masterTerms.getNotionalPrincipal(), "0.0");
		Assertions.assertEquals(NextPrincipalRedemptionPayment, masterTerms.getNextPrincipalRedemptionPayment(), "0.01");
		Assertions.assertEquals(LocalDateTime.parse("2023-01-01T00:00"), masterTerms.getInitialExchangeDate());
		Assertions.assertEquals(LocalDateTime.parse("2022-12-31T00:00"), masterTerms.getStatusDate());
		Assertions.assertEquals(profile.getProfileID(), masterTerms.getCounterpartyID());

		Assertions.assertEquals(paymentDetails.getCounterpartyPaymentChannelID(),
				counterPartyPaymentChannel.getPaymentChannelID());
		Assertions.assertEquals(paymentDetails.getRecordCreatorPaymentChannelID(),
				recordCreatorPaymentChannel.getPaymentChannelID());

	}

{
  "notionalPrincipal": 60000
}

{
  "status": 200,
  "message": "Contract Rescheduled",
  "data": "36c7d13e-55dc-4b89-a1b8-98f1f8716698"
}

{
  "status": 400,
  "message": "Invalid contractUUID",
  "data": "36c7d13e-55dc-4b89-a1b8-98f1f8716698"
}

public void updateExecutedContract(String contractUUID, TermsDto updationData)
    throws ContractsException, IllegalAccessException, ParseException

public void updateExecutedContract(UUID contractUUID, TermsDto updationData)
			throws ContractsException, IllegalAccessException, ParseException {

		// Validate the executed contract data before updating.
		updateContractValidator.validateExecutedContractData(contractUUID, updationData); (1)

		// Perform the actual contract update.
		contractsWorker.updateExecutedContract(contractUUID, updationData); (2)

	}


public void updateExecutedContract(UUID contractUUID, TermsDto updationData)
			throws IllegalAccessException, ParseException {
		log.info("Contract update started by UserId : {}, ContractUUID : {}, Request : {}", usersHelper.getUserID(),
				contractUUID, updationData);
		// Retrieve the executed contract by its UUID.
		Contracts contract = contractsServiceRepo.findById(contractUUID)
				.orElseThrow(() -> new IllegalArgumentException(CONTRACT_ERROR)); (3)

		// Save a history snapshot of the contract before updating.
		saveContractHistory(contract); (4)

		// Update the contract data based on the provided data.
		updateContractData(contract, updationData); (5)

		// Reschedule events associated with the updated contract.
		rescheduleEvents(contract); (6)
		contractsServiceRepo.save(contract); (7)

		log.info("Contract update finished by UserId : {}, ContractUUID : {}", usersHelper.getUserID(), contractUUID);
	}

public void validateExecutedContractData(UUID contractUUID, TermsDto updationContractTerms)
			throws ContractsException {
		// Validate the contract UUID and retrieve the contract.
		Contracts contract = contractsValidator.validateContractUUID(contractUUID); (1)
		Terms masterContractTerms = contract.getContractTerms().get(0);

		// Validate the updated contract terms against the master contract terms.
		validateContractUpdateTerms(masterContractTerms, updationContractTerms); (2)
	}

@TestFactory
	Stream<DynamicTest> updatePFContractBeforeTest() throws IOException { (1)
		List<DynamicTest> dynamicTests = new ArrayList<>();

		List<BusinessEventsDto> expectedEventsList = MappingUtils
				.mapToEventsList("./src/test/resources/events/events-contract-ann.json");

		List<BusinessEvents> computedEventsList = eventsRepo.findByContractUUID(contracts);
		Assertions.assertEquals(expectedEventsList.size(), computedEventsList.size(), "Number of events should match.");

		for (int i = 0; i < expectedEventsList.size(); i++) {
			BusinessEventsDto expectedEvent = expectedEventsList.get(i);
			BusinessEvents computedEvent = computedEventsList.get(i);

			dynamicTests.add(contractUtils.createDynamicTest(expectedEvent, computedEvent));
		}

		return dynamicTests.stream();
	}

	@TestFactory
	Stream<DynamicTest> updatePFContractAfterTest()
			throws IOException, ParseException, IllegalAccessException, ContractsException, InterruptedException { (2)
		List<DynamicTest> dynamicTests = new ArrayList<>();

		List<BusinessEventsDto> expectedEventsList = MappingUtils
				.mapToEventsList("./src/test/resources/events/updated-events-contract-ann.json");

		updatePFContractTest();
		List<BusinessEvents> computedEventsList = eventsRepo.findByContractUUID(contracts);

		Assertions.assertEquals(expectedEventsList.size(), computedEventsList.size(), "Number of events should match.");

		for (int i = 0; i < expectedEventsList.size(); i++) {
			BusinessEventsDto expectedEvent = expectedEventsList.get(i);
			BusinessEvents computedEvent = computedEventsList.get(i);

			dynamicTests.add(contractUtils.createDynamicTest(expectedEvent, computedEvent));
		}

		return dynamicTests.stream();
	}

{
  "time": "2024-02-23T06:30",
  "type": "TP",
  "value": 5000
}

{
  "status": 200,
  "message": "Event created successfully",
  "data": "36c7d13e-55dc-4b89-a1b8-98f1f8716698"
}

{
  "status": 400,
  "message": "Invalid contractUUID 36c7d13e-55dc-4b89-a1b8-98f1f8716698",
  "data": null
}

		BusinessEvents businessEvents = new BusinessEvents();
		businessEvents.setEventTime(UtilityHelper.toLocalDateTime(dynamicEventData.getTime()).toString());
		businessEvents.setEventType(dynamicEventData.getType());
		businessEvents.setEventBody(determineEventBodyForDynamicEvent(contract, term, dynamicEventData));
		businessEvents.setStatus("scheduled");
		businessEvents.setExecutionType(determineExecutionTypeForDynamicEvent(dynamicEventData.getType()));
		businessEvents.setUserID(term.getCreatorID());
		businessEvents.setCreatedBy(contract.getCreatedBy());
		businessEvents.setContractUUID(contract);
		businessEvents.setContractID(contractId);

public Contracts validateDynamicEventData(DynamicEventDto dynamicEventData, UUID contractUUID) {
		Contracts contract = validateContractUUID(contractUUID); (1)

		validateEventDateWithMaturityDate(dynamicEventData, contract); (2)

		final Integer futureProcessed = eventsRepo.countByContractUUIDAndStatusAndEventTimeGreaterThan(contract,
				"processed", dynamicEventData.getTime());
		// Check if there are any future events already processed. If so, throw an
		// exception.
		Assert.isTrue(futureProcessed == 0, "Future events already processed"); (3)
		return contract;
	}

@Test
	void createDynamicEventTest() throws ContractsException { (1)

		Response<UUID> dynamicEventResponseDto = contractServiceImpl.createDynamicEvent(dynamicEventDto,
				contractUUID);
		BusinessEvents dynamicEvent = eventsHelper.createDynamicEvent(dynamicEventDto, contract);
		BigDecimal eventValue = dynamicEvent.getValue() ;
		UUID creditPaymentChannel = dynamicEvent.getCreditPaymentChannelID();
		UUID debitPaymentChannel = dynamicEvent.getDebitPaymentChannelID();

		PaymentDetails paymentDetails = contract.getPaymentDetails();

		assertEquals("Event created successfully", dynamicEventResponseDto.getMessage());
		assertEquals(value.doubleValue(), eventValue.doubleValue(), 0.0);
		assertEquals(paymentDetails.getCounterpartyPaymentChannelID(), creditPaymentChannel);
		assertEquals(paymentDetails.getRecordCreatorPaymentChannelID(), debitPaymentChannel);

	}