Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

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

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

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

import com.spice.profitmandi.common.web.client.RestClient;

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

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

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

import org.apache.commons.lang3.StringUtils;

import org.apache.http.conn.HttpHostConnectException;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONObject;

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.ui.Model;

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

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

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

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

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

import com.spice.profitmandi.common.services.mandii.MandiiService;

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

import com.spice.profitmandi.dao.cart.CartService;

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

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

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

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

import com.spice.profitmandi.dao.entity.dtr.UserAccount;

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

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

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

import com.spice.profitmandi.dao.enumuration.catalog.ByPassRequestStatus;

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

import com.spice.profitmandi.dao.enumuration.dtr.AccountType;

import com.spice.profitmandi.dao.enumuration.fofo.PaymentStatus;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.util.ContentPojoPopulator;

import com.spice.profitmandi.service.FofoUser;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.PartnerInvestmentService;

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

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

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

import com.spice.profitmandi.web.res.ValidateCartResponse;

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

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

import io.swagger.annotations.ApiOperation;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class CartController {

	private static final Logger logger = LogManager.getLogger(CartController.class);

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private ItemBucketService itemBucketService;

	@Autowired

	CartService cartService;

	@Autowired

	private ContentPojoPopulator contentPojoPopulator;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private FocusedModelByPassRepository focusedModelByPassRepository;

	@Autowired

	private FofoPaymentRepository fofoPaymentRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private PartnerInvestmentService partnerInvestmentService;

	@Autowired

	private FofoUser fofoUser;

	@Autowired

	private FocusedModelRepository focusedModelRepository;

	@Autowired

	private PartnerRegionRepository partnerRegionRepository;

	@Autowired

	private SaholicInventoryService saholicInventoryService;

	@Autowired

	private TransactionService transactionService;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private RetailerBlockBrandsRepository retailerBlockBrandRepository;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private NotificationService notificationService;

	@Autowired

	private FofoOpeningStockRepository fofoOpeningStockRepository;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	public static final Map<String, Integer> MIN_BRAND_QTY_LIMIT = new HashMap<>();

	private static final Logger log = LogManager.getLogger(CartController.class);

	List<EscalationType> esclationType = Arrays.asList(EscalationType.L3, EscalationType.L4, EscalationType.L2);

	List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com",

			"niranjan.kala@smartdukaan.com", "sm@smartdukaan.com");

	static {

		// MIN_BRAND_QTY_LIMIT.put("Realme", 10);

		MIN_BRAND_QTY_LIMIT.put("Reliance", 5);

	}

	@RequestMapping(value = ProfitMandiConstants.URL_CART, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	@ApiOperation(value = "Add items to cart")

	public ResponseEntity<?> validateCart(HttpServletRequest request,

			@RequestParam(value = "pincode", defaultValue = "110001") String pincode, @RequestParam int bucketId)

			throws Throwable {

		AddCartRequest cartRequest = new AddCartRequest();

		List<CartItem> ci = new ArrayList<>();

		itemBucketService.getBucketDetails(bucketId).stream().forEach(x -> {

			ci.add(new CartItem(x.getQuantity(), x.getItemId()));

		});

		cartRequest.setCartItems(ci);

		return this.validateCart(request, cartRequest, "110001");

	}

	@RequestMapping(value = ProfitMandiConstants.URL_CART, method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	@ApiOperation(value = "Add items to cart")

	public ResponseEntity<?> validateCart(HttpServletRequest request, @RequestBody AddCartRequest cartRequest,

			@RequestParam(value = "pincode", defaultValue = "110001") String pincode) throws Throwable {

		UserAccount userAccount = null;

		ValidateCartResponse vc = null;

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

		int cartId = userAccountRepository.selectByUserIdType(userId, AccountType.cartId).getAccountKey();

		List<CartItem> cartItems = cartRequest.getCartItems();

		cartService.addItemsToCart(cartId, cartItems);

		CartResponse cartValidationResponse = cartService.getCartValidation(cartId);

		for (CartItemResponseModel cartItem : cartValidationResponse.getCartItems()) {

			ProductPojo pp = contentPojoPopulator.getShortContent(cartItem.getCatalogItemId());

			log.info("pp {}", pp);

			if (pp != null) {

				cartItem.setImageUrl(pp.getImageUrl()); // cartItem.setTitle(pp.getTitle());

			}

		}

		vc = new ValidateCartResponse(cartValidationResponse, "Success", "Items added to cart successfully");

		return responseSender.ok(vc);

	}

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

	@ApiImplicitParams({

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

	@ApiOperation(value = "Add or update a single cart item")

	public ResponseEntity<?> updateCartItem(HttpServletRequest request,

			@RequestParam int itemId, @RequestParam int quantity,

			@RequestParam(defaultValue = "0") float sellingPrice) throws Throwable {

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

		int cartId = userAccountRepository.selectByUserIdType(userId, AccountType.cartId).getAccountKey();

		cartService.updateCartItem(cartId, itemId, quantity, sellingPrice);

		return responseSender.ok(cartService.getCartItems(cartId));

	}

	@RequestMapping(value = "/cart/item", method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	@ApiOperation(value = "Remove an item from cart")

	public ResponseEntity<?> removeCartItem(HttpServletRequest request,

			@RequestParam int itemId) throws Throwable {

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

		int cartId = userAccountRepository.selectByUserIdType(userId, AccountType.cartId).getAccountKey();

		cartService.removeCartItem(cartId, itemId);

		return responseSender.ok(cartService.getCartItems(cartId));

	}

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

	@ApiImplicitParams({

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

	@ApiOperation(value = "Get current cart items")

	public ResponseEntity<?> getCartItems(HttpServletRequest request) throws Throwable {

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

		int cartId = userAccountRepository.selectByUserIdType(userId, AccountType.cartId).getAccountKey();

		return responseSender.ok(cartService.getCartItems(cartId));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_CART_CHANGE_ADDRESS, method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

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

	@ApiOperation(value = "Change address")

	public ResponseEntity<?> changeAddress(HttpServletRequest request,

			@RequestParam(value = "addressId") long addressId) throws Throwable {

		UserCart uc = userAccountRepository.getUserCart((int) request.getAttribute("userId"));

		cartService.addAddressToCart(uc.getCartId(), addressId);

		return responseSender.ok("Address Changed successfully");

	}

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

	@ApiImplicitParams({

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

	@ApiOperation(value = "byPassRequests")

	public ResponseEntity<?> byPassRequests(HttpServletRequest request, Model model) throws Exception {

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

		User user = userRepository.selectById(userId);

		AuthUser authUser = authRepository.selectByEmailOrMobile(user.getEmailId());

		List<FocusedModelByPassRequest> byPassRequests = null;

		Set<Integer> authfofoIds = null;

		boolean actionAccess = false;

		logger.info("authUser" + authUser);

		List<Position> positions = positionRepository.selectPositionByAuthId(authUser.getId()).stream()

				.filter(x -> (x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_SALES

						|| x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_RBM))

				.collect(Collectors.toList());

		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

		if (emails.contains(authUser.getEmailId())) {

			byPassRequests = focusedModelByPassRepository.selectByStatus(ByPassRequestStatus.PENDING);

			actionAccess = true;

		} else {

			if (!positions.isEmpty()) {

				for (Position ps : positions) {

					if (ProfitMandiConstants.TICKET_CATEGORY_RBM == ps.getCategoryId()) {

						authfofoIds = storeGuyMap.get(user.getEmailId());

						logger.info("authfofoIdsw" + authfofoIds);

						actionAccess = true;

						break;

					} else if (ProfitMandiConstants.TICKET_CATEGORY_SALES == ps.getCategoryId()) {

						authfofoIds = storeGuyMap.get(user.getEmailId());

						logger.info("authfofoIdsw" + authfofoIds);

						actionAccess = false;

						break;

					}

				}

			}

		}

		logger.info("authfofoIds" + authfofoIds);

		if (authfofoIds != null) {

			byPassRequests = focusedModelByPassRepository.selectByStatusAndFofoIds(new ArrayList<>(authfofoIds),

					ByPassRequestStatus.PENDING);

		}

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

		List<ByPassRequestModel> byPassList = new ArrayList<>();

		for (FocusedModelByPassRequest byPassRequest : byPassRequests) {

			List<FocusedShortageModel> fsms = cartService.focusedModelShortageValidation(byPassRequest.getFofoId(),

					new HashMap<>());

			Map<String, Object> investments = fofoUser.getInvestments(byPassRequest.getFofoId());

			ByPassRequestModel bp = new ByPassRequestModel();

			bp.setPartnerName(customRetailerMap.get(byPassRequest.getFofoId()).getBusinessName());

			bp.setCity(customRetailerMap.get(byPassRequest.getFofoId()).getAddress().getCity());

			bp.setState(customRetailerMap.get(byPassRequest.getFofoId()).getAddress().getState());

			bp.setCode(customRetailerMap.get(byPassRequest.getFofoId()).getCode());

			bp.setStatus(byPassRequest.getStatus());

			bp.setFofoId(byPassRequest.getFofoId());

			bp.setByPassRequestId(byPassRequest.getId());

			bp.setInvestmentOkDays((Long) investments.get("okDays"));

			bp.setInvestmentShort((PartnerDailyInvestment) investments.get("investment"));

			bp.setMobileNumber(customRetailerMap.get(byPassRequest.getFofoId()).getMobileNumber());

			bp.setActionAccess(actionAccess);

			bp.setCreateTimestamp(byPassRequest.getCreatedTimeStamp());

			bp.setUpdateTimestamp(byPassRequest.getUpdatedTimestamp());

			bp.setFsms(fsms);

			byPassList.add(bp);

		}

		return responseSender.ok(byPassList);

	}

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

	@ApiImplicitParams({

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

	@ApiOperation(value = "Add items to cart")

	public ResponseEntity<?> addAmountToWalletRequestRejected(HttpServletRequest request,

			@RequestParam(name = "id", defaultValue = "0") int id, @RequestParam ByPassRequestStatus status,

			@RequestParam String reason, Model model) throws Exception {

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

		User user = userRepository.selectById(userId);

		AuthUser authUser = authRepository.selectByEmailOrMobile(user.getEmailId());

		FocusedModelByPassRequest byPassRequest = focusedModelByPassRepository.selectById(id);

		if (status.equals(ByPassRequestStatus.APPROVED)) {

			byPassRequest.setByPass(true);

			byPassRequest.setAuthId(authUser.getId());

			byPassRequest.setStatus(ByPassRequestStatus.APPROVED);

			byPassRequest.setUpdatedTimestamp(LocalDateTime.now());

			byPassRequest.setReason(reason);

		} else if (status.equals(ByPassRequestStatus.REJECTED)) {

			byPassRequest.setByPass(false);

			byPassRequest.setAuthId(authUser.getId());

			byPassRequest.setStatus(ByPassRequestStatus.REJECTED);

			byPassRequest.setUpdatedTimestamp(LocalDateTime.now());

			byPassRequest.setReason(reason);

		}

		String title = "Billing Request";

		String message = String.format("Your Billing  Request is " + status

				+ ". Please ensure to order the missing focus models as soon as possible.");

		SendNotificationModel sendNotificationModel = new SendNotificationModel();

		sendNotificationModel.setCampaignName("Billing Request");

		sendNotificationModel.setTitle(title);

		sendNotificationModel.setMessage(message);

		sendNotificationModel.setType("url");

		sendNotificationModel.setUrl("https://smartdukaan.com/pages/home/notifications");

		sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));

		sendNotificationModel.setMessageType(MessageType.notification);

		sendNotificationModel

				.setUserIds(Arrays.asList(userAccountRepository.selectUserIdByRetailerId(byPassRequest.getFofoId())));

		notificationService.sendNotification(sendNotificationModel);

		return responseSender.ok(true);

	}

	@Autowired

	WalletService walletService;

	@Autowired

	MandiiService mandiiService;

	@Autowired

	UserWalletHistoryRepository userWalletHistoryRepository;

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

	public ResponseEntity<?> validateCartPayment(HttpServletRequest request,

			@RequestParam(defaultValue = "0") int paymentId, Model model) throws Exception {

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

		UserCart uc = userAccountRepository.getUserCart(userId);

		FofoPayment fofoPayment = fofoPaymentRepository.selectById(paymentId);

		if (fofoPayment == null || fofoPayment.getFofoId() != uc.getUserId()) {

			return responseSender.ok(false);

		}

		String gatewayReference = fofoPayment.getGatewayReference();

		List<UserWalletHistory> historyList = userWalletHistoryRepository

				.selectAllByreferenceIdandreferenceType(paymentId, WalletReferenceType.PAYMENT_GATEWAY);

		if (fofoPayment.getStatus().equals(PaymentStatus.INIT) && historyList.size() == 0) {

			String jsonString = mandiiService.getOrderStatus(gatewayReference);

			JSONObject jsonOrder = new JSONObject(jsonString);

			double orderAmount = jsonOrder.getDouble("order_amount");

			double capturedAmount = jsonOrder.getDouble("captured_amount");

			int merchantOrderId = jsonOrder.getInt("merchant_order_number");

			String status = jsonOrder.getString("status");

			if (merchantOrderId == paymentId && status.equals("SUCCESS") || status.equals("CAPTURED")) {

				if (orderAmount == fofoPayment.getAmount()) {

					fofoPayment.setStatus(PaymentStatus.SUCCESS);

					fofoPayment.setAmount(capturedAmount);

					walletService.addAmountToWallet(uc.getUserId(), paymentId, WalletReferenceType.PAYMENT_GATEWAY,

							"Amount added to wallet via SD Credit via Mandii", (float) fofoPayment.getAmount(),

							LocalDateTime.now());

					if (orderAmount == capturedAmount) {

						return responseSender.ok(true);

					}

				}

			}

		}

		return responseSender.ok(false);

	}

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

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

	public ResponseEntity<?> getItemHidAllocation(HttpServletRequest request) throws

			Exception {

		List<HidAllocationModel> hidAllocationModels = new ArrayList<>();

		int userId = (int) request.getAttribute(ProfitMandiConstants.USER_ID);

		int retailerId = userAccountRepository.selectRetailerIdByUserId(userId);

		hidAllocationModels = fofoOpeningStockRepository.getPartnerHidAllocation(retailerId);

		return responseSender.ok(hidAllocationModels);

	}

}