{
  "selection": {
    "department": "DeptB",
    "profitCenter": "A",
    "productCategory": "Loan"
  },
  "productIdentifier": "MilaapNew Loan1",
  "terms": [
    {
      "cycleOfPrincipalRedemption": "P1ML0",
      "nextPrincipalRedemptionPayment": "(value:Real)",
      "dayCountConvention": "30E360",
      "cycleOfInterestPayment": "P1ML0",
      "initialExchangeDate": "(value:TimeStamp)",
      "nominalInterestRate": "0.24",
      "contractDealDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
      "contractID": "(value='System.UUID')",
      "maturityDate": "(value='ACTUS.initialExchangeDate'+'Period.tenure')",
      "creatorIdentifier": "(value='System.RootUserProfileID')",
      "counterpartyID": "(value:ProfileID)",
      "tenure": "(value:Varchar)",
      "statusDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
      "cycleAnchorDateOfInterestPayment": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')",
      "notionalPrincipal": "(value:Real)",
      "delinquencyPeriod": "360D",
      "roundingConvention": "1",
      "businessDayConvention": "SCF",
      "currency": "INR",
      "contractType": "ANN",
      "gracePeriod": "0D",
      "contractRole": "RPA",
      "cycleAnchorDateOfPrincipalRedemption": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')"
    }
  ],
  "paymentDetails": {
    "recordCreatorPaymentChannelID": "31cc3f46-4d73-4c0e-81ae-c14eeaf745df",
    "paymentMethod": "billing",
    "counterpartyPaymentChannelID": "(value:PaymentChannelID)"
  }
}

{
  "status": 200,
  "message": "Product created successfully",
  "data": {
    "selection": {
      "department": "DeptB",
      "profitCenter": "A",
      "productCategory": "Loan"
    },
    "productIdentifier": "MilaapNew Loan1",
    "terms": [
      {
        "cycleOfPrincipalRedemption": "P1ML0",
        "nextPrincipalRedemptionPayment": "(value:Real)",
        "dayCountConvention": "30E360",
        "cycleOfInterestPayment": "P1ML0",
        "initialExchangeDate": "(value:TimeStamp)",
        "nominalInterestRate": "0.24",
        "contractDealDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
        "contractID": "(value='System.UUID')",
        "maturityDate": "(value='ACTUS.initialExchangeDate'+'Period.tenure')",
        "creatorIdentifier": "(value='System.RootUserProfileID')",
        "counterpartyID": "(value:ProfileID)",
        "tenure": "(value:Varchar)",
        "statusDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
        "cycleAnchorDateOfInterestPayment": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')",
        "notionalPrincipal": "(value:Real)",
        "delinquencyPeriod": "360D",
        "roundingConvention": "1",
        "businessDayConvention": "SCF",
        "currency": "INR",
        "contractType": "ANN",
        "gracePeriod": "0D",
        "contractRole": "RPA",
        "cycleAnchorDateOfPrincipalRedemption": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')"
      }
    ],
    "paymentDetails": {
      "recordCreatorPaymentChannelID": "31cc3f46-4d73-4c0e-81ae-c14eeaf745df",
      "paymentMethod": "billing",
      "counterpartyPaymentChannelID": "(value:PaymentChannelID)"
    }
  }
}

{
    "status": 412,
    "message": "Identifier required (or) non-empty identifier expected",
    "data": null
}

public Response<Object> createProduct(CreateProductsDTO productTemplate) {
		log.info(LOG_MESSAGE, usersHelper.getUserID(), productTemplate);

		try {
			// Perform validation checks on the product creation request
			validator.createProductValidation(usersHelper.getUserID(), productTemplate); (1)

			// Create the product using the provided data
			return productsWorker.createProduct(productTemplate); (2)

		} catch (Exception e) { (3)
			return new Response<>(HttpStatus.PRECONDITION_FAILED.value(), e.getMessage(), null);
		}
	}

