![JAR search and dependency download from the Maven repository](/logo.png)
io.mosip.pms.partner.service.impl.PartnerServiceImpl Maven / Gradle / Ivy
package io.mosip.pms.partner.service.impl;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.data.domain.Page;
import org.springframework.http.MediaType;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.mosip.kernel.core.authmanager.authadapter.model.AuthUserDetails;
import io.mosip.pms.common.constant.ApiAccessibleExceptionConstant;
import io.mosip.pms.common.constant.EventType;
import io.mosip.pms.common.dto.FilterData;
import io.mosip.pms.common.dto.FilterDto;
import io.mosip.pms.common.dto.FilterValueDto;
import io.mosip.pms.common.dto.PageResponseDto;
import io.mosip.pms.common.dto.PartnerPolicySearchResponseDto;
import io.mosip.pms.common.dto.PolicyRequestSearchResponseDto;
import io.mosip.pms.common.dto.SearchDto;
import io.mosip.pms.common.dto.SearchFilter;
import io.mosip.pms.common.dto.Type;
import io.mosip.pms.common.entity.AuthPolicy;
import io.mosip.pms.common.entity.BiometricExtractorProvider;
import io.mosip.pms.common.entity.Partner;
import io.mosip.pms.common.entity.PartnerContact;
import io.mosip.pms.common.entity.PartnerH;
import io.mosip.pms.common.entity.PartnerHPK;
import io.mosip.pms.common.entity.PartnerPolicy;
import io.mosip.pms.common.entity.PartnerPolicyCredentialType;
import io.mosip.pms.common.entity.PartnerPolicyCredentialTypePK;
import io.mosip.pms.common.entity.PartnerPolicyRequest;
import io.mosip.pms.common.entity.PartnerType;
import io.mosip.pms.common.entity.PolicyGroup;
import io.mosip.pms.common.exception.ApiAccessibleException;
import io.mosip.pms.common.helper.FilterHelper;
import io.mosip.pms.common.helper.SearchHelper;
import io.mosip.pms.common.helper.WebSubPublisher;
import io.mosip.pms.common.repository.AuthPolicyRepository;
import io.mosip.pms.common.repository.BiometricExtractorProviderRepository;
import io.mosip.pms.common.repository.PartnerContactRepository;
import io.mosip.pms.common.repository.PartnerHRepository;
import io.mosip.pms.common.repository.PartnerPolicyCredentialTypeRepository;
import io.mosip.pms.common.repository.PartnerPolicyRepository;
import io.mosip.pms.common.repository.PartnerPolicyRequestRepository;
import io.mosip.pms.common.repository.PartnerServiceRepository;
import io.mosip.pms.common.repository.PartnerTypeRepository;
import io.mosip.pms.common.repository.PolicyGroupRepository;
import io.mosip.pms.common.request.dto.RequestWrapper;
import io.mosip.pms.common.util.MapperUtils;
import io.mosip.pms.common.util.PageUtils;
import io.mosip.pms.common.util.RestUtil;
import io.mosip.pms.common.validator.FilterColumnValidator;
import io.mosip.pms.device.response.dto.ColumnCodeValue;
import io.mosip.pms.device.response.dto.FilterResponseCodeDto;
import io.mosip.pms.partner.constant.ErrorCode;
import io.mosip.pms.partner.constant.PartnerConstants;
import io.mosip.pms.partner.dto.MosipUserDto;
import io.mosip.pms.partner.dto.UploadCertificateRequestDto;
import io.mosip.pms.partner.dto.UserRegistrationRequestDto;
import io.mosip.pms.partner.exception.PartnerServiceException;
import io.mosip.pms.partner.keycloak.service.KeycloakImpl;
import io.mosip.pms.partner.request.dto.AddContactRequestDto;
import io.mosip.pms.partner.request.dto.CACertificateRequestDto;
import io.mosip.pms.partner.request.dto.ExtractorDto;
import io.mosip.pms.partner.request.dto.ExtractorProviderDto;
import io.mosip.pms.partner.request.dto.ExtractorsDto;
import io.mosip.pms.partner.request.dto.PartnerAPIKeyRequest;
import io.mosip.pms.partner.request.dto.PartnerCertDownloadRequestDto;
import io.mosip.pms.partner.request.dto.PartnerCertificateRequestDto;
import io.mosip.pms.partner.request.dto.PartnerCertificateUploadRequestDto;
import io.mosip.pms.partner.request.dto.PartnerRequest;
import io.mosip.pms.partner.request.dto.PartnerSearchDto;
import io.mosip.pms.partner.request.dto.PartnerUpdateRequest;
import io.mosip.pms.partner.response.dto.APIkeyRequests;
import io.mosip.pms.partner.response.dto.CACertificateResponseDto;
import io.mosip.pms.partner.response.dto.DownloadPartnerAPIkeyResponse;
import io.mosip.pms.partner.response.dto.PartnerAPIKeyResponse;
import io.mosip.pms.partner.response.dto.PartnerCertDownloadResponeDto;
import io.mosip.pms.partner.response.dto.PartnerCertificateResponseDto;
import io.mosip.pms.partner.response.dto.PartnerCredentialTypePolicyDto;
import io.mosip.pms.partner.response.dto.PartnerResponse;
import io.mosip.pms.partner.response.dto.PartnerSearchResponseDto;
import io.mosip.pms.partner.response.dto.RetrievePartnerDetailsResponse;
import io.mosip.pms.partner.service.PartnerService;
import io.mosip.pms.partner.util.PartnerUtil;
@Service
@Transactional
public class PartnerServiceImpl implements PartnerService {
private static final Logger LOGGER = LoggerFactory.getLogger(PartnerServiceImpl.class);
private static final String ALL = "all";
@Autowired
PartnerServiceRepository partnerRepository;
@Autowired
PartnerTypeRepository partnerTypeRepository;
@Autowired
PolicyGroupRepository policyGroupRepository;
@Autowired
PartnerHRepository partnerHRepository;
@Autowired
AuthPolicyRepository authPolicyRepository;
@Autowired
PartnerPolicyRequestRepository partnerPolicyRequestRepository;
@Autowired
PartnerPolicyRepository partnerPolicyRepository;
@Autowired
PartnerContactRepository partnerContactRepository;
@Autowired
BiometricExtractorProviderRepository extractorProviderRepository;
@Autowired
PartnerPolicyCredentialTypeRepository partnerCredentialTypePolicyRepo;
@Autowired
SearchHelper partnerSearchHelper;
@Autowired
private PageUtils pageUtils;
@Autowired
FilterColumnValidator filterColumnValidator;
@Autowired
FilterHelper filterHelper;
@Autowired
RestUtil restUtil;
@Autowired
private WebSubPublisher webSubPublisher;
@Autowired
private ObjectMapper mapper;
@Autowired
private Environment environment;
@Autowired
private KeycloakImpl keycloakImpl;
@Value("${pmp.partner.partnerId.max.length}")
private int partnerIdMaxLength;
@Value("${mosip.pmp.partner.policy.expiry.period.indays}")
private int partnerPolicyExpiryInDays;
@Value("${pmp.partner.valid.email.address.regex}")
private String emailRegex;
@Value("${pmp.allowed.credential.types}")
private String allowedCredentialTypes;
@Value("${policy.credential.type.mapping.allowed.partner.types}")
private String credentialTypesRequiredPartnerTypes;
@Value("${application.id:PARTNER}")
private String applicationId;
@Override
public PartnerResponse savePartner(PartnerRequest request) {
validateEmail(request.getEmailId());
validatePartnerIdLength(request.getPartnerId());
validatePartnerByEmail(request.getEmailId());
validatePartnerId(request.getPartnerId());
PartnerType partnerType = validateAndGetPartnerType(request.getPartnerType());
PolicyGroup policyGroup = null;
if (partnerType.getIsPolicyRequired()) {
policyGroup = validateAndGetPolicyGroupByName(request.getPolicyGroup());
}
Partner partner = mapPartnerFromRequest(request, policyGroup);
RegisterUserInKeycloak(partner);
partnerRepository.save(partner);
saveToPartnerH(partner);
PartnerResponse partnerResponse = new PartnerResponse();
partnerResponse.setPartnerId(partner.getId());
partnerResponse.setStatus(partner.getApprovalStatus());
return partnerResponse;
}
private void saveToPartnerH(Partner partner) {
PartnerH partnerHistory = new PartnerH();
PartnerHPK partnerHPK = new PartnerHPK();
partnerHPK.setId(PartnerUtil.createPartnerId());
partnerHPK.setEffDtimes(new Date());
LocalDateTime now = LocalDateTime.now();
partnerHistory.setPolicyGroupId(partner.getPolicyGroupId());
partnerHistory.setName(partner.getName());
partnerHistory.setAddress(partner.getAddress());
partnerHistory.setContactNo(partner.getContactNo());
partnerHistory.setPartnerTypeCode(partner.getPartnerTypeCode());
partnerHistory.setApprovalStatus(partner.getApprovalStatus());
partnerHistory.setEmailId(partner.getEmailId());
partnerHistory.setIsActive(partner.getIsActive());
partnerHistory.setIsDeleted(partner.getIsDeleted());
partnerHistory.setUserId(partner.getUserId());
partnerHistory.setCrBy(partner.getCrBy());
partnerHistory.setCrDtimes(Timestamp.valueOf(now));
partnerHistory.setId(partnerHPK);
partnerHRepository.save(partnerHistory);
}
private MosipUserDto RegisterUserInKeycloak(Partner partner) {
UserRegistrationRequestDto userRegistrationRequestDto = new UserRegistrationRequestDto();
userRegistrationRequestDto.setAppId("PARTNER_MANAGEMENT");
userRegistrationRequestDto.setContactNo(partner.getContactNo());
userRegistrationRequestDto.setEmailID(partner.getEmailId());
userRegistrationRequestDto.setFirstName(partner.getName());
userRegistrationRequestDto.setRole(partner.getPartnerTypeCode().toUpperCase());
userRegistrationRequestDto.setUserPassword(partner.getId());
userRegistrationRequestDto.setUserName(partner.getId().toLowerCase());
return keycloakImpl.registerUser(userRegistrationRequestDto);
}
private Partner mapPartnerFromRequest(PartnerRequest request, PolicyGroup policyGroup) {
Partner partner = new Partner();
partner.setId(request.getPartnerId());
partner.setPolicyGroupId(policyGroup != null ? policyGroup.getId() : null);
partner.setName(request.getOrganizationName());
partner.setAddress(request.getAddress());
partner.setContactNo(request.getContactNumber());
partner.setPartnerTypeCode(request.getPartnerType());
partner.setEmailId(request.getEmailId());
partner.setIsActive(false);
partner.setIsDeleted(false);
partner.setUserId(request.getPartnerId());
partner.setCrBy(getUser());
partner.setApprovalStatus(PartnerConstants.IN_PROGRESS);
partner.setCrDtimes(Timestamp.valueOf(LocalDateTime.now()));
return partner;
}
private PolicyGroup validateAndGetPolicyGroupByName(String policyGroup) {
PolicyGroup policyGroupFromDb = policyGroupRepository.findByName(policyGroup);
if (policyGroup == null) {
LOGGER.error(policyGroup + " : Policy Group is not available");
throw new PartnerServiceException(ErrorCode.POLICY_GROUP_DOES_NOT_EXIST.getErrorCode(),
ErrorCode.POLICY_GROUP_DOES_NOT_EXIST.getErrorMessage());
}
return policyGroupFromDb;
}
private PartnerType validateAndGetPartnerType(String partnerType) {
Optional partnerTypeFromDb = partnerTypeRepository.findById(partnerType);
if (partnerTypeFromDb.isEmpty()) {
LOGGER.error(partnerType + " : partnerType is not available.");
throw new PartnerServiceException(ErrorCode.PARTNER_TYPE_DOES_NOT_EXIST.getErrorCode(),
ErrorCode.PARTNER_TYPE_DOES_NOT_EXIST.getErrorMessage());
}
return partnerTypeFromDb.get();
}
private void validatePartnerByEmail(String emailId) {
Partner partnerFromDb = partnerRepository.findByEmailId(emailId);
if (partnerFromDb != null) {
LOGGER.error("Partner with email " + emailId + "already exists.");
throw new PartnerServiceException(ErrorCode.EMAIL_ALREADY_EXISTS_EXCEPTION.getErrorCode(),
ErrorCode.EMAIL_ALREADY_EXISTS_EXCEPTION.getErrorMessage());
}
}
private void validatePartnerId(String partnerId) {
Optional partnerById = partnerRepository.findById(partnerId);
if (!partnerById.isEmpty()) {
LOGGER.error("Partner with id " + partnerId + "already exists.");
throw new PartnerServiceException(ErrorCode.PARTNER_ALREADY_REGISTERED_WITH_ID_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_ALREADY_REGISTERED_WITH_ID_EXCEPTION.getErrorMessage());
}
}
private void validatePartnerIdLength(String partnerId) {
if (partnerId.length() > partnerIdMaxLength) {
LOGGER.error(
"Length of partner id " + partnerId + " : is more than max length(" + partnerIdMaxLength + ")");
throw new PartnerServiceException(ErrorCode.PARTNER_ID_LENGTH_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_ID_LENGTH_EXCEPTION.getErrorMessage() + partnerIdMaxLength);
}
}
private void validateEmail(String emailId) {
if (!emailId.matches(emailRegex)) {
LOGGER.error(emailId + " : this is invalid email");
throw new PartnerServiceException(ErrorCode.INVALID_EMAIL_ID_EXCEPTION.getErrorCode(),
ErrorCode.INVALID_EMAIL_ID_EXCEPTION.getErrorMessage());
}
}
@Override
public RetrievePartnerDetailsResponse getPartnerDetails(String partnerId) {
RetrievePartnerDetailsResponse response = new RetrievePartnerDetailsResponse();
Partner partner = getValidPartner(partnerId,true);
response.setPartnerID(partner.getId());
response.setAddress(partner.getAddress());
response.setContactNumber(partner.getContactNo());
response.setEmailId(partner.getEmailId());
response.setOrganizationName(partner.getName());
response.setPartnerType(partner.getPartnerTypeCode());
response.setStatus(partner.getApprovalStatus());
if (partner.getPolicyGroupId() != null) {
response.setPolicyGroup(validateAndGetPolicyGroupById(partner.getPolicyGroupId()).getName());
}
return response;
}
private Partner getValidPartner(String partnerId,boolean isToRetrieve) {
Optional partnerById = partnerRepository.findById(partnerId);
if (partnerById.isEmpty()) {
LOGGER.error("Partner with id " + partnerId + "not exists.");
throw new PartnerServiceException(ErrorCode.PARTNER_DOES_NOT_EXIST_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_DOES_NOT_EXIST_EXCEPTION.getErrorMessage());
}
if(!isToRetrieve) {
if (!partnerById.get().getIsActive()) {
LOGGER.error("Partner with id " + partnerId + "is not active.");
throw new PartnerServiceException(ErrorCode.PARTNER_NOT_ACTIVE_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_NOT_ACTIVE_EXCEPTION.getErrorMessage());
}
}
return partnerById.get();
}
private PolicyGroup validateAndGetPolicyGroupById(String policyGroupId) {
Optional policyGroupFromDb = policyGroupRepository.findById(policyGroupId);
if (policyGroupFromDb.isEmpty()) {
LOGGER.error(policyGroupId + " : Policy Group is not available");
throw new PartnerServiceException(ErrorCode.POLICY_GROUP_DOES_NOT_EXIST.getErrorCode(),
ErrorCode.POLICY_GROUP_DOES_NOT_EXIST.getErrorMessage());
}
return policyGroupFromDb.get();
}
@Override
public PartnerResponse updatePartnerDetail(PartnerUpdateRequest partnerUpdateRequest, String partnerId) {
Partner partner = getValidPartner(partnerId,false);
partner.setAddress(partnerUpdateRequest.getAddress());
partner.setContactNo(partnerUpdateRequest.getContactNumber());
partner.setUpdBy(getUser());
partner.setUpdDtimes(Timestamp.valueOf(LocalDateTime.now()));
partnerRepository.save(partner);
saveToPartnerH(partner);
PartnerResponse updateResponse = new PartnerResponse();
updateResponse.setPartnerId(partner.getId());
updateResponse.setStatus(partner.getApprovalStatus());
return updateResponse;
}
@Override
public PartnerAPIKeyResponse submitPartnerApiKeyReq(PartnerAPIKeyRequest partnerAPIKeyRequest, String partnerId) {
Partner partner = getValidPartner(partnerId,false);
AuthPolicy authPolicy = validatePolicyGroupAndPolicy(partner.getPolicyGroupId(),
partnerAPIKeyRequest.getPolicyName());
PartnerPolicyRequest partnerPolicyRequest = new PartnerPolicyRequest();
partnerPolicyRequest.setStatusCode(PartnerConstants.IN_PROGRESS);
partnerPolicyRequest.setCrBy(getUser());
partnerPolicyRequest.setCrDtimes(Timestamp.valueOf(LocalDateTime.now()));
partnerPolicyRequest.setId(PartnerUtil.createPartnerPolicyRequestId());
partnerPolicyRequest.setPartner(partner);
partnerPolicyRequest.setPolicyId(authPolicy.getId());
partnerPolicyRequest.setRequestDatetimes(Timestamp.valueOf(LocalDateTime.now()));
partnerPolicyRequest.setRequestDetail(partnerAPIKeyRequest.getUseCaseDescription());
partnerPolicyRequest.setIsDeleted(false);
if (!partnerPolicyRepository.findByPartnerIdAndPolicyIdAndIsActiveTrue(partnerId,authPolicy.getId()).isEmpty()) {
partnerPolicyRequest.setStatusCode(PartnerConstants.APPROVED);
partnerPolicyRequestRepository.save(partnerPolicyRequest);
return approvePartnerPolicy(partnerPolicyRequest);
}
partnerPolicyRequestRepository.save(partnerPolicyRequest);
PartnerAPIKeyResponse partnerAPIKeyResponse = new PartnerAPIKeyResponse();
partnerAPIKeyResponse.setApiRequestId(partnerPolicyRequest.getId());
partnerAPIKeyResponse.setMessage("PartnerAPIKeyRequest successfully submitted.");
LOGGER.info("PartnerAPIKeyRequest successfully submitted.");
return partnerAPIKeyResponse;
}
private PartnerAPIKeyResponse approvePartnerPolicy(PartnerPolicyRequest partnerPolicyRequest) {
PartnerPolicy partnerPolicy = new PartnerPolicy();
partnerPolicy.setPolicyApiKey(partnerPolicyRequest.getId());
partnerPolicy.setPartner(partnerPolicyRequest.getPartner());
partnerPolicy.setPolicyId(partnerPolicyRequest.getPolicyId());
partnerPolicy.setIsActive(true);
partnerPolicy.setIsDeleted(false);
partnerPolicy.setValidFromDatetime(Timestamp.valueOf(LocalDateTime.now()));
partnerPolicy.setValidToDatetime(Timestamp.valueOf(LocalDateTime.now().plusDays(partnerPolicyExpiryInDays)));
partnerPolicy.setCrBy(partnerPolicyRequest.getCrBy());
partnerPolicy.setCrDtimes(partnerPolicyRequest.getCrDtimes());
partnerPolicyRepository.save(partnerPolicy);
PartnerAPIKeyResponse partnerAPIKeyResponse = new PartnerAPIKeyResponse();
partnerAPIKeyResponse.setApiRequestId(partnerPolicyRequest.getId());
partnerAPIKeyResponse.setApikeyId(partnerPolicy.getPolicyApiKey());
partnerAPIKeyResponse.setMessage("PartnerAPIKeyRequest successfully submitted and approved.");
LOGGER.info("PartnerAPIKeyRequest successfully submitted and approved.");
return partnerAPIKeyResponse;
}
private AuthPolicy validatePolicyGroupAndPolicy(String policyGroupId, String policyName) {
AuthPolicy authPolicyFromDb = authPolicyRepository.findByPolicyGroupAndName(policyGroupId, policyName);
if (authPolicyFromDb == null) {
LOGGER.info("Given Policy and partner's policy group not mapped.");
throw new PartnerServiceException(ErrorCode.POLICY_GROUP_POLICY_NOT_EXISTS.getErrorCode(),
ErrorCode.POLICY_GROUP_POLICY_NOT_EXISTS.getErrorMessage());
}
if (!authPolicyFromDb.getIsActive()) {
LOGGER.info("Given Policy is not active. " + authPolicyFromDb.getId());
throw new PartnerServiceException(ErrorCode.POLICY_NOT_ACTIVE_EXCEPTION.getErrorCode(),
ErrorCode.POLICY_NOT_ACTIVE_EXCEPTION.getErrorMessage());
}
if (authPolicyFromDb.getValidToDate().isBefore(LocalDateTime.now())) {
LOGGER.info("Policy is expired. " + authPolicyFromDb.getId());
throw new PartnerServiceException(ErrorCode.POLICY_EXPIRED_EXCEPTION.getErrorCode(),
ErrorCode.POLICY_EXPIRED_EXCEPTION.getErrorMessage());
}
if (!authPolicyFromDb.getPolicyGroup().getIsActive()) {
LOGGER.info("Policy group is not active." + authPolicyFromDb.getPolicyGroup().getId());
throw new PartnerServiceException(ErrorCode.POLICY_GROUP_NOT_ACTIVE.getErrorCode(),
ErrorCode.POLICY_GROUP_NOT_ACTIVE.getErrorMessage());
}
return authPolicyFromDb;
}
@Override
public DownloadPartnerAPIkeyResponse getApikeyFromRequestKey(String partnerId, String apikeyReqId) {
PartnerPolicyRequest partnerRequest = partnerPolicyRequestRepository.findByPartnerIdAndReqId(partnerId,
apikeyReqId);
if (partnerRequest == null) {
LOGGER.info(apikeyReqId + " : Invalid apikeyReqId");
throw new PartnerServiceException(ErrorCode.PARTNER_API_KET_REQ_DOES_NOT_EXIST_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_API_KET_REQ_DOES_NOT_EXIST_EXCEPTION.getErrorMessage());
}
DownloadPartnerAPIkeyResponse response = new DownloadPartnerAPIkeyResponse();
response.setApikeyReqStatus(partnerRequest.getStatusCode());
response.setApiRequestKey(apikeyReqId);
if (partnerRequest.getStatusCode().equalsIgnoreCase(PartnerConstants.APPROVED)) {
PartnerPolicy approvedPolicy = getPartnerMappedPolicy(apikeyReqId);
response.setPartnerAPIKey(approvedPolicy.getPolicyApiKey());
response.setValidityTill(approvedPolicy.getValidToDatetime());
response.setApikeyStatus(approvedPolicy.getIsActive());
}
return response;
}
private PartnerPolicy getPartnerMappedPolicy(String apiKey) {
return partnerPolicyRepository.findByApiKey(apiKey);
}
@Override
public List retrieveAllApiKeyRequestsSubmittedByPartner(String partnerId) {
List apikeyRequestsByPartner = partnerPolicyRequestRepository.findByPartnerId(partnerId);
if (apikeyRequestsByPartner.isEmpty()) {
LOGGER.info("For partner " + partnerId + " : no apikey request exists.");
throw new PartnerServiceException(ErrorCode.PARTNER_API_KET_REQ_DOES_NOT_EXIST_EXCEPTION.getErrorCode(),
ErrorCode.PARTNER_API_KET_REQ_DOES_NOT_EXIST_EXCEPTION.getErrorMessage());
}
List apikeyRequests = new ArrayList<>();
for (PartnerPolicyRequest apIkeyRequest : apikeyRequestsByPartner) {
APIkeyRequests approvedRequest = new APIkeyRequests();
approvedRequest.setApiKeyReqID(apIkeyRequest.getId());
approvedRequest.setApiKeyRequestStatus(apIkeyRequest.getStatusCode());
if (apIkeyRequest.getStatusCode().equalsIgnoreCase(PartnerConstants.APPROVED)) {
PartnerPolicy approvedPolicy = getPartnerMappedPolicy(apIkeyRequest.getId());
approvedRequest.setPartnerApiKey(approvedPolicy.getPolicyApiKey());
approvedRequest.setValidityTill(approvedPolicy.getValidToDatetime());
approvedRequest.setApikeyStatus(approvedPolicy.getIsActive());
}
apikeyRequests.add(approvedRequest);
}
return apikeyRequests;
}
@Override
public String createAndUpdateContactDetails(AddContactRequestDto request, String partnerId) {
validateEmail(request.getEmailId());
PartnerContact contactsFromDb = partnerContactRepository.findByPartnerAndEmail(partnerId, request.getEmailId());
String resultMessage;
if (contactsFromDb != null) {
contactsFromDb.setAddress(request.getAddress());
contactsFromDb.setContactNo(request.getContactNumber());
contactsFromDb.setIsActive(request.getIs_Active());
contactsFromDb.setUpdBy(getUser());
contactsFromDb.setUpdDtimes(LocalDateTime.now());
resultMessage = "Contacts details updated successfully.";
} else {
Partner partnerFromDb = getValidPartner(partnerId,false);
contactsFromDb = new PartnerContact();
contactsFromDb.setId(PartnerUtil.createPartnerId());
contactsFromDb.setAddress(request.getAddress());
contactsFromDb.setContactNo(request.getContactNumber());
contactsFromDb.setCrBy(getUser());
contactsFromDb.setCrDtimes(LocalDateTime.now());
contactsFromDb.setPartner(partnerFromDb);
contactsFromDb.setEmailId(request.getEmailId());
contactsFromDb.setIsActive(request.getIs_Active());
contactsFromDb.setIsDeleted(false);
resultMessage = "Contacts details added successfully.";
}
partnerContactRepository.save(contactsFromDb);
return resultMessage;
}
@SuppressWarnings("unchecked")
@Override
public CACertificateResponseDto uploadCACertificate(CACertificateRequestDto caCertRequestDto)
throws JsonParseException, JsonMappingException, JsonProcessingException, IOException {
RequestWrapper request = new RequestWrapper<>();
request.setRequest(caCertRequestDto);
request.setRequesttime(LocalDateTime.now());
CACertificateResponseDto responseObject = null;
Map uploadApiResponse = restUtil.postApi(
environment.getProperty("pmp.ca.certificaticate.upload.rest.uri"), null, "", "",
MediaType.APPLICATION_JSON, request, Map.class);
LOGGER.info("Calling the upload ca certificate api");
responseObject = mapper.readValue(mapper.writeValueAsString(uploadApiResponse.get("response")),
CACertificateResponseDto.class);
if (responseObject == null && uploadApiResponse.containsKey(PartnerConstants.ERRORS)) {
List
© 2015 - 2025 Weber Informatics LLC | Privacy Policy