Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.model.UserInfo;
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.model.lms.LeadDispositionRequest;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.service.lms.LmsCallService;
import com.spice.profitmandi.service.lms.LmsDispositionService;
import com.spice.profitmandi.service.lms.LmsOutcome;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

/**
 * The field app's LMS dialer: place a recorded call to a lead from a beat stop, watch it, end it,
 * and record what came of it.
 *
 * <p>Same calls as the desk console's {@code /lms/dialer/*}, and deliberately the same services
 * underneath ({@link LmsCallService}, {@link LmsDispositionService}) so a rep's call is
 * indistinguishable from a BGC agent's in every LMS report — same {@code user.lead_call} row, same
 * recording archived to our own bucket, same first-contact SLA stamp, same trail entry. Only the
 * identity step differs: the console reads a session cookie, this reads the app's {@code Auth-Token}.
 *
 * <p><b>Not under {@code /clickToCall}.</b> That prefix is excluded from {@code
 * SimpleCORSInterceptor} in {@code WebMVCConfig} for the legacy Knowlarity endpoints, and a new
 * path starting with it would silently inherit the exclusion.
 */
@Controller
@Transactional(rollbackFor = Throwable.class)
public class LmsAppCallController {

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

    @Autowired
    private LmsCallService lmsCallService;

    @Autowired
    private LmsDispositionService lmsDispositionService;

    @Autowired
    private AuthRepository authRepository;

    @Autowired
    private ResponseSender<?> responseSender;

    /** Gate a dial before it happens: DND and TRAI calling hours. */
    @RequestMapping(value = "/lms/call/precheck", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> precheck(HttpServletRequest request,
                                      @RequestParam(name = "leadId") int leadId) {
        AuthUser agent = currentUser(request);
        if (agent == null) {
            return unauthorized();
        }
        return renderAllowingRefusal(lmsCallService.precheck(leadId));
    }

    /**
     * Place the call. The rep's own VBC endpoint rings first, then VBC dials the retailer.
     *
     * <p>{@code leadId} is a query parameter rather than a JSON body on purpose: {@code
     * PostInterceptor} de-duplicates POSTs for 300 seconds by hashing the body when no
     * {@code IdempotencyKey} is present, and two identical bodies would make a rep's second attempt
     * at the same lead fail with "Duplicate request." instead of dialling.
     */
    @RequestMapping(value = "/lms/call/dial", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> dial(HttpServletRequest request,
                                  @RequestParam(name = "leadId") int leadId) {
        AuthUser agent = currentUser(request);
        if (agent == null) {
            return unauthorized();
        }
        return renderAllowingRefusal(lmsCallService.dial(agent, leadId));
    }

    /**
     * Poll one call's live state. Click2dial has no event webhook, so the app has to ask — and this
     * is also what advances the stored row, so a call nobody polls never reaches a terminal state.
     */
    @RequestMapping(value = "/lms/call/state", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<?> state(HttpServletRequest request,
                                   @RequestParam(name = "leadCallId") int leadCallId) {
        AuthUser agent = currentUser(request);
        if (agent == null) {
            return unauthorized();
        }
        return render(lmsCallService.state(agent, leadCallId));
    }

    /** Hang up a call the rep placed. */
    @RequestMapping(value = "/lms/call/hangup", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> hangup(HttpServletRequest request,
                                    @RequestParam(name = "leadCallId") int leadCallId) {
        AuthUser agent = currentUser(request);
        if (agent == null) {
            return unauthorized();
        }
        return render(lmsCallService.hangup(agent, leadCallId));
    }

    /** Record what came of the call: disposition, stage move, SLA stamp, trail entry. */
    @RequestMapping(value = "/lms/call/disposition", method = RequestMethod.POST,
            consumes = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public ResponseEntity<?> disposition(HttpServletRequest request,
                                         @RequestBody LeadDispositionRequest body) {
        AuthUser agent = currentUser(request);
        if (agent == null) {
            return unauthorized();
        }
        LmsOutcome outcome = lmsDispositionService.apply(agent, body);
        if (outcome.isOk()) {
            Lead lead = (Lead) outcome.data.get("lead");
            java.util.Map<String, Object> out = new java.util.LinkedHashMap<>();
            out.put("ok", true);
            out.put("leadId", lead.getId());
            out.put("stage", outcome.data.get("stage"));
            out.put("leadCallId", outcome.data.get("leadCallId"));
            return responseSender.ok(out);
        }
        return render(outcome);
    }

    /**
     * As {@link #render}, but a refusal comes back as a 200 carrying {@code {ok:false, code, reason}}.
     *
     * <p>"This retailer is on the do-not-call register" and "it is past 21:00" are correct answers
     * to a request to dial, not failures of it. They matter because the app's HTTP interceptor
     * auto-toasts every 4xx in red: sending a 4xx here would show the rep an error for behaving
     * exactly as the rules require, on top of the explanation the call sheet already gives them.
     */
    private ResponseEntity<?> renderAllowingRefusal(LmsOutcome outcome) {
        if (outcome.status == LmsOutcome.Status.REFUSED) {
            return responseSender.ok(outcome.asRefusalBody());
        }
        return render(outcome);
    }

    /** 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 unauthorized();
            case FORBIDDEN:
                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
            default:
                return responseSender.badRequest(outcome.message);
        }
    }

    private ResponseEntity<?> unauthorized() {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
    }

    /**
     * The field rep behind this request.
     *
     * <p>Follows the beat/PJP idiom ({@code BeatTrackingController.listBeats}): resolve from the
     * token's email against {@code gmail_id}, never from a client-supplied user id. Null-checked by
     * every caller because {@code AuthenticationInterceptor} lets a request through when the
     * {@code Auth-Token} header is absent entirely — it only rejects a token it cannot parse.
     */
    private AuthUser currentUser(HttpServletRequest request) {
        try {
            UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
            if (userInfo == null || userInfo.getEmail() == null) {
                return null;
            }
            return authRepository.selectByGmailId(userInfo.getEmail());
        } catch (Exception e) {
            LOGGER.warn("Could not resolve the user for an LMS call request", e);
            return null;
        }
    }
}