public void createProductValidation(UUID userID, CreateProductsDTO productTemplate) {

		if (UtilityHelper.isNotNullOrEmpty(productTemplate.getProductIdentifier())) { (1)

			String productIdentifier = productTemplate.getProductIdentifier();

			boolean exists = productsServiceRepo.existsByUserIDAndProductIdentifier(userID, productIdentifier); (2)

			// Check for unique identifier
			Assert.isTrue(!exists, "Product identifier already exists");

		} else {
			throw new IllegalArgumentException("Identifier required (or) non-empty identifier expected"); (3)
		}

	}

	@Test
	void createProduct() throws Exception { (1)
		// Prepare data for the test
		productTemplate.setProductIdentifier("Go savings");

		// Mocking the HTTP request
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.post("/products")
				.contentType(MediaType.APPLICATION_JSON)
				.content((new ObjectMapper()).writeValueAsString(productTemplate));

		// Performing the request and asserting the response
		JSONObject obj = new JSONObject(MockMvcBuilders.standaloneSetup(productsServiceController).build()
				.perform(requestBuilder).andExpect(MockMvcResultMatchers.status().isOk())
				.andExpect(MockMvcResultMatchers.content().contentType("application/json")).andReturn().getResponse()
				.getContentAsString());
		// Extracting contractRole from the JSON response
		JSONObject paymentDetails = obj.getJSONObject("data").getJSONObject("paymentDetails");

		// Asserting the response details
		Assertions.assertEquals("39f16465-ab89-4fc6-b50b-50413b8e0193", paymentDetails.getString("recordCreatorPaymentChannelID"));
		Assertions.assertEquals("Go savings", obj.getJSONObject("data").getString("productIdentifier"));
		Assertions.assertEquals("EUR", obj.getJSONObject("data").getJSONArray("terms").getJSONObject(0).getString("currency"));
		Assertions.assertEquals("Product created successfully", obj.get("message"));
		Assertions.assertEquals(200, obj.get("status"));
	}

@Test
	void provideProducts() throws Exception { (1)
		// Mock the HTTP request for providing all products
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/products").param("productID", "")
				.contentType(MediaType.APPLICATION_JSON);

		// Perform the request and assert the response
		JSONObject response = new JSONObject(
				MockMvcBuilders.standaloneSetup(productsServiceController).build().perform(requestBuilder)
						.andDo(print()).andExpect(MockMvcResultMatchers.content().contentType("application/json"))
						.andReturn().getResponse().getContentAsString());
		JSONArray data = response.getJSONArray("data");

		// Asserting values for the first product
		JSONObject product1 = data.getJSONObject(0);
		Assertions.assertEquals("bad75c28-3167-416e-b9b8-bb5f5f6b09a9", product1.getString("userID"));
		Assertions.assertEquals("Bond Fixed", product1.getJSONObject("template").getString("productIdentifier"));

		// Asserting values for the second product
		JSONObject product2 = data.getJSONObject(1);
		Assertions.assertEquals("a43c22ed-27df-4324-a453-3e7707c9b82d", product2.getString("userID"));
		Assertions.assertEquals("Personal savings", product2.getJSONObject("template").getString("productIdentifier"));

		// Assert the response details
		Assertions.assertEquals("Success", response.get("message"));
		Assertions.assertEquals(200, response.get("status"));
	}

