{
    "profileType": "INDIVIDUAL",
    "userId": "a6ef2b36-1b72-4fd9-a33e-af42c6c362b2",
    "firstName": "John wick",
    "lastName": "Martin",
    "dateOfBirth": "1967-02-03",
    "domicile": "India",
    "address": "secunderabad",
    "street": "EastMaredpally",
    "city": "Hyderabad",
    "state": "Telangana",
    "postalCode": "500029",
    "country": "India",
    "email": "john@gmail.com",
    "phoneNumber": "+9170898111",
    "customFields": {
        "customField1": "Value0",
        "customField2": "Value1",
        "industry": "Hospitality"
    },
    "status": "ACTIVE"
}

{
    "status": 200,
    "message": "Individual profile created",
    "data": {}
}

{
    "status": 400,
    "message": "Invalid profile type. Must be 'Individual'"
}

       public void createIndividualProfile(IndividualProfileCreationDTO individualCreationDTO) {
		// Create profiles entity for the individual
		Profiles profiles = profileServiceWorker.createProfiles(
				ProfileType.valueOf(individualCreationDTO.getProfileType()), individualCreationDTO.getUserId());(1)
		// Create individual entity from DTO
		Individual individual = profileServiceWorker.createIndividualFromDTO(individualCreationDTO, profiles);(2)

		// Save profiles and individual entities to the database
		profileRepository.save(profiles);(3)
		individualProfileRepository.save(individual);(4)
	}

  @Test
	void createIndividualProfile() throws JsonProcessingException {
	    // Arrange: Mock repository behaviors and validation
	    when(profileRepository.save(profiles)).thenReturn(profiles);
	    when(individualProfileRepository.save(individual)).thenReturn(individual);
	    when(validations.findIndividualCustomFields(Mockito.anyString())).thenReturn(individualCustomFields);

	    // Act: Call the createIndividualFromDTO method
	    Individual createIndividualFromDTO = profileServiceWorker.createIndividualFromDTO(individualProfileCreationDTO, profiles);

	    // Assert: Verify the properties of the created individual profile
	    assertEquals(individual.getFirstName(), createIndividualFromDTO.getFirstName());
	    assertEquals(individual.getDateOfBirth(), createIndividualFromDTO.getDateOfBirth());
	}

        @Test
	    void getIndividualProfileByprofileId() {
	    // Arrange: Mock validation and repository behaviors
	    when(validations.getProfile(profiles.getProfileId())).thenReturn(profiles);
	    when(individualProfileRepository.findByProfile(profiles)).thenReturn(individual);

	    // Act: Call the getIndividualProfile method
	    IndividualProfileCreationDTO individualProfile = profileServiceWorker.getIndividualProfile(profiles.getProfileId());

	    // Assert: Verify the properties of the retrieved individual profile DTO
	    assertEquals(individual.getFirstName(), individualProfile.getFirstName());
	    assertEquals(individual.getEmail(), individualProfile.getEmail());
	}

{
    "profileType": "BUSINESS",
    "userId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
    "businessName": "Finance",
    "registrationNumber": "AKJGB86",
    "registrationDate": "2024-03-15T04:31:22.573Z",
    "legalForm": "Formone",
    "taxId": "13284",
    "address": "Hyderabad",
    "street": "maredpally'",
    "city": "hyderabad",
    "state": "Telanagana",
    "postalCode": "509897",
    "country": "iraq",
    "email": "saihf@gmail.com",
    "phoneNumber": "+99456025165",
    "customFields": {
        "industry": "Technology",
        "customField1": "customfield",
        "customField2": "Customfield2"
    },
    "status": "INACTIVE"
}

{
    "status": 200,
    "message": "Business profile created",
    "data": {}
}

