Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.spice.profitmandi.common.web.util.ResponseSender;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.user.Lead;

import com.spice.profitmandi.dao.entity.user.LeadCall;

import com.spice.profitmandi.dao.entity.user.LeadDnd;

import com.spice.profitmandi.dao.entity.auth.VonageAgent;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.auth.VonageAgentRepository;

import com.spice.profitmandi.dao.repository.dtr.LeadCallRepository;

import com.spice.profitmandi.dao.repository.dtr.LeadDndRepository;

import com.spice.profitmandi.dao.repository.dtr.LeadRepository;

import com.spice.profitmandi.service.integrations.vonage.VonageVoiceService;

import com.spice.profitmandi.service.lms.LmsCallService;

import com.spice.profitmandi.service.lms.LmsOutcome;

import com.spice.profitmandi.service.lms.LmsDialerProvider;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestHeader;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import javax.servlet.http.HttpServletRequest;

import java.nio.charset.StandardCharsets;

import java.security.MessageDigest;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.util.Base64;

import java.util.HashMap;

import java.util.Map;

/**

 * The LMS web dialer: the endpoints the browser softphone talks to, plus the three Vonage callbacks.

 *

 * <p><b>Two audiences, two security models.</b> {@code /lms/dialer/*} is normal authenticated app

 * traffic behind the session cookie and the role gate. {@code /vonage/voice/*} is Vonage calling us,

 * so those paths are excluded from all three interceptors in {@code WebConfig} and are protected

 * instead by the signed-webhook JWT — which means they must never trust anything in the payload that

 * they can look up themselves. In particular the number we dial comes from the lead record, never

 * from the webhook.

 */

@Controller

@Transactional(rollbackFor = Throwable.class)

public class LmsDialerController {

    private static final Logger LOGGER = LogManager.getLogger(LmsDialerController.class);

    private final ObjectMapper objectMapper = new ObjectMapper();

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private LeadCallRepository leadCallRepository;

    @Autowired

    private LeadDndRepository leadDndRepository;

    @Autowired

    private VonageVoiceService vonageVoiceService;

    @Autowired

    private LmsDialerProvider dialerProvider;

    /**

     * Placing, tracking and ending a call — shared with the field app's endpoints in

     * profitmandi-web, which differ from these only in how they identify the agent.

     */

    @Autowired

    private LmsCallService lmsCallService;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private VonageAgentRepository vonageAgentRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private ResponseSender<?> responseSender;

    /**

     * Vonage account signature secret. Verification is skipped while this is blank so a new

     * environment can be brought up before the secret is in place — same opt-in shape as

     * {@code PinelabsWebhookController}. Set it in every environment that faces the internet.

     */

    @Value("${vonage.webhook.signature.secret:}")

    private String webhookSignatureSecret;

    // ---- Browser-facing -----------------------------------------------------------------------

    /**

     * Mint this agent's dialer credential. Short-lived by design — the page asks again rather than

     * holding a long-lived token in memory.

     */