{
  "selection": {
    "department": "DeptB",
    "profitCenter": "A",
    "productCategory": "Loan"
  },
  "productIdentifier": "MilaapNew Loan1",
  "terms": [
    {
      "cycleOfPrincipalRedemption": "P1ML0",
      "nextPrincipalRedemptionPayment": "(value:Real)",
      "dayCountConvention": "30E360",
      "cycleOfInterestPayment": "P1ML0",
      "initialExchangeDate": "(value:TimeStamp)",
      "nominalInterestRate": "0.24",
      "contractDealDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
      "contractID": "(value='System.UUID')",
      "maturityDate": "(value='ACTUS.initialExchangeDate'+'Period.tenure')",
      "creatorIdentifier": "(value='System.RootUserProfileID')",
      "counterpartyID": "(value:ProfileID)",
      "tenure": "(value:Varchar)",
      "statusDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
      "cycleAnchorDateOfInterestPayment": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')",
      "notionalPrincipal": "(value:Real)",
      "delinquencyPeriod": "360D",
      "roundingConvention": "1",
      "businessDayConvention": "SCF",
      "currency": "INR",
      "contractType": "ANN",
      "gracePeriod": "0D",
      "contractRole": "RPA",
      "cycleAnchorDateOfPrincipalRedemption": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')"
    }
  ],
  "paymentDetails": {
    "recordCreatorPaymentChannelID": "31cc3f46-4d73-4c0e-81ae-c14eeaf745df",
    "paymentMethod": "billing",
    "counterpartyPaymentChannelID": "(value:PaymentChannelID)"
  }
}

{
  "status": 200,
  "message": "Product updated successfully",
  "data": {
    "selection": {
      "department": "DeptB",
      "profitCenter": "A",
      "productCategory": "Loan"
    },
    "productIdentifier": "MilaapNew Loan1",
    "terms": [
      {
        "cycleOfPrincipalRedemption": "P1ML0",
        "nextPrincipalRedemptionPayment": "(value:Real)",
        "dayCountConvention": "30E360",
        "cycleOfInterestPayment": "P1ML0",
        "initialExchangeDate": "(value:TimeStamp)",
        "nominalInterestRate": "0.24",
        "contractDealDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
        "contractID": "(value='System.UUID')",
        "maturityDate": "(value='ACTUS.initialExchangeDate'+'Period.tenure')",
        "creatorIdentifier": "(value='System.RootUserProfileID')",
        "counterpartyID": "(value:ProfileID)",
        "tenure": "(value:Varchar)",
        "statusDate": "(value='ACTUS.initialExchangeDate'- 'Period.P1DL0')",
        "cycleAnchorDateOfInterestPayment": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')",
        "notionalPrincipal": "(value:Real)",
        "delinquencyPeriod": "360D",
        "roundingConvention": "1",
        "businessDayConvention": "SCF",
        "currency": "INR",
        "contractType": "ANN",
        "gracePeriod": "0D",
        "contractRole": "RPA",
        "cycleAnchorDateOfPrincipalRedemption": "(value='ACTUS.initialExchangeDate'+'Period.P1ML0')"
      }
    ],
    "paymentDetails": {
      "recordCreatorPaymentChannelID": "31cc3f46-4d73-4c0e-81ae-c14eeaf745df",
      "paymentMethod": "billing",
      "counterpartyPaymentChannelID": "(value:PaymentChannelID)"
    }
  }
}

{
    "status": 400,
    "message": "Product doesn't exist",
    "data": null
}

public Response<Object> updateProduct(Long productID, CreateProductsDTO productDetails) {
		log.info(LOG_MESSAGE, usersHelper.getUserID(), productDetails);

		// Retrieve a list of product IDs from contracts using contractURL
		List<Map<String, Object>> listOfContracts = productsWorker.getProductIDListFromContracts(productID); (1)

		// Validate whether the product is present and obtain the product
		Products product = validator.updateProductValidation(productID, listOfContracts); (2)

		return productsWorker.saveUpdatedProduct(product, productDetails); (3)
	}