{
    "status": 400,
    "message": "Invalid profile type. Must be 'Business'"
}

   public void createBusinessProfile(BusinessProfileCreationDTO businessCreationDTO) {
		// Create profiles entity for the business
		Profiles profiles = profileServiceWorker.createProfiles(
				ProfileType.valueOf(businessCreationDTO.getProfileType()), businessCreationDTO.getUserId());(1)

		// Create business entity from DTO
		Business business = profileServiceWorker.createBusinessFromDTO(businessCreationDTO, profiles);(2)

		// Save profiles and business entities to the database
		profileRepository.save(profiles);(3)
		businessProfileRepository.save(business);(4)
	}

    @Test
	void createBusinessProfile() {
	    // Arrange: Mock repository behaviors and validation
	    when(profileRepository.save(profiles)).thenReturn(profiles);
	    when(businessProfileRepository.save(business)).thenReturn(business);
	    when(validations.findBusinessCustomFields(Mockito.anyString())).thenReturn(businessCustomFields);

	    // Act: Call the createBusinessFromDTO method
	    Business createBusinessFromDTO = profileServiceWorker.createBusinessFromDTO(businessProfileCreationDTO, profiles);

	    // Assert: Verify the properties of the created business profile
	    assertEquals(business.getBusinessName(), createBusinessFromDTO.getBusinessName());
	    assertEquals(business.getRegistrationNumber(), createBusinessFromDTO.getRegistrationNumber());
	}

	public BusinessProfileCreationDTO getBusinessProfileById(UUID profileId) {
		// Retrieve the business profile using the profileServiceWorker
		return profileServiceWorker.getBusinessProfile(profileId);(1)
	}

           @Test
	     void getBusinessProfileByprofileId() {
	    // Arrange: Mock validation and repository behaviors
	    when(validations.getProfile(profiles.getProfileId())).thenReturn(profiles);
	    when(businessProfileRepository.findByProfile(profiles)).thenReturn(business);

	    // Act: Call the getBusinessProfile method
	    BusinessProfileCreationDTO businessProfile = profileServiceWorker.getBusinessProfile(profiles.getProfileId());

	    // Assert: Verify the properties of the retrieved business profile DTO
	    assertEquals(business.getEmail(), businessProfile.getEmail());
	    assertEquals(business.getRegistrationDate(), businessProfile.getRegistrationDate());
	}

{
  "groupName": "contractGroup",
  "primaryProfile": "129638e7-4f23-454e-9791-4ae4d579a677",
  "secondaryProfiles": [
    "129638e7-4f23-454e-9791-4ae4d579a677"
  ]
}

{
    "status": 200,
    "message": "Contract group created",
    "data": {}
}

{
    "status": 400,
    "message": "The request could not be understood by the server due to malformed syntax.",
}

      public void createContractGroup(BusinessContractCreationDTO businessContractCreationDTO) {
		ContractGroup savedContractGroup = contractServiceWorker.saveContractGroup(businessContractCreationDTO);(1)
		contractServiceWorker.savePrimaryProfileConnection(businessContractCreationDTO, savedContractGroup);(2)
		contractServiceWorker.saveSecondaryProfileConnections(businessContractCreationDTO, savedContractGroup);(3)
	 }

   @Test
	void createBusinessContract() {
	    // Mock the behavior of the contract group repository to return the mock contract group
		when(contractGroupRepository.save(Mockito.any())).thenReturn(contractGroup);
	    // Call the method under test to save the contract group
		ContractGroup saveContractGroup = contractServiceWorker.saveContractGroup(businessContractCreationDTO);
	    // Verify that the saved contract group's ID matches the expected value
		assertEquals(contractGroup.getGroupId(), saveContractGroup.getGroupId());
	    // Verify that the saved contract group's name matches the expected value
		assertEquals(contractGroup.getGroupName(), saveContractGroup.getGroupName());

	}

	/**
	 * Test case to verify linking a profile to a contract group.
	 */
	@Test
	void linkProfileToContractGroup() {
	    // Mock the behavior of the contract connection repository to return the mock contract connection
		when(contractConnectionRepository.save(contractConnection)).thenReturn(contractConnection);
	    // Call the method under test to link the profile to the contract group
		contractServiceWorker.linkProfileToContractGroup(contractGroup.getGroupId(), linkProfileActionDTO);
	    // Verify that the contract group's ID matches the expected value
		assertEquals(1, contractGroup.getGroupId());
	    // Verify that the contract group's name matches the expected value
		assertEquals("BusinessGroup", contractGroup.getGroupName());
	}

	/**
	 * Test case to verify unlinking a profile from a contract group.
	 */
	@Test
	void unlinkProfileFromContractGroup() {
		// Call the method under test to unlink the profile from the contract group
		contractServiceWorker.unlinkProfileToContractGroup(contractGroup.getGroupId(), linkProfileActionDTO);
		// Verify that the contract group's ID matches the expected value
		assertEquals(1, contractGroup.getGroupId());
		// Verify that the contract group's name matches the expected value
		assertEquals("BusinessGroup", contractGroup.getGroupName());

	}

/**
	 * Test case to verify setting a primary profile for a contract group.
	 */
	@Test
	void setPrimaryProfile() {
		// Create a list of contract connections containing the mock contract connection
		ArrayList<ContractConnection> arrayList = new ArrayList<>();
		arrayList.add(contractConnection);
		// Mock the behavior of the contract connection repository to return the list of
		// contract connections
		when(contractConnectionRepository.findByGroup(contractGroup)).thenReturn(arrayList);
		// Call the method under test to set the primary profile for the contract group
		contractServiceWorker.setprimaryProfile(contractGroup.getGroupId(), setPrimaryProfileDTO);
		// Verify that the contract's ID matches the expected value
		assertEquals(1, contracts.getContractId());
		// Verify that the contract's name matches the expected value
		assertEquals("Bond", contracts.getContractName());

	}

{
  "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)
	}