biller-cli 0.1.0__py3-none-any.whl

biller_cli/templates/biller-user-layer/src/main/java/bharat/connect/biller/provider/impl/PostgresBillingProvider.java

@@ -0,0 +1,210 @@
+package bharat.connect.biller.provider.impl;
+
+import bharat.connect.biller.model.BillDetails;
+import bharat.connect.biller.provider.BillingProvider;
+import bharat.connect.biller.provider.BillingProviderProperties;
+import bharat.connect.biller.provider.CustomerParamCriterion;
+import bharat.connect.biller.provider.PaymentUpdateRequest;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class PostgresBillingProvider implements BillingProvider {
+    private static final Pattern IDENTIFIER_PATTERN = Pattern.compile("^[A-Za-z_][A-Za-z0-9_\\.]*$");
+
+    private final NamedParameterJdbcTemplate jdbcNamedTemplate;
+    private final BillingProviderProperties.Postgres postgres;
+
+    public PostgresBillingProvider(@Qualifier("jdbcNamedTemplate") NamedParameterJdbcTemplate jdbcNamedTemplate,
+                                   BillingProviderProperties properties) {
+        this.jdbcNamedTemplate = jdbcNamedTemplate;
+        this.postgres = properties.getPostgres();
+    }
+
+    @Override
+    public BillDetails findLatestUnpaidBill(List<CustomerParamCriterion> criteria) {
+        if (criteria == null || criteria.isEmpty()) {
+            return null;
+        }
+
+        String billTable = id(postgres.getTables().getBillDetails());
+        String billIdCol = id(postgres.getBillColumns().getBillId());
+        String customerParamNameCol = id(postgres.getBillColumns().getCustomerParamName());
+        String customerParamTypeCol = id(postgres.getBillColumns().getCustomerParamType());
+        String customerParamValueCol = id(postgres.getBillColumns().getCustomerParamValue());
+        String billAmountCol = id(postgres.getBillColumns().getBillAmount());
+        String billDateCol = id(postgres.getBillColumns().getBillDate());
+        String dueDateCol = id(postgres.getBillColumns().getDueDate());
+        String billNumberCol = id(postgres.getBillColumns().getBillNumber());
+        String billPeriodCol = id(postgres.getBillColumns().getBillPeriod());
+        String billStatusCol = id(postgres.getBillColumns().getBillStatus());
+        String additionalInfoCol = id(postgres.getBillColumns().getAdditionalInfo());
+        String createdAtCol = id(postgres.getBillColumns().getCreatedAt());
+        String updatedAtCol = id(postgres.getBillColumns().getUpdatedAt());
+
+        StringBuilder sql = new StringBuilder("""
+                SELECT %s AS bill_id, %s AS customer_param_name, %s AS customer_param_type, %s AS customer_param_value,
+                       %s AS bill_amount, %s AS bill_date, %s AS due_date, %s AS bill_number, %s AS bill_period,
+                       %s AS bill_status, %s AS additional_info, %s AS created_at, %s AS updated_at
+                FROM %s
+                WHERE %s = 'UNPAID'
+                """.formatted(
+                billIdCol, customerParamNameCol, customerParamTypeCol, customerParamValueCol,
+                billAmountCol, billDateCol, dueDateCol, billNumberCol, billPeriodCol, billStatusCol,
+                additionalInfoCol, createdAtCol, updatedAtCol, billTable, billStatusCol
+        ));
+
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        appendCriteriaClause(criteria, sql, params, customerParamNameCol, customerParamValueCol);
+
+        sql.append("""
+                    ORDER BY %s NULLS LAST, %s DESC, %s DESC
+                    LIMIT 1
+                """.formatted(dueDateCol, billDateCol, billIdCol));
+
+        List<BillDetails> list = jdbcNamedTemplate.query(sql.toString(), params, (rs, rowNum) -> mapBillDetails(rs));
+        return list.isEmpty() ? null : list.get(0);
+    }
+
+    @Override
+    @Transactional
+    public boolean markBillPaidAndRecordTransaction(List<CustomerParamCriterion> criteria, PaymentUpdateRequest paymentUpdateRequest) {
+        if (criteria == null || criteria.isEmpty() || paymentUpdateRequest == null) {
+            return false;
+        }
+
+        String billTable = id(postgres.getTables().getBillDetails());
+        String paymentTable = id(postgres.getTables().getPaymentTransactions());
+        String billIdCol = id(postgres.getBillColumns().getBillId());
+        String customerParamNameCol = id(postgres.getBillColumns().getCustomerParamName());
+        String customerParamValueCol = id(postgres.getBillColumns().getCustomerParamValue());
+        String billStatusCol = id(postgres.getBillColumns().getBillStatus());
+        String updatedAtCol = id(postgres.getBillColumns().getUpdatedAt());
+        String dueDateCol = id(postgres.getBillColumns().getDueDate());
+        String billDateCol = id(postgres.getBillColumns().getBillDate());
+        String paymentBillIdCol = id(postgres.getPaymentColumns().getBillId());
+        String paymentTxnRefCol = id(postgres.getPaymentColumns().getBbpsTxnRef());
+        String paymentAmountCol = id(postgres.getPaymentColumns().getAmountPaid());
+        String paymentModeCol = id(postgres.getPaymentColumns().getPaymentMode());
+
+        MapSqlParameterSource updateParams = new MapSqlParameterSource();
+        StringBuilder subWhere = new StringBuilder("%s = 'UNPAID'".formatted(billStatusCol));
+        appendCriteriaClause(criteria, subWhere, updateParams, customerParamNameCol, customerParamValueCol);
+
+        String updateSql = """
+                UPDATE %s
+                SET %s = 'PAID',
+                    %s = now()
+                WHERE %s = (
+                    SELECT %s FROM %s
+                    WHERE %s
+                    ORDER BY %s NULLS LAST, %s DESC, %s DESC
+                    LIMIT 1
+                )
+                """.formatted(
+                billTable,
+                billStatusCol,
+                updatedAtCol,
+                billIdCol,
+                billIdCol,
+                billTable,
+                subWhere,
+                dueDateCol,
+                billDateCol,
+                billIdCol
+        );
+
+        int updatedRows = jdbcNamedTemplate.update(updateSql, updateParams);
+        if (updatedRows <= 0) {
+            return false;
+        }
+
+        String insertSql = """
+                INSERT INTO %s (%s, %s, %s, %s)
+                VALUES (:billId, :bbpsTxnRef, :amountPaid, :paymentMode)
+                """.formatted(paymentTable, paymentBillIdCol, paymentTxnRefCol, paymentAmountCol, paymentModeCol);
+
+        MapSqlParameterSource insertParams = new MapSqlParameterSource()
+                .addValue("billId", paymentUpdateRequest.getBillId())
+                .addValue("bbpsTxnRef", paymentUpdateRequest.getBbpsTxnRef())
+                .addValue("amountPaid", paymentUpdateRequest.getAmountPaid())
+                .addValue("paymentMode", paymentUpdateRequest.getPaymentMode());
+
+        int inserted = jdbcNamedTemplate.update(insertSql, insertParams);
+        return updatedRows > 0 && inserted > 0;
+    }
+
+    private void appendCriteriaClause(List<CustomerParamCriterion> criteria,
+                                      StringBuilder sql,
+                                      MapSqlParameterSource params,
+                                      String customerParamNameCol,
+                                      String customerParamValueCol) {
+        boolean addedAny = false;
+        for (int i = 0; i < criteria.size(); i++) {
+            CustomerParamCriterion criterion = criteria.get(i);
+            if (criterion == null) {
+                continue;
+            }
+
+            String nKey = "name" + i;
+            String vKey = "value" + i;
+            params.addValue(nKey, criterion.getName());
+            params.addValue(vKey, criterion.getValue());
+
+            sql.append(addedAny ? " OR " : " AND (");
+            sql.append("(").append(customerParamNameCol).append(" = :").append(nKey)
+                    .append(" AND ").append(customerParamValueCol).append(" = :").append(vKey).append(")");
+            addedAny = true;
+        }
+        if (addedAny) {
+            sql.append(")");
+        }
+    }
+
+    private BillDetails mapBillDetails(ResultSet rs) throws SQLException {
+        BillDetails b = new BillDetails();
+        b.setBillId(rs.getLong("bill_id"));
+        b.setCustomerParamName(rs.getString("customer_param_name"));
+        b.setCustomerParamType(rs.getString("customer_param_type"));
+        b.setCustomerParamValue(rs.getString("customer_param_value"));
+        b.setBillAmount(rs.getBigDecimal("bill_amount"));
+        var billDate = rs.getDate("bill_date");
+        if (billDate != null) {
+            b.setBillDate(billDate.toLocalDate());
+        }
+        var dueDate = rs.getDate("due_date");
+        if (dueDate != null) {
+            b.setDueDate(dueDate.toLocalDate());
+        }
+        b.setBillNumber(rs.getString("bill_number"));
+        b.setBillPeriod(rs.getString("bill_period"));
+        b.setBillStatus(rs.getString("bill_status"));
+        b.setAdditionalInfo(rs.getString("additional_info"));
+        var created = rs.getTimestamp("created_at");
+        if (created != null) {
+            b.setCreatedAt(created.toLocalDateTime());
+        }
+        var updated = rs.getTimestamp("updated_at");
+        if (updated != null) {
+            b.setUpdatedAt(updated.toLocalDateTime());
+        }
+        return b;
+    }
+
+    private String id(String configuredValue) {
+        if (configuredValue == null || configuredValue.isBlank()) {
+            throw new IllegalArgumentException("Postgres table/column mapping value must not be blank");
+        }
+        String value = configuredValue.trim();
+        if (!IDENTIFIER_PATTERN.matcher(value).matches()) {
+            throw new IllegalArgumentException("Invalid postgres identifier: " + value);
+        }
+        return value;
+    }
+}