public Products updateProductValidation(Long productID, List<Map<String, Object>> listOfContracts) {

		// Attempt to find the existing product by its ID
		Products product = productsServiceRepo.findById(productID)
				.orElseThrow(() -> new IllegalArgumentException("Product doesn't exist")); (1)

		// Check for status and contracts
		Assert.isTrue(product.getStatus().equalsIgnoreCase("inactive") && listOfContracts.isEmpty(),
				"Product already active (or) product have contracts"); (2)

		return product;

	}

	@Test
	void updateProduct() throws Exception { (1)

		when(productsServiceRepo.save(any())).thenReturn(productsOptional);
		when(contractsFeignClient.getContractsList(any(Long.class), any(String.class)))
				.thenReturn(new Response<>(HttpStatus.OK.value(), "Success", new ArrayList<>()));
		// Mock the HTTP request for updating a product
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.put("/products/11")
				.contentType(MediaType.APPLICATION_JSON)
				.content((new ObjectMapper()).writeValueAsString(productsOptional));

		// Perform the request and assert the response
		JSONObject obj = new JSONObject(MockMvcBuilders.standaloneSetup(productsServiceController).build()
				.perform(requestBuilder).andExpect(MockMvcResultMatchers.status().isOk())
				.andExpect(MockMvcResultMatchers.content().contentType("application/json")).andReturn().getResponse()
				.getContentAsString());

		JSONObject data = obj.getJSONObject("data");

		// Assert the response details
		Assertions.assertEquals("Leasing", data.getString("productIdentifier"));
		Assertions.assertEquals("Product updated successfully", obj.get("message"));
		Assertions.assertEquals(200, obj.get("status"));
	}

{
  "status": 200,
  "message": "Product created successfully",
  "data": {
    "productID": 3,
    "status": "inactive",
    "template": {
      "selection": {
        "productCategory": "Savings"
      },
      "productIdentifier": "Personal savings",
      "terms": [
        {
          "dayCountConvention": "30E360",
          "cycleOfInterestPayment": "P1YL1",
          "initialExchangeDate": "(value:TimeStamp)",
          "nominalInterestRate": "0",
          "contractDealDate": "(value='ACTUS.InitialExchangeDate'- 'Period.P1DL0')",
          "contractID": "(value='System.UUID')",
          "maturityDate": "(value='ACTUS.InitialExchangeDate'+'Period.Tenure')",
          "creatorID": "(value='System.RootUserProfileID')",
          "counterpartyID": "(value:ProfileID)",
          "tenure": "10Y",
          "statusDate": "(value='ACTUS.InitialExchangeDate'- 'Period.P1DL0')",
          "cycleAnchorDateOfInterestPayment": "(value='ACTUS.InitialExchangeDate'+'Period.P1YL0')",
          "notionalPrincipal": "(value:Real)",
          "roundingConvention": "1",
          "currency": "INR",
          "contractType": "UMP",
          "contractRole": "RPL"
        }
      ],
      "paymentDetails": {
        "recordCreatorPaymentChannelID": "55ca344f-19b1-4304-87db-21e8d58b4659",
        "paymentMethod": "billing",
        "counterpartyPaymentChannelID": "(value:PaymentChannelID)"
      }
    },
    "userID": "a43c22ed-27df-4324-a453-3e7707c9b82d"
  }
}

{
    "status": 400,
    "message": "ProductID doesn't exist",
    "data": null
}

public Response<Products> updateProductStatus(Long productID, String status) {
		log.info(LOG_MESSAGE, usersHelper.getUserID(), "updated product status");

		try {
			// Validate whether the provided status is valid or not
			validator.validateStatus(status); (1)

			return productsWorker.updateStatus(status, productID); (2)
		} catch (Exception e) { (3)
			return new Response<>(HttpStatus.PRECONDITION_FAILED.value(), e.getMessage(), null);
		}
	}

