Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.enumuration.ActivationType;

import com.spice.profitmandi.common.enumuration.CounterSize;

import com.spice.profitmandi.common.enumuration.MessageType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.*;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.Utils;

import com.spice.profitmandi.common.util.Utils.Attachment;

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

import com.spice.profitmandi.service.mail.MailOutboxService;

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

import com.spice.profitmandi.dao.entity.catalog.*;

import com.spice.profitmandi.dao.entity.cs.Region;

import com.spice.profitmandi.dao.entity.fofo.*;

import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;

import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;

import com.spice.profitmandi.dao.entity.transaction.Loan;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.transaction.SDCreditRequirement;

import com.spice.profitmandi.dao.model.BulkCreditSummary;

import com.spice.profitmandi.service.transaction.SDCreditService;

import com.spice.profitmandi.dao.entity.transaction.UserWallet;

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

import com.spice.profitmandi.dao.entity.warehouse.BrandRegionMapping;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.inventory.CatalogMovingEnum;

import com.spice.profitmandi.dao.event.TagListingEventPublisher;

import com.spice.profitmandi.dao.model.*;

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

import com.spice.profitmandi.dao.repository.catalog.*;

import com.spice.profitmandi.dao.repository.cs.*;

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

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

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

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

import com.spice.profitmandi.dao.repository.fofo.*;

import com.spice.profitmandi.dao.repository.inventory.SaholicCISTableRepository;

import com.spice.profitmandi.dao.repository.inventory.SaholicInventoryCISRepository;

import com.spice.profitmandi.dao.repository.inventory.WarehouseRepository;

import com.spice.profitmandi.dao.repository.transaction.LoanRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.transaction.SDCreditRequirementRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

import com.spice.profitmandi.dao.repository.warehouse.BrandRegionMappingRepository;

import com.spice.profitmandi.model.WarehouseItemQtyModel;

import com.spice.profitmandi.service.FofoUser;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.RbmTargetService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.inventory.*;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.wallet.WalletService;

import com.spice.profitmandi.thrift.clients.PaymentClient;

import com.spice.profitmandi.thrift.clients.UserClient;

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

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

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

import in.shop2020.model.v1.order.LineItem;

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.model.v1.order.Transaction;

import in.shop2020.model.v1.user.ItemPriceQuantity;

import in.shop2020.model.v1.user.ShoppingCartException;

import in.shop2020.model.v1.user.UserContextService.Client;

import in.shop2020.payments.Attribute;

import in.shop2020.payments.PaymentException;

import in.shop2020.payments.PaymentStatus;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.thrift.TException;

import org.json.JSONArray;

import org.json.JSONObject;

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

import org.springframework.core.io.ByteArrayResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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 javax.servlet.http.HttpServletRequest;

import java.math.BigDecimal;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.YearMonth;

import java.util.*;

import java.util.Map.Entry;