    @RequestMapping(value = "/lms/dialer/token", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> token(HttpServletRequest request) {

        AuthUser me = currentUser(request);

        LmsDialerProvider.Handshake handshake = dialerProvider.prepare(me);

        Map<String, Object> out = new HashMap<>();

        out.put("ok", handshake.ok);

        if (!handshake.ok) {

            out.put("reason", handshake.reason);

            return responseSender.ok(out);

        }

        out.put("mode", handshake.mode.name());

        out.put("token", handshake.token);

        out.put("applicationId", handshake.applicationId);

        return responseSender.ok(out);

    }

    /**

     * Gate a dial before it happens: DND and calling hours.

     *

     * <p>A refusal is a 200 carrying {@code {ok:false, code, reason}} — "this retailer is on the

     * DND register" is a normal answer to "may I dial?", not a client error, and the browser needs

     * the code to decide what to show.

     */

    @RequestMapping(value = "/lms/dialer/precheck", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> precheck(HttpServletRequest request,

                                      @RequestParam(name = "leadId") int leadId) {

        LmsOutcome outcome = lmsCallService.precheck(leadId);

        if (outcome.status == LmsOutcome.Status.REFUSED) {

            return responseSender.ok(outcome.asRefusalBody());

        }

        return render(outcome);

    }

    /**

     * The call row for a lead, so the browser can learn its {@code leadCallId} after the answer

     * webhook has created it. The browser cannot know this id itself — see {@code VonageVoiceService}.

     */

    @RequestMapping(value = "/lms/dialer/call", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> currentCall(HttpServletRequest request,

                                         @RequestParam(name = "leadId") int leadId) {

        AuthUser me = currentUser(request);

        if (me == null) {

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        LeadCall call = leadCallRepository.selectLatestByLeadIdAndAuthId(leadId, me.getId());

        Map<String, Object> out = new HashMap<>();

        if (call == null) {

            out.put("found", false);

            return responseSender.ok(out);

        }

        out.put("found", true);

        out.put("leadCallId", call.getId());

        out.put("status", call.getStatus() != null ? call.getStatus().name() : null);

        out.put("durationSeconds", call.getDurationSeconds());

        out.put("hasRecording", call.getRecordingDocumentId() != null);

        return responseSender.ok(out);

    }

    /** Place a call server-side (click2dial). */

    @RequestMapping(value = "/lms/dialer/dial", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> dial(HttpServletRequest request,

                                  @RequestParam(name = "leadId") int leadId) {

        return render(lmsCallService.dial(currentUser(request), leadId));

    }

    /** Poll one call's live state — click2dial has no event webhook, so the browser has to ask. */

    @RequestMapping(value = "/lms/dialer/state", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> state(HttpServletRequest request,

                                   @RequestParam(name = "leadCallId") int leadCallId) {

        return render(lmsCallService.state(currentUser(request), leadCallId));

    }

    /** Hang up a server-placed call. */

    @RequestMapping(value = "/lms/dialer/hangup", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> hangup(HttpServletRequest request,

                                    @RequestParam(name = "leadCallId") int leadCallId) {

        return render(lmsCallService.hangup(currentUser(request), leadCallId));

    }

    /** Map a service outcome onto this module's response envelope. */

    private ResponseEntity<?> render(LmsOutcome outcome) {

        switch (outcome.status) {

            case OK:

                return responseSender.ok(outcome.data);

            case NOT_FOUND:

                return responseSender.notFound(outcome.message);

            case UNAUTHORIZED:

                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

            case FORBIDDEN:

                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();

            default:

                return responseSender.badRequest(outcome.message);

        }

    }

    // ---- Vonage callbacks ---------------------------------------------------------------------

    /**

     * Answer webhook — returns the NCCO. Accepts GET and POST because the method is an Application

     * setting rather than something we control per call.

     *

     * <p>Always returns valid NCCO JSON, never an error status: a 5xx here makes Vonage retry a call

     * that is already ringing. An unidentifiable lead yields an empty NCCO, which hangs up cleanly.

     */

    @RequestMapping(value = "/vonage/voice/answer", method = {RequestMethod.GET, RequestMethod.POST},

            produces = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    public String answer(HttpServletRequest request,

                         @RequestBody(required = false) String rawBody) {

        try {

            JsonNode body = (rawBody != null && !rawBody.trim().isEmpty())

                    ? objectMapper.readTree(rawBody) : null;

            String conversationUuid = firstNonNull(

                    body != null ? asText(body.get("conversation_uuid")) : null,

                    request.getParameter("conversation_uuid"));

            String callUuid = firstNonNull(

                    body != null ? asText(body.get("uuid")) : null,

                    request.getParameter("uuid"));

            // custom_data is what serverCall({leadId}) put on the wire.

            int leadId = 0;

            if (body != null && body.get("custom_data") != null) {

                leadId = asInt(body.get("custom_data").get("leadId"));

            }

            if (leadId <= 0) {

                leadId = parseInt(request.getParameter("leadId"));

            }

            // The agent is resolved from `from_user` — the JWT `sub` Vonage authenticated, echoed back

            // to us. Deliberately NOT taken from custom_data: this webhook is unauthenticated as far

            // as the app is concerned, and an auth id supplied by the caller would let anyone

            // attribute a call, and its recording, to another agent. The same lookup yields the

            // agent's own caller ID, which is why it must be trustworthy.

            VonageAgent agent = resolveAgent(firstNonNull(

                    body != null ? asText(body.get("from_user")) : null,

                    request.getParameter("from_user")));

            int authId = agent != null ? agent.getAuthId() : 0;

            String agentFromNumber = agent != null ? agent.getFromNumber() : null;

            Lead lead = leadId > 0 ? leadRepository.selectById(leadId) : null;

            if (lead == null) {

                LOGGER.error("Vonage answer webhook could not resolve a lead (conversation {})", conversationUuid);

                return "[]";

            }

            // Defence in depth: the number is taken from the lead, and DND is re-checked here rather

            // than trusting that the pre-check ran or that nothing changed since.

            if (leadDndRepository.selectByMobile(lead.getLeadMobile()) != null) {

                LOGGER.warn("Refusing to connect lead {} — number is on the DND register", leadId);

                return "[]";

            }

            return vonageVoiceService.onAnswer(leadId, authId, agentFromNumber, lead.getLeadMobile(),

                    conversationUuid, callUuid);

        } catch (Exception e) {

            LOGGER.error("Vonage answer webhook failed", e);

            return "[]";

        }

    }

    /** Event webhook — call state transitions. Always ACKs; Vonage retries anything non-2xx. */

    @RequestMapping(value = "/vonage/voice/event", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> event(HttpServletRequest request,

                                   @RequestHeader(name = "Authorization", required = false) String authorization,

                                   @RequestBody(required = false) String rawBody) {

        if (!verifySignature(authorization, rawBody)) {

            LOGGER.warn("Rejected a Vonage event webhook with a bad signature");

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        try {

            vonageVoiceService.onEvent(objectMapper.readTree(rawBody));

        } catch (Exception e) {

            LOGGER.error("Vonage event webhook failed for body {}", rawBody, e);

        }

        return ResponseEntity.ok().build();

    }

    /** Recording webhook — attaches the vendor handle; archival happens on its own schedule. */

    @RequestMapping(value = "/vonage/voice/recording", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> recording(HttpServletRequest request,

                                       @RequestHeader(name = "Authorization", required = false) String authorization,

                                       @RequestBody(required = false) String rawBody) {

        if (!verifySignature(authorization, rawBody)) {

            LOGGER.warn("Rejected a Vonage recording webhook with a bad signature");

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        try {

            vonageVoiceService.onRecording(objectMapper.readTree(rawBody));

        } catch (Exception e) {

            LOGGER.error("Vonage recording webhook failed for body {}", rawBody, e);

        }

        return ResponseEntity.ok().build();

    }

    /**

     * Vonage signed webhooks carry an HS256 JWT in {@code Authorization: Bearer}, signed with the

     * account signature secret, whose {@code payload_hash} claim is the SHA-256 of the request body.

     * Verifying both the signature and the hash is what stops a replayed body.

     *

     * <p>Returns true when no secret is configured — deliberate, so a new environment is not bricked

     * before the secret lands, and the same opt-in shape the Pinelabs webhook already uses.

     */

    private boolean verifySignature(String authorization, String rawBody) {

        if (webhookSignatureSecret == null || webhookSignatureSecret.trim().isEmpty()) {

            return true;

        }

        if (authorization == null || !authorization.trim().toLowerCase().startsWith("bearer ")) {

            return false;

        }

        try {

            String jwt = authorization.trim().substring(7).trim();

            String[] parts = jwt.split("\\.");

            if (parts.length != 3) {

                return false;

            }

            String signingInput = parts[0] + "." + parts[1];

            Mac mac = Mac.getInstance("HmacSHA256");

            mac.init(new SecretKeySpec(webhookSignatureSecret.trim().getBytes(StandardCharsets.UTF_8), "HmacSHA256"));

            byte[] expected = mac.doFinal(signingInput.getBytes(StandardCharsets.UTF_8));

            byte[] actual = Base64.getUrlDecoder().decode(parts[2]);

            if (!MessageDigest.isEqual(expected, actual)) {

                return false;

            }

            JsonNode claims = objectMapper.readTree(Base64.getUrlDecoder().decode(parts[1]));

            String payloadHash = asText(claims.get("payload_hash"));

            if (payloadHash == null) {

                // Signature alone is valid; a hash-less token cannot bind to this body.

                return true;

            }

            byte[] digest = MessageDigest.getInstance("SHA-256")

                    .digest((rawBody == null ? "" : rawBody).getBytes(StandardCharsets.UTF_8));

            return MessageDigest.isEqual(hex(digest).getBytes(StandardCharsets.UTF_8),

                    payloadHash.toLowerCase().getBytes(StandardCharsets.UTF_8));

        } catch (Exception e) {

            LOGGER.warn("Could not verify a Vonage webhook signature", e);

            return false;

        }

    }

    private String hex(byte[] bytes) {

        StringBuilder sb = new StringBuilder(bytes.length * 2);

        for (byte b : bytes) {

            sb.append(Character.forDigit((b >> 4) & 0xF, 16));

            sb.append(Character.forDigit(b & 0xF, 16));

        }

        return sb.toString();

    }

    // ---- helpers ------------------------------------------------------------------------------

    private String asText(JsonNode node) {

        if (node == null || node.isNull()) {

            return null;

        }

        String s = node.asText();

        return (s == null || s.trim().isEmpty()) ? null : s.trim();

    }

    private int asInt(JsonNode node) {

        return (node == null || node.isNull()) ? 0 : node.asInt(0);

    }

    private int parseInt(String s) {

        try {

            return (s == null || s.trim().isEmpty()) ? 0 : Integer.parseInt(s.trim());

        } catch (NumberFormatException e) {

            return 0;

        }

    }

    private String firstNonNull(String a, String b) {

        return a != null ? a : b;

    }

    /**

     * Vonage user name -> the agent mapping, which carries both our auth id and that agent's own

     * caller ID. Returns null when unmapped, leaving the call unattributed and falling back to the

     * default caller ID rather than attributing it to the wrong person — an orphan call is

     * recoverable, a misattributed recording is not.

     */

    private VonageAgent resolveAgent(String vonageUserName) {

        if (vonageUserName == null || vonageUserName.trim().isEmpty()) {

            LOGGER.warn("Vonage answer webhook carried no from_user — call will be unattributed");

            return null;

        }

        VonageAgent agent = vonageAgentRepository.selectByVonageUserName(vonageUserName);

        if (agent == null) {

            LOGGER.warn("No vonage_agent mapping for Vonage user '{}'", vonageUserName);

        }

        return agent;

    }

    private AuthUser currentUser(HttpServletRequest request) {

        try {

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            if (loginDetails != null && loginDetails.getEmailId() != null) {

                return authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

            }

        } catch (Exception e) {

            LOGGER.warn("Could not resolve the user for a dialer request", e);

        }

        return null;

    }

}