Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

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

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

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

import com.spice.profitmandi.common.solr.SolrService;

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.CustomerService;

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

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.util.StringUtils;

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.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.HashSet;

import java.util.function.Function;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class CustomerController {

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

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private CustomerRepository customerRepository;

	@Autowired

	private InventoryService inventoryService;

	@Autowired

	private CustomerService customerService;

	@Autowired

	private CustomerAddressRepository customerAddressRepository;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private SolrService commonSolrService;

	@Autowired

	private FofoLineItemRepository fofoLineItemRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private CustomerOfferRepository customerOfferRepository;

	@Autowired

	private CustomerOfferItemRepository customerOfferItemRepository;

	@Autowired

	private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

	@RequestMapping(value = "/customer/mobileNumber", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	public ResponseEntity<?> getCustomerByMobileNumber(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.MOBILE_NUMBER) String mobileNumber)

			throws ProfitMandiBusinessException {

		CustomCustomer customCustomer = null;

		LOGGER.info("Request Received at url {}", request.getRequestURI());

		try {

			Customer customer = customerRepository.selectByMobileNumber(mobileNumber);

			customCustomer = new CustomCustomer();

			customCustomer.setCustomerId(customer.getId());

			customCustomer.setEmailId(customer.getEmailId());

			customCustomer.setFirstName(customer.getFirstName());

			customCustomer.setLastName(customer.getLastName());

			customCustomer.setMobileNumber(customer.getMobileNumber());

			LOGGER.info(customer.getCustomerAddress());

			List<CustomerAddress> customerAddresses = customer.getCustomerAddress().stream().filter(c -> Boolean.TRUE.equals(c.getActive())).collect(Collectors.toList());

			LOGGER.info(customerAddresses);

			if (!customerAddresses.isEmpty()) {

				List<CustomAddress> customAddresses = new ArrayList<>();

				for (CustomerAddress customerAddress : customerAddresses) {

					customAddresses.add(this.toCustomAddress(customerAddress));

				}

				customCustomer.setAddresses(customAddresses);

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return responseSender.ok(customCustomer);

	}

	private CustomAddress toCustomAddress(CustomerAddress customerAddress) {

		CustomAddress customAddress = new CustomAddress();

		customAddress.setCity(customerAddress.getCity());

		customAddress.setCountry(customerAddress.getCountry());

		customAddress.setLandmark(customerAddress.getLandmark());

		customAddress.setLine1(customerAddress.getLine1());

		customAddress.setLine2(customerAddress.getLine2());

		customAddress.setName(customerAddress.getName());

		customAddress.setLastName(customerAddress.getLastName());

		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());

		customAddress.setPinCode(customerAddress.getPinCode());

		customAddress.setState(customerAddress.getState());

		customAddress.setId(customerAddress.getId());

		customAddress.setDefaultAddress(customerAddress.getDefault());

		return customAddress;

	}

	@RequestMapping(value = "/customer/add", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	public ResponseEntity<?> addCustomer(HttpServletRequest request, @RequestBody CustomCustomer customCustomer)

			throws ProfitMandiBusinessException {

		Customer customer = new Customer();

		if (StringUtils.isEmpty(customCustomer.getFirstName())) {

			throw new ProfitMandiBusinessException("First Name", "Empty", "First Name required");

		}

		customer.setEmailId(customCustomer.getEmailId());

		customer.setFirstName(customCustomer.getFirstName());

		customer.setLastName(customCustomer.getLastName());

		customer.setMobileNumber(customCustomer.getMobileNumber());

		customer = customerService.addCustomer(customer);

		customCustomer.setCustomerId(customer.getId());

		return responseSender.ok(customCustomer);

	}

	@RequestMapping(value = "/customer/address", method = RequestMethod.POST)

	public ResponseEntity<?> addAddress(HttpServletRequest request, @RequestParam int customerId,

			@RequestBody CustomAddress customAddress) {

		CustomerAddress customerAddress = this.toCustomerAddress(customerId, customAddress);

		customerAddress.setActive(true);

		customerAddressRepository.persist(customerAddress);

		return responseSender.ok(this.toCustomAddress(customerAddress));

	}

	@RequestMapping(value = "/customer/address/update", method = RequestMethod.PUT)

	public ResponseEntity<?> updateAddress(HttpServletRequest request, @RequestParam int addressId,

			@RequestBody CustomAddress customAddress) {

		try {

			CustomerAddress customerAddress = customerAddressRepository.selectById(addressId);

			if (customAddress.getName() != null) customerAddress.setName(customAddress.getName());

			if (customAddress.getLastName() != null) customerAddress.setLastName(customAddress.getLastName());

			if (customAddress.getLine1() != null) customerAddress.setLine1(customAddress.getLine1());

			if (customAddress.getLine2() != null) customerAddress.setLine2(customAddress.getLine2());

			if (customAddress.getLandmark() != null) customerAddress.setLandmark(customAddress.getLandmark());

			if (customAddress.getCity() != null) customerAddress.setCity(customAddress.getCity());

			if (customAddress.getPinCode() != null) customerAddress.setPinCode(customAddress.getPinCode());

			if (customAddress.getState() != null) customerAddress.setState(customAddress.getState());

			if (customAddress.getCountry() != null) customerAddress.setCountry(customAddress.getCountry());

			if (customAddress.getPhoneNumber() != null) customerAddress.setPhoneNumber(customAddress.getPhoneNumber());

			return responseSender.ok(this.toCustomAddress(customerAddress));

		} catch (ProfitMandiBusinessException e) {

			return responseSender.badRequest(e);

		}

	}

	private CustomerAddress toCustomerAddress(int customerId, CustomAddress customAddress) {

		CustomerAddress customerAddress = new CustomerAddress();

		customerAddress.setCustomerId(customerId);

		customerAddress.setName(customAddress.getName());

		customerAddress.setLastName(customAddress.getLastName());

		customerAddress.setLine1(customAddress.getLine1());

		customerAddress.setLine2(customAddress.getLine2());

		customerAddress.setLandmark(customAddress.getLandmark());

		customerAddress.setCity(customAddress.getCity());

		customerAddress.setPinCode(customAddress.getPinCode());

		customerAddress.setState(customAddress.getState());

		customerAddress.setCountry(customAddress.getCountry());

		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());

		return customerAddress;

	}

	@RequestMapping(value = "/customer/order", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	public ResponseEntity<?> getOrderInvoiceDetail(HttpServletRequest request,

			@RequestParam(name = "offset") int offset, @RequestParam(name = "limit") int limit) throws Exception {

		int userId = (int) request.getAttribute("userId");

		UserCart uc = userAccountRepository.getUserCart(userId);

		List<CustomerOrderDetail> customerOrderDetails = new ArrayList<>();

		List<FofoOrder> fofoOrders = fofoOrderRepository.selectOrderByFofoId(uc.getUserId(), offset, limit);

		if (fofoOrders.isEmpty()) {

			return responseSender.ok(customerOrderDetails);

		}

		// Filter out cancelled orders

		List<FofoOrder> activeOrders = fofoOrders.stream()

				.filter(fo -> fo.getCancelledTimestamp() == null)

				.collect(Collectors.toList());

		if (activeOrders.isEmpty()) {

			return responseSender.ok(customerOrderDetails);

		}

		// Batch fetch all order items for all orders at once

		List<Integer> orderIds = activeOrders.stream().map(FofoOrder::getId).collect(Collectors.toList());

		List<FofoOrderItem> allOrderItems = fofoOrderItemRepository.selectByOrderIds(orderIds);

		Map<Integer, List<FofoOrderItem>> orderItemsByOrderId = allOrderItems.stream()

				.collect(Collectors.groupingBy(FofoOrderItem::getOrderId));

		// Batch fetch all customers

		List<Integer> customerIds = activeOrders.stream().map(FofoOrder::getCustomerId).distinct().collect(Collectors.toList());

		Map<Integer, Customer> customerMap = customerRepository.selectAllByIds(customerIds).stream()

				.collect(Collectors.toMap(Customer::getId, Function.identity()));

		// Batch fetch all customer addresses

		List<Integer> addressIds = activeOrders.stream().map(FofoOrder::getCustomerAddressId).distinct().collect(Collectors.toList());

		Map<Integer, CustomerAddress> addressMap = customerAddressRepository.selectAllByIds(addressIds).stream()

				.collect(Collectors.toMap(CustomerAddress::getId, Function.identity()));

		// Batch fetch all items

		Set<Integer> itemIds = allOrderItems.stream().map(FofoOrderItem::getItemId).collect(Collectors.toSet());

		// A customer whose only order is an insurance-only sale has no fofo_order_item rows, so

		// itemIds is empty and selectByIds would throw "List should not be empty" on the empty IN.

		Map<Integer, Item> itemMap = itemIds.isEmpty()

				? new HashMap<>()

				: itemRepository.selectByIds(new ArrayList<>(itemIds)).stream()

						.collect(Collectors.toMap(Item::getId, Function.identity()));

		// Batch fetch all line items

		Set<Integer> orderItemIds = allOrderItems.stream().map(FofoOrderItem::getId).collect(Collectors.toSet());

		List<FofoLineItem> allLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(orderItemIds);

		Map<Integer, List<FofoLineItem>> lineItemsByOrderItemId = allLineItems.stream()

				.collect(Collectors.groupingBy(FofoLineItem::getFofoOrderItemId));

		// Fetch customer offers once outside the loops

		Map<Integer, List<CustomerOffer>> customerOffersMap = customerOfferRepository.getCustomerOffer(LocalDate.now().atStartOfDay());

		List<CustomerOffer> customerOffers = customerOffersMap.get(uc.getUserId());

		List<Integer> offerIds = (customerOffers != null && !customerOffers.isEmpty())

				? customerOffers.stream().map(CustomerOffer::getId).collect(Collectors.toList())

				: new ArrayList<>();

		// Process orders using pre-fetched data

		for (FofoOrder fo : activeOrders) {

			List<FofoOrderItem> fofoOrderItems = orderItemsByOrderId.getOrDefault(fo.getId(), new ArrayList<>());

			Customer customer = customerMap.get(fo.getCustomerId());

			CustomerAddress customerAddress = addressMap.get(fo.getCustomerAddressId());

			for (FofoOrderItem foi : fofoOrderItems) {

				Item item = itemMap.get(foi.getItemId());

				if (item != null) {

					foi.setItemName(item.getItemDescription());

				}

				List<FofoLineItem> fofoLineItems = lineItemsByOrderItemId.getOrDefault(foi.getId(), new ArrayList<>());

				CustomerOrderDetail customerOrderDetail = new CustomerOrderDetail();

				List<String> serialNumbers = fofoLineItems.stream()

						.map(FofoLineItem::getSerialNumber)

						.filter(x -> x != null)

						.collect(Collectors.toList());

				customerOrderDetail.setSerialNumber(serialNumbers);

				if (customerAddress != null) {

					customerOrderDetail.setCustomerName(customerAddress.getName());

					customerOrderDetail.setCustomerMobile(customerAddress.getPhoneNumber());

					customerOrderDetail.setCustomerEmail(customer != null ? customer.getEmailId() : null);

					customerOrderDetail.setCustomerCity(customerAddress.getCity());

					customerOrderDetail.setCustomerState(customerAddress.getState());

				}

				if (item != null) {

					customerOrderDetail.setBrand(item.getBrand());

					customerOrderDetail.setColor(item.getColor());

					customerOrderDetail.setModelName(item.getModelName());

					customerOrderDetail.setModelNumber(item.getModelNumber());

				}

				customerOrderDetail.setFofoOrderItemId(foi.getId());

				customerOrderDetail.setFofoOrderId(foi.getOrderId());

				customerOrderDetail.setItemId(foi.getItemId());

				customerOrderDetail.setQuantity(foi.getQuantity());

				customerOrderDetail.setTotalPrice(foi.getSellingPrice());

				customerOrderDetail.setCreatedTimeStamp(foi.getCreateTimestamp());

				customerOrderDetail.setInvoiceNumber(fo.getInvoiceNumber());

				customerOrderDetail.setCancelledTimestamp(fo.getCancelledTimestamp());

				customerOrderDetail.setInsurance(false);

				if (!serialNumbers.isEmpty() && item != null) {

					if ("85171300".equals(item.getHsnCode())) {

						customerOrderDetail.setInsurance(true);

					}

				}

				long offerCount = 0;

				if (!offerIds.isEmpty() && item != null) {

					List<CustomerOfferItem> customerOfferItems = customerOfferItemRepository

							.selectByOfferIds(offerIds, item.getCatalogItemId(), LocalDate.now());

					offerCount = customerOfferItems.size();

				}

				customerOrderDetail.setOfferCount(offerCount);

				customerOrderDetails.add(customerOrderDetail);

			}

		}

		return responseSender.ok(customerOrderDetails);

	}

}