import java.util.function.Function;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class IndentController {

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

    private static final int WALLET_GATEWAY_ID = 8;

    private static final Set<Integer> defaultTags = new HashSet<Integer>(Arrays.asList(4));

    private final List<OrderStatus> partnerPendingOrderList = Arrays.asList(OrderStatus.ACCEPTED,

            OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,

            OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,

            OrderStatus.REACHED_DESTINATION_CITY);

    private static final int PLANNING_OPEN_DAY = 20;

    private static final int PLANNING_CLOSE_DAY = 1;

    private static final String PO_TITLE_STRING = "Alert - Stock Arriving at SD Warehouse";

    @Autowired

    WalletService walletService;

    @Autowired

    BrandRegionMappingRepository brandRegionMappingRepository;

    @Autowired

    private JavaMailSender googleMailSender;

    @Autowired

    private MailOutboxService mailOutboxService;

    @Autowired

    private ResponseSender responseSender;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private UserWalletRepository userWalletRepository;

    @Autowired

    private UserRepository userRepository;

    @Autowired

    FofoStoreRepository fofoStoreRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private StockAllocationService stockAllocationService;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private TagListingEventPublisher tagListingEventPublisher;

    @Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private PurchaseRepository purchaseRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private FocusedModelRepository focusedModelRepository;

    @Autowired

    private MonthlyPlannedRepository monthlyPlannedRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private PlannedDetailRepository plannedDetailRepository;

    @Autowired

    RoleManager roleManager;

    @Autowired

    PartnerTypeChangeRepository partnerTypeChangeRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private InventoryService inventoryService;

    @Autowired

    private CsService1 csService1;

    @Autowired

    private CsService csService;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    WarehouseRepository warehouseRepository;

    @Autowired

    private SuggestedPoRepository suggestedPoRepository;

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private RegionRepository regionRepository;

    @Autowired

    private PartnerRegionRepository partnerRegionRepository;

    @Autowired

    private SaholicInventoryCISRepository saholicInventoryCISRepository;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Autowired

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private SuggestedPoDetailRepository suggestedPoDetailRepository;

    @Autowired

    SaholicCISTableRepository saholicCISTableRepository;

    @Autowired

    MonthlyTargetRepository monthlyTargetRepository;

    @Autowired

    AgeingService ageingService;

    @Autowired

    LoanRepository loanRepository;

    @Autowired

    SDCreditService sdCreditService;

    @Autowired

    RbmTargetService rbmTargetService;

    @Autowired

    FofoUser fofoUser;

    @Autowired

    BrandsService brandsService;

    @Autowired

    SDCreditRequirementRepository sdCreditRequirementRepository;

    @Autowired

    CategorisedCatalogRepository categorisedCatalogRepository;

    @RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)

    public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,

                                 @RequestParam int itemQty, @RequestParam int fofoId) throws Exception {

        if (fofoId == 0) {

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            fofoId = loginDetails.getFofoId();

        }

        LocalDate currentMonthDate = LocalDate.now();

        MonthlyPlanned monthlyPlanned = null;

        if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

            currentMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);

            LOGGER.info("monthlyPlanned" + monthlyPlanned);

            saveMonthlyPlanned(monthlyPlanned, fofoId, currentMonthDate, catalogId, itemQty);

        }

        model.addAttribute("response1", mvcResponseSender.createResponseString(false));

        return "response";

    }

    private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,

                                    int catalogId, int itemQty) {

        if (monthlyPlanned == null) {

            monthlyPlanned = new MonthlyPlanned();

            monthlyPlanned.setFofoId(fofoId);

            monthlyPlanned.setYearMonth(currentMonthDate);

            monthlyPlannedRepository.persist(monthlyPlanned);

            PlannedDetail pd = new PlannedDetail();

            pd.setCatalogId(catalogId);

            pd.setPlannedId(monthlyPlanned.getId());

            pd.setQuantity(itemQty);

            pd.setUpdatedTimestamp(LocalDateTime.now());

            plannedDetailRepository.persist(pd);

        } else {

            PlannedDetail plannedDetail = plannedDetailRepository.selectByPlannedIdCatalogId(monthlyPlanned.getId(),

                    catalogId);

            if (plannedDetail == null) {

                plannedDetail = new PlannedDetail();

                plannedDetail.setCatalogId(catalogId);

                plannedDetail.setPlannedId(monthlyPlanned.getId());

                plannedDetail.setQuantity(itemQty);

                plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

                plannedDetailRepository.persist(plannedDetail);

            } else if (itemQty == 0) {

                plannedDetailRepository.delete(plannedDetail);

            } else {

                plannedDetail.setCatalogId(catalogId);

                plannedDetail.setQuantity(itemQty);

                plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

            }

        }

    }

    @RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)

    public String confirmOpenIndent(HttpServletRequest request,

                                    @RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {

        if (fofoId == 0) {

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            fofoId = loginDetails.getFofoId();

        }

        CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

        LocalDate currentDate = LocalDate.now();

        LocalDate planningMonthDate = null;

        MonthlyPlanned monthlyPlanned = null;

        if (currentDate.isAfter(currentDate.withDayOfMonth(PLANNING_OPEN_DAY))) {

            planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            confirmMonthlyPlanned(monthlyPlanned, customRetailer, fofoId);

        } else if (currentDate.isBefore(currentDate.withDayOfMonth(8))) {

            planningMonthDate = LocalDate.now().withDayOfMonth(1);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            confirmMonthlyPlanned(monthlyPlanned, customRetailer, fofoId);

        }

        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        return "response";

    }

    private void confirmMonthlyPlanned(MonthlyPlanned monthlyPlanned, CustomRetailer customRetailer, int fofoId)

            throws Exception {

        List<PlannedDetail> plannedDetails = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId());

        List<PlannedModel> plannedModel = new ArrayList<>();

        for (PlannedDetail plannedDetail : plannedDetails) {

            List<Item> items = itemRepository.selectAllByCatalogItemId(plannedDetail.getCatalogId());

            String itemDesription = items.get(0).getItemDescriptionNoColor();

            PlannedModel pm = new PlannedModel();

            pm.setItemDescription(itemDesription);

            pm.setStoreName(customRetailer.getBusinessName());

            pm.setQty(plannedDetail.getQuantity());

            pm.setFofoId(fofoId);

            plannedModel.add(pm);

            LOGGER.info("plannedModel" + plannedModel);

        }

        List<String> ccemails = new ArrayList<>();

        LOGGER.info("ccemails" + ccemails);

        Map<EscalationType, String> emailEsclationType = csService.getAuthUserAndEsclationTypeByPartnerId(fofoId);

        LOGGER.info("emailEsclationType" + emailEsclationType);

        if (emailEsclationType.get(EscalationType.L1) != null) {

            ccemails.add(emailEsclationType.get(EscalationType.L1));

        }

        if (emailEsclationType.get(EscalationType.L2) != null) {

            ccemails.add(emailEsclationType.get(EscalationType.L2));

        }

        LOGGER.info("ccemails" + ccemails);

        List<String> bccemails = new ArrayList<>();

        bccemails.add(emailEsclationType.get(EscalationType.L3));

        LOGGER.info("bccemails" + bccemails);

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),

                plannedModel.stream()

                        .map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))

                        .collect(Collectors.toList()));

        LOGGER.info("baos" + baos);

        mailOutboxService.queueMailWithAttachmentsViaGoogle(new String[]{customRetailer.getEmail()},

                ccemails.toArray(new String[ccemails.size()]), bccemails.toArray(new String[bccemails.size()]),

                "Planned Indent", "PFA", false, "IndentController.confirmMonthlyPlanned",

                new Attachment("PlannedIndent.csv", new ByteArrayResource(baos.toByteArray())));

    }

    @RequestMapping(value = "/indent/download", method = RequestMethod.GET)

    public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,

                                                            @RequestParam(required = false, defaultValue = "0") int fofoId,

                                                            @RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Set<Integer> roleIds = loginDetails.getRoleIds();

        LOGGER.info("Counter size is {}", counterSize);

        LOGGER.info("Fofo Id is {}", fofoId);

        if (roleManager.isAdmin(roleIds) || loginDetails.getFofoId() == fofoId) {

            List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())

                    .collect(Collectors.toList());

            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

            Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x))

                    .filter(x -> x != null).collect(Collectors.toList()).stream()

                    .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

            List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,

                    true);

            Map<Integer, Integer> modelStockAllocationMap = stockAllocationList.stream()

                    .collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getQuantity()));

            Map<String, Integer> catalogUserQtyMap = new HashMap<>();

            currentInventorySnapshotRepository.selectByFofoId(fofoId).stream().forEach(x -> {

                int retailerId = x.getFofoId();

                int catalogId;

                try {

                    catalogId = itemRepository.selectById(x.getItemId()).getCatalogItemId();

                    String key = catalogId + "-" + retailerId;

                    if (!catalogUserQtyMap.containsKey(key)) {

                        catalogUserQtyMap.put(key, 0);

                    }

                    catalogUserQtyMap.put(key, catalogUserQtyMap.get(key) + x.getAvailability());

                } catch (ProfitMandiBusinessException e) {

                    // TODO Auto-generated catch block

                    throw new RuntimeException(e);

                }

            });

            List<Order> inTransitOrders = orderRepository.selectOrders(fofoIds, partnerPendingOrderList);

            Map<String, Integer> catalogUserInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> {

                try {

                    return itemRepository.selectById(x.getLineItem().getItemId()).getCatalogItemId() + "-"

                            + x.getRetailerId();

                } catch (ProfitMandiBusinessException e) {

                    // TODO Auto-generated catch block

                    return "";

                }

            }, Collectors.summingInt(x -> x.getLineItem().getQuantity())));

            Map<String, CatalogListingModel> catalogListingMap = new HashMap<>();

            List<TagListing> tagListings = tagListingRepository.selectAll(true);

            Iterator<TagListing> iterator = tagListings.iterator();

            while (iterator.hasNext()) {

                TagListing tagListing = iterator.next();

                Item item = itemRepository.selectById(tagListing.getItemId());

                int catalogId = item.getCatalogItemId();

                if (item.getCategoryId() != 10006) {

                    continue;

                }

                int catalogStockAllocationQuantity = modelStockAllocationMap.containsKey(catalogId)

                        ? modelStockAllocationMap.get(catalogId)

                        : 0;

                for (int retailerId : fofoIds) {

                    String key = catalogId + "-" + retailerId;

                    if (catalogListingMap.containsKey(key)) {

                        continue;

                    }

                    int catalogInTransit = catalogUserInTransit.containsKey(key) ? catalogUserInTransit.get(key) : 0;

                    int catalogInStock = catalogUserQtyMap.containsKey(key) ? catalogUserQtyMap.get(key) : 0;

                    if (catalogInTransit + catalogInStock == 0 && catalogStockAllocationQuantity == 0) {

                        continue;

                    }

                    CatalogListingModel catalogListingModel = new CatalogListingModel();

                    catalogListingModel.setFofoId(retailerId);

                    catalogListingModel.setModelName(item.getModelName());

                    catalogListingModel.setModelNumber(item.getModelNumber());

                    catalogListingModel.setCatalogId(catalogId);

                    catalogListingModel.setDp(tagListing.getSellingPrice());

                    catalogListingModel.setMop(tagListing.getMop());

                    catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

                    catalogListingModel.setAllocatedQuantity(catalogStockAllocationQuantity);

                    catalogListingModel.setInTransitQuantity(catalogInTransit);

                    catalogListingModel

                            .setToBeOrdered(catalogStockAllocationQuantity - catalogInTransit - catalogInStock);

                    catalogListingModel.setStockInHand(catalogInStock);

                    catalogListingModel.setBrand(item.getBrand());

                    catalogListingModel.setModelName(item.getModelName());

                    catalogListingModel.setModelNumber(item.getModelNumber());

                    catalogListingModel.setCategoryId(item.getCategoryId());

                    catalogListingMap.put(key, catalogListingModel);

                }

            }

            List<List<?>> listOfRows = new ArrayList<>();

            for (CatalogListingModel clm : catalogListingMap.values()) {

                CustomRetailer cr = crm.get(clm.getFofoId());

                listOfRows.add(Arrays.asList(cr.getPartnerId(), cr.getBusinessName(), clm.getCatalogId(),

                        clm.getBrand(), clm.getModelName(), clm.getModelNumber(), clm.getDp(), clm.getMop(),

                        clm.getAllocatedQuantity(), clm.getInTransitQuantity(), clm.getStockInHand(),

                        clm.getToBeOrdered()));

            }

            ByteArrayOutputStream baos = FileUtil

                    .getCSVByteStream(

                            Arrays.asList("StoreId", "StoreName", "Catalog Id", "Brand", "Model Name", "Model Number",

                                    "DP", "MOP", "Allocated Quantity", "In Transit", "Stock In hand", "Shortage"),

                            listOfRows);

            HttpHeaders headers = new HttpHeaders();

            headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

            headers.set("Content-disposition", "inline; filename=retailer-allocation.csv");

            return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(baos.toByteArray()), headers,

                    HttpStatus.OK);

        }

        return null;

    }

    @RequestMapping(value = "/itemsByCatalogId")

    public String getItemsByCatalogId(HttpServletRequest request, Model model,

                                      @RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)

            throws ProfitMandiBusinessException {

        if (catalogId == 0) {

            catalogId = itemRepository.selectById(itemId).getCatalogItemId();

        }

        List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);

        LOGGER.info("Items {}", items);

        Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

                .collect(Collectors.toMap(Item::getId, Item::getColor));

        Map<Integer, TagListing> tagsMap = tagListingRepository

                .selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

                .stream().collect(Collectors.toMap(TagListing::getItemId, x -> x));

        LOGGER.info("Items color map {}", itemsColorMap);

        JSONArray response = new JSONArray();

        itemsColorMap.keySet().stream().forEach(x -> {

            response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("active",

                    tagsMap.get(x) == null ? false : tagsMap.get(x).isActive()));

        });

        model.addAttribute("response1", response.toString());

        return "response";

    }

    @RequestMapping(value = "/hotdealsitemsByCatalogId")

    public String getHotdealsitemsByCatalogId(HttpServletRequest request, Model model,

                                              @RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)

            throws ProfitMandiBusinessException {

        if (catalogId == 0) {

            catalogId = itemRepository.selectById(itemId).getCatalogItemId();

        }

        List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);

        LOGGER.info("Items {}", items);

        Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

                .collect(Collectors.toMap(Item::getId, Item::getColor));

        Map<Integer, TagListing> tagsMap = tagListingRepository

                .selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

                .stream().collect(Collectors.toMap(TagListing::getItemId, x -> x));

        LOGGER.info("Items color map {}", itemsColorMap);

        JSONArray response = new JSONArray();

        itemsColorMap.keySet().stream().forEach(x -> {

            response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("hotDeals",

                    tagsMap.get(x) == null ? false : tagsMap.get(x).isHotDeals()));

        });

        model.addAttribute("response1", response.toString());

        return "response";

    }

    private List<Order> filterValidOrders(List<Order> lastOrdersList) {

        int orderRemovedCount = 0;

        Iterator<Order> orderIterator = lastOrdersList.iterator();

        while (orderIterator.hasNext()) {

            Order o = orderIterator.next();

            if (o.getInvoiceNumber() != null) {

                try {

                    purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());

                    orderIterator.remove();

                    orderRemovedCount++;

                } catch (Exception e) {

                }

            }

        }

        LOGGER.info("Order removed count is {}", orderRemovedCount);

        return lastOrdersList;

    }

    // Clean up the saholic cis table

    @RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)

    public String updateTagListing(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

            throws Exception {

        JSONArray jsonArray = new JSONArray(jsonArrayString);

        Set<Integer> updatedCatalogIds = new HashSet<>();

        for (int i = 0; i < jsonArray.length(); i++) {

            JSONObject obj = jsonArray.getJSONObject(i);

            int itemId = obj.getInt("id");

            TagListing tl = tagListingRepository.selectByItemId(itemId);

            if (tl == null) {

                continue;

            } else {

                tl.setActive(obj.getBoolean("active"));

                if (!tl.isActive()) {

                    saholicCISTableRepository.selectAllByItemId(tl.getItemId()).stream()

                            .forEach(x -> saholicCISTableRepository.delete(x));

                }

                // Collect catalogIds for Solr updates

                try {

                    Item item = itemRepository.selectById(itemId);

                    updatedCatalogIds.add(item.getCatalogItemId());

                } catch (Exception e) {

                    LOGGER.error("Failed to get catalogId for itemId: {}", itemId, e);

                }

            }

        }

        // Publish events for all updated catalogs

        for (Integer catalogId : updatedCatalogIds) {

            try {

                tagListingEventPublisher.publishStatusChange(0, catalogId);

            } catch (Exception e) {

                LOGGER.error("Failed to publish status change event for catalogId: {}", catalogId, e);

            }

        }

        model.addAttribute("response1", true);

        return "response";

    }

    @RequestMapping(value = "/indent/confirm-hotdeals-pause", method = RequestMethod.POST)

    public String hotdealUpdate(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

            throws Exception {

        JSONArray jsonArray = new JSONArray(jsonArrayString);

        Set<Integer> updatedCatalogIds = new HashSet<>();

        for (int i = 0; i < jsonArray.length(); i++) {

            JSONObject obj = jsonArray.getJSONObject(i);

            int itemId = obj.getInt("id");

            TagListing tl = tagListingRepository.selectByItemId(itemId);

            if (tl == null) {

                continue;

            } else {

                tl.setHotDeals(obj.getBoolean("hotDeals"));

                tagListingRepository.persist(tl);

                // Collect catalogIds for Solr updates

                try {

                    Item item = itemRepository.selectById(itemId);

                    updatedCatalogIds.add(item.getCatalogItemId());

                } catch (Exception e) {

                    LOGGER.error("Failed to get catalogId for itemId: {}", itemId, e);

                }

            }

        }

        // Publish events for all updated catalogs

        for (Integer catalogId : updatedCatalogIds) {

            try {

                tagListingEventPublisher.publishStatusChange(0, catalogId);

            } catch (Exception e) {

                LOGGER.error("Failed to publish status change event for catalogId: {}", catalogId, e);

            }

        }

        model.addAttribute("response1", true);

        return "response";

    }

    private void createPayment(User user, double totalAmount, long transactionId)

            throws NumberFormatException, PaymentException, TException {

        List<Attribute> paymentAttributes = new ArrayList<Attribute>();

        in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();

        paymentAttributes.add(new Attribute("payMethod", "7890"));

        long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,

                false);

        paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,

                PaymentStatus.SUCCESS, null, paymentAttributes);

    }

    @RequestMapping(value = "/indent/loadIndent")

    public String loadOpenIndent(HttpServletRequest request, Model model,

                                 @RequestParam(required = false, defaultValue = "0") int fofoId,

                                 @RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Set<Integer> roleIds = loginDetails.getRoleIds();

        LOGGER.info("Counter size is {}", counterSize);

        LOGGER.info("Fofo Id is {}", fofoId);

        boolean isAdmin = roleManager.isAdmin(roleIds);

        List<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toList());

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

        equalsMap.put("categoryId", 10006);

        equalsMap.put("brand", brands);

        Map<String, List<?>> notEqualsMap = new HashMap<>();

        Map<String, List<?>> notEqualsJoinMap = new HashMap<>();

        Map<Integer, Integer> currentStockMap;

        if (!isAdmin && fofoId == 0) {

            fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();

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

            equalsStockJoinMap.put("fofoId", fofoId);

            currentStockMap = itemRepository

                    .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                            equalsStockJoinMap, notEqualsJoinMap, "availability")

                    .stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));

            LOGGER.info("currentStock");

        } else {

            if (fofoId == 0) {

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

                equalsStockJoinMap.put("fofoId", fofoId);

                currentStockMap = itemRepository

                        .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                                equalsStockJoinMap, notEqualsJoinMap, "availability")

                        .stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));

            } else {

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

                equalsStockJoinMap.put("fofoId", fofoId);

                currentStockMap = itemRepository

                        .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                                equalsStockJoinMap, notEqualsJoinMap, "availability")

                        .stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));

            }

        }

        LOGGER.info("currentStock" + currentStockMap);

        Map<Integer, Integer> itemsInTransit = null;

        List<TagListing> tagListings = tagListingRepository.selectAll(true);

        if (!isAdmin) {

            tagListings = new ArrayList<>(tagListings);

            List<Order> inTransitOrders = orderRepository.selectPendingGrnOrder(fofoId,

                    OrderRepository.validOrderStatusList);

            inTransitOrders = this.filterValidOrders(inTransitOrders);

            itemsInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),

                    Collectors.summingInt(x -> x.getLineItem().getQuantity())));

        } else {

            itemsInTransit = new HashMap<>();

        }

        int totalPcs = 0;

        float totalAmount = 0;

        Map<Integer, CatalogListingModel> catalogListingMap = new HashMap<>();

        List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())

                .collect(Collectors.toList());

        LOGGER.info("regionIds" + regionIds);

        Map<Integer, FocusedModel> focusedModelMap = focusedModelRepository.selectAllByRegionIds(regionIds).stream()

                .collect(Collectors.toMap(FocusedModel::getCatalogId, Function.identity()));

        LOGGER.info("focusedModelMap" + focusedModelMap);

        LocalDate planningMonthDate = null;

        MonthlyPlanned monthlyPlanned = null;

        List<Integer> fofoOrderIds = null;

        LOGGER.info("localDate" + LocalDate.now());

        if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

            planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            LOGGER.info("monthlyPlanned2" + monthlyPlanned);

            fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),

                            LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())

                    .collect(Collectors.toList());

            model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());

        } else if (LocalDate.now().isBefore(LocalDate.now().withDayOfMonth(8))) {

            planningMonthDate = LocalDate.now().withDayOfMonth(8);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            LOGGER.info("monthlyPlanned2" + monthlyPlanned);

            fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),

                            LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())

                    .collect(Collectors.toList());

            model.addAttribute("planningMonth", LocalDate.now().getMonth());

        } else {

            planningMonthDate = LocalDate.now().withDayOfMonth(1);

            LocalDateTime curDate = LocalDate.now().atStartOfDay();

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            model.addAttribute("planningMonth", planningMonthDate.getMonth());

            model.addAttribute("mtd", true);

            model.addAttribute("freezed", true);

            fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),

                            curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())

                    .collect(Collectors.toList());

            LOGGER.info("monthlyPlanned1" + monthlyPlanned);

        }

        Map<Integer, Integer> plannedDetailMap = null;

        if (monthlyPlanned != null) {

            plannedDetailMap = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId()).stream()

                    .collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getQuantity()));

        }

        LOGGER.info("plannedDetailMap" + plannedDetailMap);

        LOGGER.info("fofoOrderIds" + fofoOrderIds);

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

        equalsJoinMap.put("orderId", fofoOrderIds);

        Map<Integer, Integer> last15daysMap = null;

        if (fofoOrderIds != null && !fofoOrderIds.isEmpty()) {

            last15daysMap = itemRepository

                    .selectItems(FofoOrderItem.class, "id", "itemId", equalsMap, notEqualsMap, equalsJoinMap,

                            notEqualsJoinMap, "quantity")

                    .stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));

        }

        LOGGER.info("last15daysMap" + last15daysMap);

        Map<Integer, TagListing> taglistingMap = tagListings.stream()

                .collect(Collectors.toMap(x -> x.getItemId(), x -> x));

        List<Item> items = itemRepository.selectByIds(taglistingMap.keySet());

        Map<Integer, List<Item>> catalogIdItemMap = items.stream().collect(

                Collectors.groupingBy(x -> x.getCatalogItemId(), Collectors.mapping(y -> y, Collectors.toList())));

        LOGGER.info("catalogIdItemMap");

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

        equalsItemJoinMap.put("active", 1);

        List<IntegerIdAggregateValue> tagListingCatalogIds = itemRepository.selectItems(TagListing.class, "id",

                "itemId", equalsMap, notEqualsMap, equalsItemJoinMap, notEqualsJoinMap, "tagId");

        LOGGER.info("tagListingCatalogIds");

        for (IntegerIdAggregateValue catalogIdAggregateValue : tagListingCatalogIds) {

            int catalogId = catalogIdAggregateValue.getCatalogId();

            Item item = catalogIdItemMap.get(catalogId).get(0);

            TagListing tagListing = taglistingMap.get(item.getId());

            CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);

            if (!catalogListingMap.containsKey(catalogId)) {

                catalogListingModel = new CatalogListingModel();

                catalogListingModel.setCatalogId(catalogId);

                catalogListingModel.setDp(tagListing.getSellingPrice());

                catalogListingModel.setMop(tagListing.getMop());

                catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

                if (plannedDetailMap != null) {

                    Integer quantity = plannedDetailMap.get(catalogId);

                    if (quantity != null) {

                        catalogListingModel.setAllocatedQuantity(quantity);

                    }

                }

                if (last15daysMap != null) {

                    Integer last15DaysSale = last15daysMap.get(catalogId);

                    if (last15DaysSale != null) {

                        catalogListingModel.setLast15DaysSale(last15DaysSale);

                    } else {

                        catalogListingModel.setLast15DaysSale(0);

                    }

                } else {

                    catalogListingModel.setLast15DaysSale(0);

                }

                catalogListingModel.setBrand(item.getBrand());

                if (item.getCategoryId() == 10006) {

                    catalogListingModel.setCategoryId(item.getCategoryId());

                }

                FocusedModel fm = focusedModelMap.get(catalogId);

                if (fm != null) {

                    catalogListingModel.setRecommendedQty(fm.getRecommendedQty());

                    catalogListingModel.setMinimumQty(fm.getMinimumQty());

                } else {

                    catalogListingModel.setRecommendedQty(0);

                    catalogListingModel.setMinimumQty(0);

                }

                catalogListingMap.put(catalogId, catalogListingModel);

            }

            int itemAvailability = 0;

            if (currentStockMap != null) {

                Integer qty = currentStockMap.get(catalogId);

                itemAvailability = qty == null ? 0 : qty;

                catalogListingModel.setStockInHand(itemAvailability);

            } else {

                catalogListingModel.setStockInHand(0);

            }

            Integer inTransitQuantity = itemsInTransit.get(item.getId());

            int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);

            catalogListingModel.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);

            if (plannedDetailMap != null) {

                if (plannedDetailMap.get(catalogId) != null) {

                    int remaining = plannedDetailMap.get(catalogId) - catalogListingModel.getLast15DaysSale()

                            + catalogListingModel.getStockInHand() + catalogListingModel.getInTransitQuantity();

                    LOGGER.info("remaning" + remaining);

                    if (remaining != 0) {

                        catalogListingModel.setRemaining(remaining);

                    } else {

                        catalogListingModel.setRemaining(0);

                    }

                }

            }

        }

        Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(false);

        if (fofoId > 0) {

            CustomRetailer customRetailer = customRetailersMap.get(fofoId);

            model.addAttribute("retailerName",

                    customRetailer.getBusinessName() + "-" + customRetailer.getAddress().getCity());

            FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

            model.addAttribute("retailerId", customRetailer.getPartnerId());

            model.addAttribute("counterSize", fs.getCounterSize().toString());

        } else {

            model.addAttribute("counterSize", counterSize.toString());

        }

        String customRetailers = JSONObject.valueToString(customRetailersMap.values());

        List<CatalogListingModel> catalogModelList = new ArrayList<>(catalogListingMap.values());

        Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getMinimumQty,

                Comparator.reverseOrder());

        LOGGER.info("monthlyPlanned" + monthlyPlanned);

        model.addAttribute("catalogTagListings",

                catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));

        model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));

        model.addAttribute("brandStockPrices", this.getBrandStockPrices(loginDetails.getFofoId()));

        model.addAttribute("previousPlanningMonth", planningMonthDate.minusMonths(1).getMonth());

        model.addAttribute("currentPlanningMonth", planningMonthDate.getMonth());

        model.addAttribute("customRetailers", customRetailers);

        model.addAttribute("totalAmount", totalAmount);

        model.addAttribute("monthlyPlanned", monthlyPlanned);

        model.addAttribute("totalPcs", totalPcs);

        return "open-indent";

    }

    private long resetCart(Transaction transaction) {

        long sum = 0;

        Map<Long, Double> items = new HashMap<Long, Double>();

        for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {

            sum += order.getGvAmount();

            for (LineItem lineitem : order.getLineitems()) {

                Long itemId = lineitem.getItem_id();

                Double quantity = items.get(itemId);

                if (quantity == null) {

                    quantity = lineitem.getQuantity();

                } else {

                    quantity = quantity + lineitem.getQuantity();

                }

                items.put(itemId, quantity);

            }

        }

        LOGGER.debug("Items to reset in cart are: " + items);

        try {

            Client userClient = new UserClient().getClient();

            userClient.resetCart(transaction.getShoppingCartid(), items);

        } catch (TException e) {

            LOGGER.error("Error while updating information in payment database.", e);

        } catch (ShoppingCartException e) {