biller_cli/templates/biller-user-layer/src/main/java/bharat/connect/biller/service/impl/BillFetchServiceImpl.java

@@ -0,0 +1,131 @@
+package bharat.connect.biller.service.impl;
+
+import bharat.connect.biller.common.CommonUtils;
+import bharat.connect.biller.model.BillDetails;
+import bharat.connect.biller.provider.BillingProvider;
+import bharat.connect.biller.provider.CustomerParamCriteriaMapper;
+import bharat.connect.biller.rest.OuRestTemplate;
+import bharat.connect.biller.service.BillFetchService;
+import org.bbps.schema.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Marshaller;
+import java.io.StringWriter;
+
+@Service
+public class BillFetchServiceImpl implements BillFetchService {
+
+    @Autowired
+    private BillingProvider billingProvider;
+
+    @Value("${ou.id}")
+    private String ouId;
+
+    @Value("${bbps.ip:${bou.domain:${bou.domain}}}")
+    private String bbpsIp;
+
+    @Value("${bbps.billfetchresponse.url:${bou.billfetchresponse.url:${bou.billfetchresponse.url}}}")
+    private String billFetchResponseUrl;
+
+    @Autowired
+    private final OuRestTemplate ouRestTemplate;
+
+    private static final JAXBContext jaxbContext;
+
+    static {
+        JAXBContext jaxbContext2 = null;
+        try {
+            jaxbContext2 = JAXBContext.newInstance(Ack.class, BillFetchResponse.class);
+        } catch (JAXBException e) {
+            e.printStackTrace();
+            jaxbContext2 = null;
+        }
+        jaxbContext = jaxbContext2;
+    }
+
+    public BillFetchServiceImpl(OuRestTemplate ouRestTemplate) {
+        this.ouRestTemplate = ouRestTemplate;
+    }
+
+    @Async
+    @Override
+    public void processBillFetchAsync(BillFetchRequest fetchRequest, String referenceId) {
+        System.out.println("Processing Bill Fetch");
+        if (fetchRequest == null || fetchRequest.getBillDetails() == null || fetchRequest.getBillDetails().getCustomerParams() == null) return;
+        BillDetails bd = billingProvider.findLatestUnpaidBill(
+                CustomerParamCriteriaMapper.from(fetchRequest.getBillDetails().getCustomerParams())
+        );
+        if (bd == null) {
+            System.out.println("No Bills found");
+            return;
+        }
+
+        try {
+            BillFetchResponse fetchResponse = new BillFetchResponse();
+            fetchResponse.setHead(fetchRequest.getHead());
+            fetchResponse.setTxn(fetchRequest.getTxn());
+            String ts = CommonUtils.getFormattedCurrentTimestamp();
+            fetchResponse.getHead().setRefId(fetchRequest.getHead().getRefId());
+            fetchResponse.getHead().setTs(ts);
+            fetchResponse.getHead().setOrigInst(ouId);
+            fetchResponse.getTxn().setTs(fetchRequest.getTxn().getTs());
+            fetchResponse.getTxn().setMsgId(fetchRequest.getTxn().getMsgId());
+            fetchResponse.getTxn().setTxnReferenceId(fetchRequest.getTxn().getTxnReferenceId());
+            BillerResponseType billerResponseType = new BillerResponseType();
+
+            billerResponseType.setAmount(String.valueOf(bd.getBillAmount()));
+            billerResponseType.setBillDate(String.valueOf(bd.getBillDate()));
+            billerResponseType.setDueDate(String.valueOf(bd.getDueDate()));
+//            fetchResponse.getBillerResponses().set(0, billerResponseType);
+            fetchResponse.getBillerResponses().add(billerResponseType);
+            fetchResponse.setBillDetails(fetchRequest.getBillDetails());
+            ReasonType responseReason = new ReasonType();
+            responseReason.setResponseCode("000");
+            responseReason.setApprovalRefNum("AB123456");
+            responseReason.setResponseReason("Successful");
+            fetchResponse.setReason(responseReason);
+            fetchResponse.getTxn().setRiskScores(null);
+
+            Marshaller marshaller = jaxbContext.createMarshaller();
+            StringWriter sw = new StringWriter();
+            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+            marshaller.marshal(fetchResponse, sw);
+            System.out.println("========================= BillFetchResponse SENT ================================");
+            System.out.println(sw.toString());
+
+            String bbpsBillFetchResponseUrl = bbpsIp + billFetchResponseUrl + fetchResponse.getHead().getRefId();
+            ResponseEntity<Ack> ackResponse = ouRestTemplate.postForEntity(
+                    bbpsBillFetchResponseUrl,
+                    fetchResponse,
+                    Ack.class,
+                    MediaType.APPLICATION_XML,
+                    MediaType.APPLICATION_XML
+            );
+
+            System.out.println("==================== Received Ack against Bill Fetch Response ===============");
+            System.out.println(ackResponse.getStatusCode());
+            if (ackResponse.getBody() != null) {
+                JAXBContext ackContext = JAXBContext.newInstance(Ack.class);
+                Marshaller ackMarshaller = ackContext.createMarshaller();
+                ackMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+                StringWriter ackSw = new StringWriter();
+                ackMarshaller.marshal(ackResponse.getBody(), ackSw);
+                System.out.println(ackSw);
+            } else {
+                System.out.println("Ack body is null");
+            }
+        } catch (JAXBException e1) {
+            e1.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

biller_cli/templates/biller-user-layer/src/main/java/bharat/connect/biller/service/impl/BillPaymentServiceImpl.java

@@ -0,0 +1,175 @@
+package bharat.connect.biller.service.impl;
+
+import bharat.connect.biller.common.CommonUtils;
+import bharat.connect.biller.model.BillDetails;
+import bharat.connect.biller.provider.BillingProvider;
+import bharat.connect.biller.provider.CustomerParamCriteriaMapper;
+import bharat.connect.biller.provider.PaymentUpdateRequest;
+import bharat.connect.biller.rest.OuRestTemplate;
+import bharat.connect.biller.service.BillPaymentService;
+import org.bbps.schema.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Marshaller;
+import java.io.StringWriter;
+import java.math.BigDecimal;
+
+@Service
+public class BillPaymentServiceImpl implements BillPaymentService {
+
+    @Autowired
+    private BillingProvider billingProvider;
+
+    @Value("${ou.id}")
+    private String ouId;
+
+    @Value("${bou.domain}")
+    private String bouIp;
+
+    @Value("${bou.billpaymentresponse.url}")
+    private String billPaymentResponseUrl;
+
+    @Autowired
+    private final OuRestTemplate ouRestTemplate;
+
+    private static final JAXBContext jaxbContext;
+
+    static {
+        JAXBContext jaxbContext2;
+        try {
+            jaxbContext2 = JAXBContext.newInstance(Ack.class, BillPaymentResponse.class);
+        } catch (JAXBException e) {
+            e.printStackTrace();
+            jaxbContext2 = null;
+        }
+        jaxbContext = jaxbContext2;
+    }
+
+    public BillPaymentServiceImpl(OuRestTemplate ouRestTemplate) {
+        this.ouRestTemplate = ouRestTemplate;
+    }
+
+    @Async
+    @Override
+    public void processBillPaymentAsync(BillPaymentRequest paymentRequest, String referenceId) {
+        System.out.println("Processing Bill Payment");
+        if (paymentRequest == null || paymentRequest.getBillDetails() == null || paymentRequest.getBillDetails().getCustomerParams() == null) {
+            System.out.println("BillPaymentRequest or CustomerParams is null, skipping.");
+            return;
+        }
+
+        CustomerParamsType customerParams = paymentRequest.getBillDetails().getCustomerParams();
+
+        // Read the unpaid bill first to get bill details for the response
+        var criteria = CustomerParamCriteriaMapper.from(customerParams);
+        BillDetails bd = billingProvider.findLatestUnpaidBill(criteria);
+        if (bd == null) {
+            System.out.println("No unpaid bill found for payment");
+            return;
+        }
+
+        String ts = CommonUtils.getFormattedCurrentTimestamp();
+        String approvalRefNum = "BP" + (System.currentTimeMillis() % 1_000_000_000L);
+
+        String bbpsTxnRef = paymentRequest.getHead().getRefId();
+        BigDecimal amountPaid = bd.getBillAmount();
+        String paymentMode = null;
+        if (paymentRequest.getPaymentMethod() != null) {
+            paymentMode = paymentRequest.getPaymentMethod().getPaymentMode();
+        }
+
+        try {
+            // Single @Transactional call: marks bill_details as PAID + inserts payment_transactions.
+            // Both succeed or both rollback.
+            boolean success = billingProvider.markBillPaidAndRecordTransaction(
+                    criteria,
+                    PaymentUpdateRequest.builder()
+                            .billId(bd.getBillId())
+                            .bbpsTxnRef(bbpsTxnRef)
+                            .amountPaid(amountPaid)
+                            .paymentMode(paymentMode)
+                            .build()
+            );
+
+            if (!success) {
+                System.out.println("DB update failed — bill_status not updated or payment_transactions insert failed. Skipping response.");
+                return;
+            }
+
+            System.out.println("DB success: bill_id=" + bd.getBillId()
+                    + " marked PAID, payment_transactions row created (txnRef=" + bbpsTxnRef + ")");
+
+            // Both DB operations succeeded — build and send BillPaymentResponse
+            BillPaymentResponse resp = new BillPaymentResponse();
+
+            resp.setHead(paymentRequest.getHead());
+            resp.setTxn(paymentRequest.getTxn());
+            resp.setBillDetails(paymentRequest.getBillDetails());
+
+            resp.getHead().setRefId(paymentRequest.getHead().getRefId());
+            resp.getHead().setTs(ts);
+            resp.getHead().setOrigInst(ouId);
+
+            resp.getTxn().setTs(paymentRequest.getTxn().getTs());
+            resp.getTxn().setMsgId(paymentRequest.getTxn().getMsgId());
+            resp.getTxn().setTxnReferenceId(paymentRequest.getTxn().getTxnReferenceId());
+            resp.getTxn().setRiskScores(null);
+
+            ReasonType reason = new ReasonType();
+            reason.setResponseCode("000");
+            reason.setApprovalRefNum(approvalRefNum);
+            reason.setResponseReason("Successful");
+            resp.setReason(reason);
+
+            if (paymentRequest.getBillerResponses() != null && !paymentRequest.getBillerResponses().isEmpty()) {
+                resp.getBillerResponses().addAll(paymentRequest.getBillerResponses());
+            } else {
+                BillerResponseType br = new BillerResponseType();
+                br.setAmount(String.valueOf(bd.getBillAmount()));
+                br.setBillDate(String.valueOf(bd.getBillDate()));
+                br.setDueDate(String.valueOf(bd.getDueDate()));
+                resp.getBillerResponses().add(br);
+            }
+
+            Marshaller marshaller = jaxbContext.createMarshaller();
+            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+            StringWriter sw = new StringWriter();
+            marshaller.marshal(resp, sw);
+
+            System.out.println("========================= BillPaymentResponse SENT ================================");
+            System.out.println(sw);
+
+            String bbpsBillPaymentResponseUrl = bouIp + billPaymentResponseUrl + resp.getHead().getRefId();
+            ResponseEntity<Ack> ackResponse = ouRestTemplate.postForEntity(
+                    bbpsBillPaymentResponseUrl,
+                    resp,
+                    Ack.class,
+                    MediaType.APPLICATION_XML,
+                    MediaType.APPLICATION_XML
+            );
+
+            System.out.println("==================== Received Ack against Bill Payment Response ===============");
+            System.out.println(ackResponse.getStatusCode());
+            if (ackResponse.getBody() != null) {
+                JAXBContext ackContext = JAXBContext.newInstance(Ack.class);
+                Marshaller ackMarshaller = ackContext.createMarshaller();
+                ackMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+                StringWriter ackSw = new StringWriter();
+                ackMarshaller.marshal(ackResponse.getBody(), ackSw);
+                System.out.println(ackSw);
+            } else {
+                System.out.println("Ack body is null");
+            }
+        } catch (Exception e) {
+            System.out.println("ERROR in processBillPaymentAsync for txnRef=" + bbpsTxnRef + ": " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}

biller_cli/templates/biller-user-layer/src/main/java/bharat/connect/biller/service/impl/HeartbeatServiceImpl.java

@@ -0,0 +1,136 @@
+package bharat.connect.biller.service.impl;
+
+import bharat.connect.biller.common.CommonUtils;
+import bharat.connect.biller.rest.OuRestTemplate;
+import bharat.connect.biller.service.HeartbeatService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.bbps.schema.HeadType;
+import org.bbps.schema.ReqDiagnostic;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.Marshaller;
+import java.security.SecureRandom;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+@Service
+public class HeartbeatServiceImpl implements HeartbeatService {
+
+    @Autowired
+    private OuRestTemplate restTemplate;
+
+    @Value("${diagnosticReqFormat:application/xml}")
+    private String contentType;
+
+    @Value("${julianDt.refId:YES}")
+    private String julianDtRefId;
+
+    @Value("${julianDateDelay:0}")
+    private int julianDateDelay;
+
+    @Value("${hbt.frequency:1}")
+    private String hbtFreq;
+
+    @Value("${bou.domain:${bou.domain}}")
+    private String bouDomain;
+
+    @Value("${ou.id}")
+    private String ouId;
+
+    public static final String BOU_DIAGNOSTIC_REQUEST_URL = "/bbps/ReqHbt/1.0/urn:referenceId:";
+
+    @Override
+    public String sendHeartbeat() {
+        ResponseEntity<String> resp = null;
+        ReqDiagnostic reqHbt = new ReqDiagnostic();
+        ReqDiagnostic reqHbtJson = new ReqDiagnostic();
+        String headRefId = "";
+        String mediaType = contentType.equalsIgnoreCase("JSON") ? MediaType.APPLICATION_JSON_VALUE : MediaType.APPLICATION_XML_VALUE;
+        if (julianDtRefId.equalsIgnoreCase("YES"))
+            headRefId = generateJulianDtId();
+        else
+            headRefId = StringUtils.capitalize(RandomStringUtils.randomAlphanumeric(35));
+
+        System.out.println("=====hbt=====" + ouId);
+        String bouDiagnosticUrlUrl = bouDomain + BOU_DIAGNOSTIC_REQUEST_URL + headRefId;
+        System.out.println("=====bouDiagnosticUrlUrl=====>>" + bouDiagnosticUrlUrl);
+        if (mediaType.equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)) {
+
+            HeadType head = new HeadType();
+            head.setTs(CommonUtils.getFormattedCurrentTimestamp());
+            head.setOrigInst(ouId);
+            head.setRefId(headRefId);
+            head.setVer("1.0");
+            reqHbtJson.setHead(head);
+            ObjectMapper mapper = new ObjectMapper();
+            try {
+                System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(reqHbtJson));
+
+            } catch (JsonProcessingException e) {
+                throw new RuntimeException(e);
+            }
+            resp = restTemplate.postForEntity(bouDiagnosticUrlUrl, reqHbtJson, String.class,
+                    MediaType.valueOf(mediaType), MediaType.valueOf(mediaType));
+
+        } else {
+            try {
+                org.bbps.schema.HeadType head = new org.bbps.schema.HeadType();
+                head.setTs(CommonUtils.getFormattedCurrentTimestamp());
+                head.setOrigInst(ouId);
+                head.setRefId(headRefId);
+                head.setVer("1.0");
+                reqHbt.setHead(head);
+                JAXBContext jaxbContext = JAXBContext.newInstance(ReqDiagnostic.class);
+                Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
+                jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
+                jaxbMarshaller.marshal(reqHbt, System.out);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            resp = restTemplate.postForEntity(bouDiagnosticUrlUrl, reqHbt, String.class,
+                    MediaType.valueOf(mediaType), MediaType.valueOf(mediaType));
+
+        }
+        try {
+            if (MediaType.APPLICATION_JSON_VALUE.equals(mediaType)) {
+                System.out.println("ApplicationContext.HeartBeatGenerator.run() response Json:" + new ObjectMapper().readTree(resp.getBody()).toPrettyString());
+            } else {
+                System.out.println("ApplicationContext.HeartBeatGenerator.run() response:" + resp.getBody());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return resp.getBody();
+    }
+
+    private String generateJulianDtId() {
+        char[] chars = "abcdefghijklmnopqrstuvwxyz1234567890".toCharArray();
+        StringBuilder sb = new StringBuilder();
+        //Random random = new Random();
+        SecureRandom random = new SecureRandom();
+
+        for (int i = 0; i < 27; i++) {
+            char c = chars[random.nextInt(27)];
+            sb.append(c);
+        }
+        if (julianDateDelay > 0)
+            sb.append(LocalDate.now().plusDays(julianDateDelay).format(DateTimeFormatter.ofPattern("yDDD")).substring(3));
+        else if (julianDateDelay < 0)
+            sb.append(LocalDate.now().minusDays(Math.abs(julianDateDelay)).format(DateTimeFormatter.ofPattern("yDDD")).substring(3));
+        else if (julianDateDelay == 0)
+            sb.append(LocalDate.now().format(DateTimeFormatter.ofPattern("YDDD")).substring(3));
+
+        sb.append(LocalDateTime.now().format(DateTimeFormatter.ofPattern("HHmm")));
+        String output = sb.toString();
+        return output.toUpperCase();
+    }
+}