Subversion Repositories SmartDukaan

    private com.spice.profitmandi.dao.repository.dtr.BeatRepository beatRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.BeatScheduleRepository beatScheduleRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.BeatRouteRepository beatRouteRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadRouteRepository leadRouteRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadLiveLocationRepository leadLiveLocationRepository;

    @Autowired

    // Field-staff creates a lead from the planner — they're physically at the lead's

    // location, so we mark the geo APPROVED immediately (no link-and-approve cycle).

    @RequestMapping(value = "/lead-geo/self-approve", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({

            @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> selfApproveLeadGeo(javax.servlet.http.HttpServletRequest request,

                                                @RequestBody Map<String, Object> req) throws Exception {

        Integer leadId = req.get("leadId") instanceof Number ? ((Number) req.get("leadId")).intValue() : null;

        if (leadId == null || leadId <= 0) return responseSender.badRequest("leadId required");

        Object latObj = req.get("latitude"), lngObj = req.get("longitude");

        if (!(latObj instanceof Number) || !(lngObj instanceof Number)) return responseSender.badRequest("latitude/longitude required");

        double latitude = ((Number) latObj).doubleValue();

        double longitude = ((Number) lngObj).doubleValue();

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) return responseSender.badRequest("Lead not found");

        // Resolve approver from session, fall back to request body.

        int approverAuthId = 0;

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo != null && userInfo.getEmail() != null) {

            AuthUser sessionAuth = authRepository.selectByGmailId(userInfo.getEmail());

            if (sessionAuth != null) approverAuthId = sessionAuth.getId();

        }

        if (approverAuthId == 0 && req.get("authUserId") instanceof Number) {

            approverAuthId = ((Number) req.get("authUserId")).intValue();

        }

        int imageDocumentId = 0;

        if (req.get("imageDocumentId") instanceof Number) {

            imageDocumentId = ((Number) req.get("imageDocumentId")).intValue();

        }

        LocalDateTime now = LocalDateTime.now();

        com.spice.profitmandi.dao.entity.user.LeadLiveLocation existing = leadLiveLocationRepository.selectByLeadId(leadId);

        if (existing != null) {

            existing.setLatitude(latitude);

            existing.setLongitude(longitude);

            existing.setStatus(com.spice.profitmandi.dao.enumuration.dtr.GeoLocationStatus.APPROVED);

            existing.setReviewedBy(approverAuthId);

            existing.setReviewedTimestamp(now);

            existing.setSubmissionCount(existing.getSubmissionCount() + 1);

            existing.setMobileNumber(lead.getLeadMobile());

            if (imageDocumentId > 0) existing.setImageDocumentId(imageDocumentId);

            existing.setUpdatedTimestamp(now);

            existing.setRemark("Self-approved by field creator");

        } else {

            com.spice.profitmandi.dao.entity.user.LeadLiveLocation loc = new com.spice.profitmandi.dao.entity.user.LeadLiveLocation();

            loc.setLeadId(leadId);

            loc.setLatitude(latitude);

            loc.setLongitude(longitude);

            loc.setMobileNumber(lead.getLeadMobile());

            loc.setImageDocumentId(imageDocumentId);

            loc.setStatus(com.spice.profitmandi.dao.enumuration.dtr.GeoLocationStatus.APPROVED);

            loc.setReviewedBy(approverAuthId);

            loc.setReviewedTimestamp(now);

            loc.setSubmissionCount(1);

            loc.setRemark("Self-approved by field creator");

            loc.setCreatedTimestamp(now);

            loc.setUpdatedTimestamp(now);

            leadLiveLocationRepository.persist(loc);

        }

        LeadActivity activity = new LeadActivity();

        activity.setLeadId(leadId);

        activity.setRemark("Geolocation self-approved by field creator");

        activity.setAuthId(approverAuthId);

        activity.setCreatedTimestamp(now);

        leadActivityRepository.persist(activity);

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

        result.put("status", "approved");

        result.put("leadId", leadId);

        return responseSender.ok(result);

    }

    // Returns the field-staff person's upcoming beat-day chips (today + next N days) so

    // the partner app can present "Schedule on today vs future" right after a self-create.

    // The auth user is resolved from the session — matches the existing

    // BeatTrackingController.listBeats pattern (the client `userId` is unreliable).

    public ResponseEntity<?> upcomingBeatsForUser(javax.servlet.http.HttpServletRequest request, int days) throws Exception {

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo == null || userInfo.getEmail() == null) {

            return responseSender.badRequest("Auth session not found");

        }

        AuthUser authUser = authRepository.selectByGmailId(userInfo.getEmail());

        if (authUser == null) return responseSender.badRequest("Auth user not found");

        int authUserId = authUser.getId();

        LOGGER.info("upcomingBeatsForUser resolved authUserId={} from session email={}", authUserId, userInfo.getEmail());

        LocalDate today = LocalDate.now();

        LocalDate end = today.plusDays(days);

        List<com.spice.profitmandi.dao.entity.user.Beat> beats = beatRepository.selectActiveByAuthUserId(authUserId);

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

        for (com.spice.profitmandi.dao.entity.user.Beat b : beats) {

            List<com.spice.profitmandi.dao.entity.user.BeatSchedule> schedules =

                    beatScheduleRepository.selectByBeatIdAndDateRange(b.getId(), today, end);

            for (com.spice.profitmandi.dao.entity.user.BeatSchedule s : schedules) {

                if (s.getStartDate() == null || s.getStartDate().getYear() == 9999) continue;

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

                row.put("beatId", b.getId());

                row.put("beatName", b.getName());

                row.put("beatColor", b.getBeatColor());

                row.put("scheduleDate", s.getStartDate().toString());

                row.put("dayNumber", s.getDayNumber());

                row.put("isToday", today.equals(s.getStartDate()));

                out.add(row);

            }

        }

        out.sort(Comparator.comparing(r -> (String) r.get("scheduleDate")));

        return responseSender.ok(out);

    }

    // Attaches a (just-created, self-approved) lead to a sales user's beat on a given

    // date. Inserts a LeadRoute row with status=APPROVED; idempotent on re-call.

    // The auth user is resolved from the session token, not the request body.

    public ResponseEntity<?> scheduleLeadOnBeat(javax.servlet.http.HttpServletRequest request,

                                                Map<String, Object> req) throws Exception {

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo == null || userInfo.getEmail() == null) {

            return responseSender.badRequest("Auth session not found");

        }

        AuthUser sessionAuth = authRepository.selectByGmailId(userInfo.getEmail());

        if (sessionAuth == null) return responseSender.badRequest("Auth user not found");

        int authUserId = sessionAuth.getId();

        Integer leadId = req.get("leadId") instanceof Number ? ((Number) req.get("leadId")).intValue() : null;

        Integer beatId = req.get("beatId") instanceof Number ? ((Number) req.get("beatId")).intValue() : null;

        Object dateObj = req.get("scheduleDate");

        if (leadId == null || beatId == null || dateObj == null) {

            return responseSender.badRequest("leadId, beatId and scheduleDate are required");

        }

        LocalDate scheduleDate;

        try {

            scheduleDate = LocalDate.parse(dateObj.toString());

        } catch (Exception e) {

            return responseSender.badRequest("scheduleDate must be yyyy-MM-dd");

        }

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) return responseSender.badRequest("Lead not found");

        // Beat must actually run on the chosen date — same guard as the panel-side flow.

        List<com.spice.profitmandi.dao.entity.user.BeatSchedule> match =

                beatScheduleRepository.selectByBeatIdAndDateRange(beatId, scheduleDate, scheduleDate);

        if (match.isEmpty()) return responseSender.badRequest("Beat is not scheduled on " + scheduleDate);

        // Idempotency: skip if the same lead is already pinned to this beat-day.

        boolean exists = leadRouteRepository.selectByBeatId(beatId).stream()

                .anyMatch(lr -> lr.getLeadId() == leadId

                        && scheduleDate.equals(lr.getScheduleDate())

                        && !"CANCELLED".equals(lr.getStatus()));

        if (exists) {

            return responseSender.ok(Collections.singletonMap("status", "already_scheduled"));

        }

        // Append at the end of the day's existing stops.

        int seq = beatRouteRepository.selectByBeatId(beatId).size() + 1;

        com.spice.profitmandi.dao.entity.user.LeadRoute lr = new com.spice.profitmandi.dao.entity.user.LeadRoute();

        lr.setBeatId(beatId);

        lr.setLeadId(leadId);

        lr.setScheduleDate(scheduleDate);

        lr.setSequenceOrder(seq);

        lr.setStatus("APPROVED");

        lr.setRequestedBy(authUserId);

        lr.setApprovedBy(authUserId);

        LocalDateTime now = LocalDateTime.now();

        lr.setApprovedTimestamp(now);

        lr.setCreatedTimestamp(now);

        lr.setUpdatedTimestamp(now);

        leadRouteRepository.persist(lr);

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

        result.put("status", "scheduled");

        result.put("scheduleDate", scheduleDate.toString());

        return responseSender.ok(result);

    }

        // Return the new lead's id alongside the legacy `success: true` flag so callers

        // that need to chain follow-up actions (e.g., the partner app's self-create →

        // self-approve geo → schedule on beat flow) can do so without an extra lookup.

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

        body.put("success", true);

        body.put("leadId", lead.getId());