public void validateStatus(String status) {
		Assert.isTrue(status.equalsIgnoreCase("active") || status.equalsIgnoreCase("inactive"), (1)
				"Invalid status provided"); (2)
	}

	@Test
	void updateProductStatus() throws Exception { (1)
		// Mock the HTTP request for updating the status of a product
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.put("/products/21/status/active")
				.contentType(MediaType.APPLICATION_JSON)
				.content((new ObjectMapper()).writeValueAsString(productsOptional));

		// Perform the request and assert the response
		JSONObject obj = new JSONObject(MockMvcBuilders.standaloneSetup(productsServiceController).build()
				.perform(requestBuilder).andExpect(MockMvcResultMatchers.status().isOk())
				.andExpect(MockMvcResultMatchers.content().contentType("application/json")).andReturn().getResponse()
				.getContentAsString());
		JSONObject data = obj.getJSONObject("data");
		JSONObject template = data.getJSONObject("template");
		JSONArray termsArray = template.getJSONArray("terms");
		JSONObject firstTerm = termsArray.getJSONObject(0);
		JSONObject paymentDetails = data.getJSONObject("template").getJSONObject("paymentDetails");
		// Assert the response details
		Assertions.assertEquals("Leasing", template.getString("productIdentifier"));
		Assertions.assertEquals("ae03c2694-71f8-48e0-a68d-8328630fd0c5", paymentDetails.getString("recordCreatorPaymentChannelID"));
		Assertions.assertEquals("ANN", firstTerm.getString("contractType"));
		Assertions.assertEquals("CHF", firstTerm.getString("currency"));
		Assertions.assertEquals("active", data.getString("status"));
		Assertions.assertEquals("Product status updated successfully", obj.get("message"));
		Assertions.assertEquals(200, obj.get("status"));
	}

[
  {
    "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 = contractDataList.stream() (1)
				.map(createContractValidator::validateContractData).toList(); (2)

		// Check if all contracts are valid
		boolean allContractsValid = contractResponseDtoList.stream()
				.allMatch(contractResponseDto -> contractResponseDto.getErrors().isEmpty());

		// Create contracts only if all are valid
		if (allContractsValid) { (3)
			contractResponseDtoList = contractDataList.stream().map(contractsWorker::createContract).toList(); (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);

			// Validate the GroupId associated with the profile.
			contractsValidator.validateGroupId(createContractDto.getGroupId(), createContractDto); (5)

		} catch (Exception e) { (6)
			// 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)

		// Compute the contract and get the list of business events
		List<BusinessEvents> eventsList = contractServiceImpl.computeContract(contracts.getContractUUID());
		BusinessEvents firstEvent = eventsList.get(0);
        //Assertions
		BigDecimal remainingValue = new BigDecimal("-20000.0");
		Assertions.assertEquals(37, eventsList.size());
		Assertions.assertEquals(LocalDateTime.parse("2023-08-01T00:00"), firstEvent.getEventTime());
		Assertions.assertEquals(remainingValue, firstEvent.getRemainingValue());
		Assertions.assertEquals(UUID.fromString("6963c361-1c1f-40b6-b8b4-47f604be36ef"),firstEvent.getCreditPaymentChannelID());
		Assertions.assertEquals(UUID.fromString("e03c2694-71f8-48e0-a68d-8328630fd0c5"),firstEvent.getDebitPaymentChannelID());

	}

	@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.systemLocalDateTime());
			contractsServiceRepo.save(contract); (7)

			// Send a request to Kafka for contract execution.
			contractsHelper.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)

	 	contractServiceImpl.executeContract(contracts.getContractUUID());
		// Retrieve the updated contract from the repository
		Contracts contract = contractsRepo.findById(contracts.getContractUUID()).get();
		 // Get the contract status from the updated contract
		String contractStatus = contract.getContractTerms().get(0).getContractPerformance();
		// Assertion
		Assertions.assertEquals("PF", contractStatus);
		Assertions.assertEquals("a6ef2246-6c23-4d16-9bfe-c6cbb827594d", contract.getContractUUID().toString());

	}

	@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 = contractDataList.stream()
				.map(updateContractValidator::validateContractData).toList(); (1)

		// Check if all contracts are valid
		boolean allContractsValid = contractResponseDtoList.stream()
				.allMatch(contractResponseDto -> contractResponseDto.getErrors().isEmpty()); (2)

		// Update contracts only if all are valid
		if (allContractsValid) {
			contractResponseDtoList = contractDataList.stream().map(contractsWorker::updateContract).toList(); (3)
		}

		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);