Subversion Repositories SmartDukaan

Rev

Rev 28437 | Rev 29707 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
21612 ashik.ali 1 
package com.spice.profitmandi.web.controller;
2 
 
21689 ashik.ali 3 
import java.io.ByteArrayInputStream;
4 
import java.io.ByteArrayOutputStream;
5 
import java.io.InputStream;
28358 tejbeer 6 
import java.time.LocalDate;
23638 amit.gupta 7 
import java.time.LocalDateTime;
28339 tejbeer 8 
import java.time.format.DateTimeFormatter;
23638 amit.gupta 9 
import java.time.temporal.ChronoUnit;
24844 amit.gupta 10 
import java.util.ArrayList;
23654 amit.gupta 11 
import java.util.Arrays;
23343 ashik.ali 12 
import java.util.HashMap;
21612 ashik.ali 13 
import java.util.HashSet;
21680 ashik.ali 14 
import java.util.List;
15 
import java.util.Map;
21612 ashik.ali 16 
import java.util.Set;
23638 amit.gupta 17 
import java.util.stream.Collectors;
21612 ashik.ali 18 
 
19 
import javax.servlet.http.HttpServletRequest;
21689 ashik.ali 20 
import javax.servlet.http.HttpServletResponse;
21612 ashik.ali 21 
 
23638 amit.gupta 22 
import org.apache.logging.log4j.LogManager;
23568 govind 23 
import org.apache.logging.log4j.Logger;
28339 tejbeer 24 
import org.json.JSONObject;
21612 ashik.ali 25 
import org.springframework.beans.factory.annotation.Autowired;
21689 ashik.ali 26 
import org.springframework.core.io.InputStreamResource;
27 
import org.springframework.http.HttpHeaders;
28 
import org.springframework.http.HttpStatus;
29 
import org.springframework.http.MediaType;
30 
import org.springframework.http.ResponseEntity;
21612 ashik.ali 31 
import org.springframework.stereotype.Controller;
22064 ashik.ali 32 
import org.springframework.transaction.annotation.Transactional;
21985 kshitij.so 33 
import org.springframework.ui.Model;
24880 govind 34 
import org.springframework.web.bind.annotation.GetMapping;
23654 amit.gupta 35 
import org.springframework.web.bind.annotation.PathVariable;
24105 govind 36 
import org.springframework.web.bind.annotation.PutMapping;
21612 ashik.ali 37 
import org.springframework.web.bind.annotation.RequestBody;
38 
import org.springframework.web.bind.annotation.RequestMapping;
39 
import org.springframework.web.bind.annotation.RequestMethod;
21689 ashik.ali 40 
import org.springframework.web.bind.annotation.RequestParam;
21612 ashik.ali 41 
 
26817 amit.gupta 42 
import com.google.gson.Gson;
23203 ashik.ali 43 
import com.spice.profitmandi.common.enumuration.SearchType;
21612 ashik.ali 44 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
21985 kshitij.so 45 
import com.spice.profitmandi.common.model.CartFofo;
22860 ashik.ali 46 
import com.spice.profitmandi.common.model.CreateOrderRequest;
23654 amit.gupta 47 
import com.spice.profitmandi.common.model.CreditNotePdfModel;
23584 ashik.ali 48 
import com.spice.profitmandi.common.model.CustomCustomer;
26647 tejbeer 49 
import com.spice.profitmandi.common.model.CustomRetailer;
27861 tejbeer 50 
import com.spice.profitmandi.common.model.FofoItemIdAmountModel;
23638 amit.gupta 51 
import com.spice.profitmandi.common.model.FoiBadReturnRequest;
27861 tejbeer 52 
import com.spice.profitmandi.common.model.PartnerOptionsAndItemAmountModel;
24105 govind 53 
import com.spice.profitmandi.common.model.PaymentOptionTransactionModel;
22660 ashik.ali 54 
import com.spice.profitmandi.common.model.PdfModel;
22581 ashik.ali 55 
import com.spice.profitmandi.common.model.PriceModel;
21612 ashik.ali 56 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
28339 tejbeer 57 
import com.spice.profitmandi.common.solr.SolrService;
21689 ashik.ali 58 
import com.spice.profitmandi.common.util.PdfUtils;
23638 amit.gupta 59 
import com.spice.profitmandi.common.util.StringUtils;
22244 ashik.ali 60 
import com.spice.profitmandi.common.web.util.ResponseSender;
23638 amit.gupta 61 
import com.spice.profitmandi.dao.entity.catalog.Item;
27861 tejbeer 62 
import com.spice.profitmandi.dao.entity.catalog.TagListing;
22217 ashik.ali 63 
import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
23343 ashik.ali 64 
import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;
23548 ashik.ali 65 
import com.spice.profitmandi.dao.entity.dtr.PaymentOptionTransaction;
26647 tejbeer 66 
import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
21728 ashik.ali 67 
import com.spice.profitmandi.dao.entity.fofo.Customer;
68 
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
23654 amit.gupta 69 
import com.spice.profitmandi.dao.entity.fofo.CustomerCreditNote;
70 
import com.spice.profitmandi.dao.entity.fofo.CustomerReturnItem;
23638 amit.gupta 71 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
22927 ashik.ali 72 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
22860 ashik.ali 73 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
28420 tejbeer 74 
import com.spice.profitmandi.dao.entity.fofo.Mou;
21728 ashik.ali 75 
import com.spice.profitmandi.dao.entity.fofo.PaymentOption;
26647 tejbeer 76 
import com.spice.profitmandi.dao.entity.fofo.PendingOrder;
77 
import com.spice.profitmandi.dao.entity.fofo.PendingOrderItem;
23298 ashik.ali 78 
import com.spice.profitmandi.dao.entity.user.Address;
23548 ashik.ali 79 
import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
27046 tejbeer 80 
import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;
23638 amit.gupta 81 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
27861 tejbeer 82 
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
26647 tejbeer 83 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
22217 ashik.ali 84 
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
23343 ashik.ali 85 
import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
23638 amit.gupta 86 
import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;
23298 ashik.ali 87 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
26647 tejbeer 88 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
21728 ashik.ali 89 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
90 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
23650 amit.gupta 91 
import com.spice.profitmandi.dao.repository.fofo.CustomerReturnItemRepository;
22860 ashik.ali 92 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
21728 ashik.ali 93 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
23366 ashik.ali 94 
import com.spice.profitmandi.dao.repository.fofo.FofoPartnerPaymentOptionRepository;
28420 tejbeer 95 
import com.spice.profitmandi.dao.repository.fofo.MouRepository;
21728 ashik.ali 96 
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
26647 tejbeer 97 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;
98 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;
28339 tejbeer 99 
import com.spice.profitmandi.dao.repository.fofo.PendingOrderService;
24440 amit.gupta 100 
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
23298 ashik.ali 101 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
28377 tejbeer 102 
import com.spice.profitmandi.service.EmailService;
23798 amit.gupta 103 
import com.spice.profitmandi.service.authentication.RoleManager;
25726 amit.gupta 104 
import com.spice.profitmandi.service.integrations.zest.InsuranceService;
24440 amit.gupta 105 
import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;
23366 ashik.ali 106 
import com.spice.profitmandi.service.order.OrderService;
22069 ashik.ali 107 
import com.spice.profitmandi.service.pricing.PricingService;
26647 tejbeer 108 
import com.spice.profitmandi.service.user.RetailerService;
22139 amit.gupta 109 
import com.spice.profitmandi.web.model.LoginDetails;
22069 ashik.ali 110 
import com.spice.profitmandi.web.util.CookiesProcessor;
24105 govind 111 
import com.spice.profitmandi.web.util.MVCResponseSender;
21612 ashik.ali 112 
 
113 
@Controller
23973 govind 114 
@Transactional(rollbackFor = Throwable.class)
21612 ashik.ali 115 
public class OrderController {
116 
 
23568 govind 117 
	private static final Logger LOGGER = LogManager.getLogger(OrderController.class);
21985 kshitij.so 118 
 
28339 tejbeer 119 
	private static final List<String> offlineOrders = Arrays.asList("EMIOD", "POD");
120 
 
21612 ashik.ali 121 
	@Autowired
22860 ashik.ali 122 
	private CustomerRepository customerRepository;
23973 govind 123 
 
23821 amit.gupta 124 
	private boolean accessoriesDeals = true;
21985 kshitij.so 125 
 
21612 ashik.ali 126 
	@Autowired
23786 amit.gupta 127 
	private RoleManager roleManager;
23973 govind 128 
 
23786 amit.gupta 129 
	@Autowired
26817 amit.gupta 130 
	private Gson gson;
27046 tejbeer 131 
 
26817 amit.gupta 132 
	@Autowired
23654 amit.gupta 133 
	private CustomerReturnItemRepository customerReturnItemRepository;
23973 govind 134 
 
23654 amit.gupta 135 
	@Autowired
23638 amit.gupta 136 
	private FofoOrderItemRepository fofoOrderItemRepository;
21985 kshitij.so 137 
 
29642 amit.gupta 138 
	private static final List<String> allowedDoaImeis = Arrays.asList("863903054378477");
139 
 
21612 ashik.ali 140 
	@Autowired
22860 ashik.ali 141 
	private PaymentOptionRepository paymentOptionRepository;
24844 amit.gupta 142 
 
24440 amit.gupta 143 
	@Autowired
144 
	private StateRepository stateRepository;
23973 govind 145 
 
23638 amit.gupta 146 
	@Autowired
147 
	private ItemRepository itemRepository;
21985 kshitij.so 148 
 
21680 ashik.ali 149 
	@Autowired
24105 govind 150 
	private MVCResponseSender mvcResponseSender;
24844 amit.gupta 151 
 
24440 amit.gupta 152 
	@Autowired
25726 amit.gupta 153 
	private InsuranceService insuranceService;
24105 govind 154 
 
155 
	@Autowired
22860 ashik.ali 156 
	private FofoOrderRepository fofoOrderRepository;
21985 kshitij.so 157 
 
21680 ashik.ali 158 
	@Autowired
22860 ashik.ali 159 
	private CustomerAddressRepository customerAddressRepository;
23973 govind 160 
 
22217 ashik.ali 161 
	@Autowired
22860 ashik.ali 162 
	private InsurancePolicyRepository insurancePolicyRepository;
23973 govind 163 
 
23343 ashik.ali 164 
	@Autowired
165 
	private InsuranceProviderRepository insuranceProviderRepository;
21985 kshitij.so 166 
 
21896 ashik.ali 167 
	@Autowired
22860 ashik.ali 168 
	private CookiesProcessor cookiesProcessor;
23973 govind 169 
 
22069 ashik.ali 170 
	@Autowired
22860 ashik.ali 171 
	private PricingService pricingService;
23973 govind 172 
 
22354 ashik.ali 173 
	@Autowired
22860 ashik.ali 174 
	private OrderService orderService;
23973 govind 175 
 
23298 ashik.ali 176 
	@Autowired
177 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
23973 govind 178 
 
22354 ashik.ali 179 
	@Autowired
23298 ashik.ali 180 
	private AddressRepository addressRepository;
23973 govind 181 
 
23298 ashik.ali 182 
	@Autowired
23548 ashik.ali 183 
	private PaymentOptionTransactionRepository fofoOrderPaymentOptionRepository;
23973 govind 184 
 
23366 ashik.ali 185 
	@Autowired
186 
	private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;
23973 govind 187 
 
23419 ashik.ali 188 
	@Autowired
22860 ashik.ali 189 
	private ResponseSender<?> responseSender;
23973 govind 190 
 
26647 tejbeer 191 
	@Autowired
192 
	private PendingOrderRepository pendingOrderRepository;
193 
 
194 
	@Autowired
195 
	private PendingOrderItemRepository pendingOrderItemRepository;
196 
 
197 
	@Autowired
198 
	private FofoStoreRepository fofoStoreRepository;
199 
 
200 
	@Autowired
201 
	private RetailerService retailerService;
202 
 
203 
	@Autowired
204 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
205 
 
27861 tejbeer 206 
	@Autowired
207 
	private TagListingRepository tagListingRepository;
208 
 
28339 tejbeer 209 
	@Autowired
210 
	private PendingOrderService pendingOrderService;
211 
 
212 
	@Autowired
213 
	private EmailService emailService;
214 
 
215 
	@Autowired
216 
	private SolrService commonSolrService;
217 
 
28420 tejbeer 218 
	@Autowired
219 
	private MouRepository mouRepository;
220 
 
21985 kshitij.so 221 
	@RequestMapping(value = "/order")
23973 govind 222 
	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)
223 
			throws ProfitMandiBusinessException {
224 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
225 
 
23298 ashik.ali 226 
		int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
227 
		Address address = addressRepository.selectById(addressId);
23973 govind 228 
 
22860 ashik.ali 229 
		List<CartFofo> cartItems = orderService.cartCheckout(cartData);
230 
		Set<Integer> itemIds = new HashSet<>();
28339 tejbeer 231 
		List<Integer> poIds = new ArrayList<>();
232 
		List<Integer> poItemIds = new ArrayList<>();
23973 govind 233 
		for (CartFofo cartFofo : cartItems) {
22860 ashik.ali 234 
			itemIds.add(cartFofo.getItemId());
28339 tejbeer 235 
			if (cartFofo.getPoId() != 0) {
236 
				poIds.add(cartFofo.getPoId());
237 
				poItemIds.add(cartFofo.getPoItemId());
238 
			}
21985 kshitij.so 239 
		}
28339 tejbeer 240 
 
241 
		PendingOrder po = null;
242 
		Customer customer = null;
243 
		PendingOrderItem poi = null;
23973 govind 244 
		Map<Integer, PriceModel> mopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds,
245 
				loginDetails.getFofoId());
246 
		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository
247 
				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());
28339 tejbeer 248 
 
249 
		if (!poIds.isEmpty()) {
250 
			po = pendingOrderRepository.selectById(poIds.get(0));
251 
			customer = customerRepository.selectById(po.getCustomerId());
252 
			if (!offlineOrders.contains(po.getPayMethod())) {
253 
				paymentOptionIds.add(23);
254 
			}
255 
		}
256 
 
257 
		if (!poItemIds.isEmpty()) {
258 
			poi = pendingOrderItemRepository.selectById(poItemIds.get(0));
259 
		}
260 
 
23366 ashik.ali 261 
		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new HashSet<>(paymentOptionIds));
28339 tejbeer 262 
 
263 
		LOGGER.info("pendingOrder" + po);
264 
		LOGGER.info("pendingOrderItem" + poi);
265 
 
22860 ashik.ali 266 
		LOGGER.info("mopPriceMap {}", mopPriceMap);
24844 amit.gupta 267 
		model.addAttribute("stateNames",
268 
				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
23298 ashik.ali 269 
		model.addAttribute("retailerStateName", address.getState());
28339 tejbeer 270 
		model.addAttribute("pendingPOCustomer", gson.toJson(customer));
271 
		model.addAttribute("pendingPO", gson.toJson(po));
272 
 
24440 amit.gupta 273 
		model.addAttribute("cartItems", cartItems);
28339 tejbeer 274 
		model.addAttribute("pendingOrder", po);
275 
		model.addAttribute("pendingOrderItem", poi);
276 
 
22860 ashik.ali 277 
		model.addAttribute("mopPriceMap", mopPriceMap);
23366 ashik.ali 278 
		model.addAttribute("paymentOptions", paymentOptions);
23821 amit.gupta 279 
		model.addAttribute("accessoriesDeals", accessoriesDeals);
22860 ashik.ali 280 
		return "order-index";
21985 kshitij.so 281 
	}
23973 govind 282 
 
24440 amit.gupta 283 
	@RequestMapping(value = "/checkplans", method = RequestMethod.GET)
25726 amit.gupta 284 
	public String getInsurancePrices(HttpServletRequest request, @RequestParam float price, Model model,
285 
			@RequestParam int itemId) throws ProfitMandiBusinessException {
22244 ashik.ali 286 
		LOGGER.info("Request received at url : {}", request.getRequestURI());
24844 amit.gupta 287 
 
24440 amit.gupta 288 
		try {
25726 amit.gupta 289 
			String response = mvcResponseSender.createResponseString(this.getPlans(price, itemId));
24440 amit.gupta 290 
			model.addAttribute("response", response);
291 
		} catch (Exception e) {
292 
			// TODO Auto-generated catch block
293 
			e.printStackTrace();
294 
			throw new ProfitMandiBusinessException("Plans", "Plans API", "Error formatting insurance plans");
295 
		}
24844 amit.gupta 296 
 
24440 amit.gupta 297 
		return "response";
22244 ashik.ali 298 
	}
23973 govind 299 
 
21985 kshitij.so 300 
	@RequestMapping(value = "/get-order", method = RequestMethod.GET)
23973 govind 301 
	public String getOrder(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId,
302 
			Model model) throws ProfitMandiBusinessException {
22927 ashik.ali 303 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
304 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
23638 amit.gupta 305 
		List<FofoOrderItem> fofoLineItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
22927 ashik.ali 306 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
23973 govind 307 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
22927 ashik.ali 308 
		customerAddress.setPhoneNumber(customer.getMobileNumber());
23973 govind 309 
		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
310 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
311 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
312 
				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
313 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
314 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
23343 ashik.ali 315 
		this.addInsuranceProvider(insurancePolicies);
24087 amit.gupta 316 
 
22927 ashik.ali 317 
		model.addAttribute("fofoOrder", fofoOrder);
318 
		model.addAttribute("fofoLineItems", fofoLineItems);
319 
		model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));
320 
		model.addAttribute("customerBillingAddressObj", customerAddress);
23548 ashik.ali 321 
		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
23366 ashik.ali 322 
		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
22927 ashik.ali 323 
		model.addAttribute("insurancePolicies", insurancePolicies);
324 
		return "order-details";
21985 kshitij.so 325 
	}
23973 govind 326 
 
327 
	private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(
328 
			List<InsuranceProvider> insuranceProviders) {
23343 ashik.ali 329 
		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = new HashMap<>();
23973 govind 330 
		for (InsuranceProvider insuranceProvider : insuranceProviders) {
23343 ashik.ali 331 
			insuranceProviderIdInsuranceProviderMap.put(insuranceProvider.getId(), insuranceProvider);
332 
		}
333 
		return insuranceProviderIdInsuranceProviderMap;
334 
	}
23973 govind 335 
 
336 
	private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {
337 
		if (insurancePolicies.isEmpty()) {
23343 ashik.ali 338 
			return;
339 
		}
340 
		Set<Integer> insuranceProviderIds = new HashSet<>();
23973 govind 341 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
23343 ashik.ali 342 
			insuranceProviderIds.add(insurancePolicy.getProviderId());
343 
		}
344 
		LOGGER.info("insuranceProviderIds {}", insuranceProviderIds);
345 
		List<InsuranceProvider> insuranceProviders = insuranceProviderRepository.selectByIds(insuranceProviderIds);
23973 govind 346 
		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this
347 
				.toInsuranceProviderIdInsuranceProvider(insuranceProviders);
348 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
349 
			insurancePolicy
350 
					.setInsuranceProvider(insuranceProviderIdInsuranceProviderMap.get(insurancePolicy.getProviderId()));
23343 ashik.ali 351 
		}
352 
	}
23973 govind 353 
 
22244 ashik.ali 354 
	@RequestMapping(value = "/saleDetails", method = RequestMethod.GET)
23973 govind 355 
	public String getSaleDetails(HttpServletRequest request,
356 
			@RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws Exception {
22927 ashik.ali 357 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
25562 amit.gupta 358 
		boolean isAdmin = roleManager.isAdmin(fofoDetails.getRoleIds());
22927 ashik.ali 359 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
23654 amit.gupta 360 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
22927 ashik.ali 361 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
23973 govind 362 
		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
363 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
364 
 
365 
		// Added Migration info as we lost it.
366 
		if (paymentOptionTransactions == null || paymentOptionTransactions.size() == 0) {
23952 amit.gupta 367 
			PaymentOptionTransaction pot = new PaymentOptionTransaction();
368 
			pot.setAmount(fofoOrder.getTotalAmount());
369 
			pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());
23973 govind 370 
			// Mark it paid through cash
23952 amit.gupta 371 
			pot.setPaymentOptionId(1);
372 
			pot.setReferenceType(PaymentOptionReferenceType.ORDER);
373 
			fofoOrderPaymentOptionRepository.persist(pot);
374 
			paymentOptionTransactions.add(pot);
375 
			LOGGER.info("Added to get invoice");
376 
		}
23973 govind 377 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
378 
				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
379 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
380 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
23343 ashik.ali 381 
		this.addInsuranceProvider(insurancePolicies);
23973 govind 382 
		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
23638 amit.gupta 383 
			try {
384 
				return itemRepository.selectById(x.getItemId());
385 
			} catch (ProfitMandiBusinessException e) {
386 
				// TODO Auto-generated catch block
387 
				return null;
388 
			}
389 
		}));
23973 govind 390 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
391 
				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
23654 amit.gupta 392 
 
23973 govind 393 
		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
394 
				.collect(Collectors.toMap(foi -> foi.getId(),
395 
						foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));
23654 amit.gupta 396 
 
397 
		Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();
23973 govind 398 
 
399 
		for (FofoOrderItem foi : fofoOrderItems) {
400 
			for (FofoLineItem fli : foi.getFofoLineItems()) {
23654 amit.gupta 401 
				inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());
402 
			}
23973 govind 403 
			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
404 
					.selectAllByOrderItemId(foi.getId());
25562 amit.gupta 405 
			this.markDoa(fofoOrder, foi, isAdmin);
23973 govind 406 
			for (CustomerReturnItem customerReturnItem : customerReturnItems) {
407 
				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),
408 
						inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);
23654 amit.gupta 409 
			}
410 
		}
23973 govind 411 
 
23654 amit.gupta 412 
		LOGGER.info("fofoOrderItemIdLineItemMap {}", fofoOrderItemIdLineItemMap);
22927 ashik.ali 413 
		model.addAttribute("fofoOrder", fofoOrder);
23638 amit.gupta 414 
		model.addAttribute("itemsMap", itemsMap);
23654 amit.gupta 415 
		model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));
23973 govind 416 
		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",
417 
				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));
23654 amit.gupta 418 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
419 
		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));
22927 ashik.ali 420 
		model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));
421 
		model.addAttribute("customerBillingAddressObj", customerAddress);
23548 ashik.ali 422 
		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
23366 ashik.ali 423 
		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
22927 ashik.ali 424 
		model.addAttribute("insurancePolicies", insurancePolicies);
23638 amit.gupta 425 
		model.addAttribute("markDefective", this.markDefective(fofoOrder));
22927 ashik.ali 426 
		return "sale-details";
22244 ashik.ali 427 
	}
23973 govind 428 
 
25562 amit.gupta 429 
	private void markDoa(FofoOrder fofoOrder, FofoOrderItem foi, boolean isAdmin) {
25606 tejbeer 430 
		if (isAdmin) {
24094 amit.gupta 431 
			foi.setDoa(true);
25562 amit.gupta 432 
			return;
24094 amit.gupta 433 
		}
29642 amit.gupta 434 
		boolean isImei = foi.getFofoLineItems().stream().anyMatch(x -> org.apache.commons.lang3.StringUtils.isNotEmpty(x.getSerialNumber()) && allowedDoaImeis.contains(x.getSerialNumber()));
24094 amit.gupta 435 
		LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);
436 
		LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
28263 amit.gupta 437 
		if (buyDate.isAfter(curDate.minusDays(45)) || isImei) {
24094 amit.gupta 438 
			foi.setDoa(true);
439 
		} else
440 
			foi.setDoa(
441 
					foi.getBrand().equals("Nokia") && foi.getCost() < 4990 && buyDate.isAfter(curDate.minusYears(1)));
23638 amit.gupta 442 
	}
23973 govind 443 
 
23638 amit.gupta 444 
	private boolean markDefective(FofoOrder fofoOrder) {
23973 govind 445 
		return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(180)
446 
				.isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));
447 
 
23638 amit.gupta 448 
	}
23973 govind 449 
 
23584 ashik.ali 450 
	@RequestMapping(value = "/getSearchOrder")
23973 govind 451 
	public String getSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
23584 ashik.ali 452 
		return "search-order";
453 
	}
23973 govind 454 
 
27819 tejbeer 455 
	@RequestMapping(value = "/getInvoiceSearchOrder")
456 
	public String getInvoiceSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
457 
		return "invoices-cancel";
458 
	}
459 
 
23584 ashik.ali 460 
	@RequestMapping(value = "/customerDetails", method = RequestMethod.PUT)
23973 govind 461 
	public String updateCustomerDetails(HttpServletRequest request, @RequestBody CustomCustomer customCustomer,
462 
			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)
24281 amit.gupta 463 
			throws Exception {
23973 govind 464 
 
23584 ashik.ali 465 
		orderService.updateCustomerDetails(customCustomer, invoiceNumber);
466 
		return this.getSearchOrderDetails(request, invoiceNumber, model);
467 
	}
23973 govind 468 
 
23584 ashik.ali 469 
	@RequestMapping(value = "/searchOrderDetails", method = RequestMethod.GET)
23973 govind 470 
	public String getSearchOrderDetails(HttpServletRequest request,
471 
			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)
24281 amit.gupta 472 
			throws Exception {
23973 govind 473 
 
23584 ashik.ali 474 
		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
24271 amit.gupta 475 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
23584 ashik.ali 476 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
477 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
24105 govind 478 
		List<Integer> fofoPartnerPaymentOptions = fofoPartnerPaymentOptionRepository
479 
				.selectPaymentOptionIdsByFofoId(fofoOrder.getFofoId());
24276 amit.gupta 480 
		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
481 
			try {
482 
				return itemRepository.selectById(x.getItemId());
483 
			} catch (ProfitMandiBusinessException e) {
484 
				// TODO Auto-generated catch block
485 
				return null;
486 
			}
487 
		}));
24105 govind 488 
		LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);
23973 govind 489 
		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
490 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
24105 govind 491 
		LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);
23973 govind 492 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
24105 govind 493 
				.paymentOptionIdPaymentOptionMapUsingPaymentOptions(fofoPartnerPaymentOptions);
494 
		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
495 
				.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
496 
		LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
23973 govind 497 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
498 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
23584 ashik.ali 499 
		this.addInsuranceProvider(insurancePolicies);
500 
		model.addAttribute("fofoOrder", fofoOrder);
24844 amit.gupta 501 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
24271 amit.gupta 502 
			fofoOrderItem.setDoa(true);
503 
		}
24844 amit.gupta 504 
 
24281 amit.gupta 505 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
506 
				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
507 
 
508 
		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
509 
				.collect(Collectors.toMap(foi -> foi.getId(),
510 
						foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));
511 
 
512 
		Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();
513 
 
514 
		for (FofoOrderItem foi : fofoOrderItems) {
515 
			for (FofoLineItem fli : foi.getFofoLineItems()) {
516 
				inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());
517 
			}
518 
			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
519 
					.selectAllByOrderItemId(foi.getId());
520 
			for (CustomerReturnItem customerReturnItem : customerReturnItems) {
521 
				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),
522 
						inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);
523 
			}
524 
		}
525 
		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",
526 
				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));
24271 amit.gupta 527 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
24281 amit.gupta 528 
		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));
529 
		model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));
24276 amit.gupta 530 
		model.addAttribute("itemsMap", itemsMap);
24271 amit.gupta 531 
		model.addAttribute("markDefective", true);
23584 ashik.ali 532 
		model.addAttribute("customer", customer);
533 
		model.addAttribute("customerAddress", customerAddress);
534 
		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
535 
		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
24105 govind 536 
		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);
23584 ashik.ali 537 
		model.addAttribute("insurancePolicies", insurancePolicies);
24105 govind 538 
		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);
539 
		model.addAttribute("totalNumberOfPaymentOptionId", fofoPartnerPaymentOptions.size());
24844 amit.gupta 540 
		model.addAttribute("stateNames",
541 
				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
23584 ashik.ali 542 
		return "search-order-details";
543 
	}
23973 govind 544 
 
545 
	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(
546 
			List<PaymentOptionTransaction> paymentOptionTransactions) {
23366 ashik.ali 547 
		Set<Integer> paymentOptionIds = new HashSet<>();
23973 govind 548 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
23548 ashik.ali 549 
			paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());
23366 ashik.ali 550 
		}
551 
		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(paymentOptionIds);
552 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();
23973 govind 553 
		for (PaymentOption paymentOption : paymentOptions) {
23366 ashik.ali 554 
			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);
555 
		}
556 
		return paymentOptionIdPaymentOptionMap;
557 
	}
23973 govind 558 
 
24105 govind 559 
	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(
560 
			List<Integer> fofoPartnerPaymentOptions) {
561 
		List<PaymentOption> paymentOptions = paymentOptionRepository
562 
				.selectByIds(new HashSet<>(fofoPartnerPaymentOptions));
563 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();
564 
		for (PaymentOption paymentOption : paymentOptions) {
565 
			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);
566 
		}
567 
		return paymentOptionIdPaymentOptionMap;
568 
	}
569 
 
570 
	private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(
571 
			List<PaymentOptionTransaction> paymentOptionTransactions) {
572 
		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = new HashMap<>();
573 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
574 
			paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),
575 
					paymentOptionTransaction);
576 
		}
577 
		return paymentOptionIdPaymentOptionTransactionMap;
578 
	}
579 
 
21985 kshitij.so 580 
	@RequestMapping(value = "/create-order", method = RequestMethod.POST)
23973 govind 581 
	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
582 
			Model model) throws ProfitMandiBusinessException {
26647 tejbeer 583 
		// throw new ProfitMandiBusinessException("Billing is on hold temporarily",
584 
		// "Billing is on hold temporarily", "Billing is on hold temporarily");
26531 amit.gupta 585 
		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
22927 ashik.ali 586 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 587 
 
23823 amit.gupta 588 
		int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);
28339 tejbeer 589 
 
22280 ashik.ali 590 
		LOGGER.info("Order has been created successfully...");
26531 amit.gupta 591 
		return "redirect:/get-order/?orderId=" + fofoOrderId;
21612 ashik.ali 592 
	}
23973 govind 593 
 
23638 amit.gupta 594 
	@RequestMapping(value = "/order/bad_return", method = RequestMethod.POST)
23973 govind 595 
	public ResponseEntity<?> badReturn(HttpServletRequest request, @RequestBody FoiBadReturnRequest foiBadReturnRequest,
596 
			Model model) throws ProfitMandiBusinessException {
23638 amit.gupta 597 
		LOGGER.info("request at uri {} body {}", request.getRequestURI(), foiBadReturnRequest);
598 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
24282 amit.gupta 599 
		CustomerCreditNote custmoerCreditNote;
24844 amit.gupta 600 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
24282 amit.gupta 601 
			FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
602 
			FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());
603 
			custmoerCreditNote = orderService.badReturn(fo.getFofoId(), foiBadReturnRequest);
604 
		} else {
605 
			custmoerCreditNote = orderService.badReturn(fofoDetails.getFofoId(), foiBadReturnRequest);
606 
		}
23654 amit.gupta 607 
		return responseSender.ok(custmoerCreditNote.getId());
23638 amit.gupta 608 
	}
21985 kshitij.so 609 
 
21689 ashik.ali 610 
	@RequestMapping(value = "/generateInvoice")
23973 govind 611 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,
612 
			@RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws ProfitMandiBusinessException {
613 
		LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(),
614 
				ProfitMandiConstants.ORDER_ID, orderId);
22139 amit.gupta 615 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
23594 ashik.ali 616 
		PdfModel pdfModel = null;
23973 govind 617 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
23594 ashik.ali 618 
			pdfModel = orderService.getInvoicePdfModel(orderId);
23973 govind 619 
		} else {
23594 ashik.ali 620 
			pdfModel = orderService.getInvoicePdfModel(fofoDetails.getFofoId(), orderId);
621 
		}
21689 ashik.ali 622 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
24844 amit.gupta 623 
		PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
21689 ashik.ali 624 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
23973 govind 625 
		final HttpHeaders headers = new HttpHeaders();
626 
		headers.setContentType(MediaType.APPLICATION_PDF);
627 
		headers.set("Content-disposition", "inline; filename=invoice-" + pdfModel.getInvoiceNumber() + ".pdf");
628 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
629 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
630 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
631 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
21689 ashik.ali 632 
	}
23973 govind 633 
 
24844 amit.gupta 634 
	@RequestMapping(value = "/generateInvoices")
635 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,
636 
			@RequestParam LocalDateTime startDate, @RequestParam LocalDateTime endDate, @RequestParam int partnerId)
637 
			throws ProfitMandiBusinessException {
638 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
639 
		List<PdfModel> pdfModels = new ArrayList<>();
640 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
641 
			List<Integer> orderIds = fofoOrderRepository.selectByFofoId(partnerId, startDate, endDate, 0, 0).stream()
642 
					.map(x -> x.getId()).collect(Collectors.toList());
643 
			for (int orderId : orderIds) {
644 
				pdfModels.add(orderService.getInvoicePdfModel(orderId));
645 
			}
646 
			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
647 
			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
648 
			LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
649 
			final HttpHeaders headers = new HttpHeaders();
650 
			headers.setContentType(MediaType.APPLICATION_PDF);
651 
			headers.set("Content-disposition", "inline; filename=invoice-" + partnerId + ".pdf");
652 
			headers.setContentLength(byteArrayOutputStream.toByteArray().length);
653 
			final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
654 
			final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
655 
			return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
656 
		} else {
657 
			throw new ProfitMandiBusinessException("Auth", fofoDetails.getEmailId(), "Unauthorised access");
658 
		}
659 
	}
660 
 
22244 ashik.ali 661 
	@RequestMapping(value = "/saleHistory")
23973 govind 662 
	public String saleHistory(HttpServletRequest request,
663 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
664 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
665 
			@RequestParam(required = false) LocalDateTime startTime,
666 
			@RequestParam(required = false) LocalDateTime endTime,
667 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
668 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
669 
			throws ProfitMandiBusinessException {
22927 ashik.ali 670 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 671 
 
672 
		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,
673 
				startTime, endTime, offset, limit);
23203 ashik.ali 674 
		model.addAllAttributes(map);
22244 ashik.ali 675 
		return "sale-history";
676 
	}
23973 govind 677 
 
25092 amit.gupta 678 
	@RequestMapping(value = "/downloadInvoices")
679 
	public ResponseEntity<?> downloadInvoices(HttpServletRequest request,
680 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
681 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
682 
			@RequestParam(required = false) LocalDateTime startTime,
683 
			@RequestParam(required = false) LocalDateTime endTime,
684 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
685 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
686 
			throws ProfitMandiBusinessException {
687 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
688 
 
689 
		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,
690 
				startTime, endTime, offset, 100);
25562 amit.gupta 691 
		List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");
25092 amit.gupta 692 
 
25562 amit.gupta 693 
		if (fofoOrders.size() == 0) {
25092 amit.gupta 694 
			throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");
695 
		}
696 
 
25093 amit.gupta 697 
		final HttpHeaders headers = new HttpHeaders();
25092 amit.gupta 698 
		headers.setContentType(MediaType.APPLICATION_PDF);
699 
		headers.set("Content-disposition", "inline; filename=invoices.pdf");
700 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
701 
		List<PdfModel> pdfModels = new ArrayList<>();
25562 amit.gupta 702 
		for (FofoOrder fofoOrder : fofoOrders) {
25092 amit.gupta 703 
			try {
704 
				pdfModels.add(orderService.getInvoicePdfModel(fofoOrder.getId()));
25606 tejbeer 705 
			} catch (Exception e) {
706 
				LOGGER.info("could not create invoice for {}, invoice number {}", fofoOrder.getId(),
707 
						fofoOrder.getInvoiceNumber());
25092 amit.gupta 708 
			}
709 
		}
710 
		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
711 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
712 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
713 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
714 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
715 
	}
716 
 
23973 govind 717 
	@RequestMapping(value = "/credit-note/{creditNoteId}")
718 
	public ResponseEntity<?> downloadCreditNote(HttpServletRequest request, @PathVariable int creditNoteId)
719 
			throws ProfitMandiBusinessException {
23654 amit.gupta 720 
		CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);
721 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
722 
		PdfUtils.generateAndWriteCustomerCreditNotes(Arrays.asList(creditNotePdfModel), byteArrayOutputStream);
723 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
23973 govind 724 
		final HttpHeaders headers = new HttpHeaders();
725 
		headers.setContentType(MediaType.APPLICATION_PDF);
726 
		headers.set("Content-disposition",
727 
				"inline; filename=invoice-" + creditNotePdfModel.getCreditNoteNumber() + ".pdf");
728 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
729 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
730 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
731 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
23654 amit.gupta 732 
	}
23973 govind 733 
 
22291 ashik.ali 734 
	@RequestMapping(value = "/getPaginatedSaleHistory")
23973 govind 735 
	public String getSaleHistoryPaginated(HttpServletRequest request,
736 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
737 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
738 
			@RequestParam(required = false) LocalDateTime startTime,
739 
			@RequestParam(required = false) LocalDateTime endTime,
740 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
741 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
742 
			throws ProfitMandiBusinessException {
22927 ashik.ali 743 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 744 
		Map<String, Object> map = orderService.getSaleHistoryPaginated(loginDetails.getFofoId(), searchType,
745 
				searchValue, startTime, endTime, offset, limit);
23203 ashik.ali 746 
		model.addAllAttributes(map);
22291 ashik.ali 747 
		return "sale-history-paginated";
748 
	}
749 
 
24105 govind 750 
	@PutMapping(value = "/updatePaymentTransaction")
751 
	public String updateTransactionDetails(HttpServletRequest request, @RequestParam String referenceType,
752 
			@RequestParam int fofoId, @RequestParam int referenceId,
27861 tejbeer 753 
			@RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,
28055 tejbeer 754 
			@RequestParam float totalAmount, Model model) throws Exception {
27861 tejbeer 755 
 
756 
		List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel
757 
				.getPaymentOptionTransactionModel();
24105 govind 758 
		LOGGER.info(paymentOptionTransactionModels);
27861 tejbeer 759 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, referenceId);
760 
		LOGGER.info("sdssd" + fofoOrder);
761 
		fofoOrder.setTotalAmount(totalAmount);
762 
		List<FofoItemIdAmountModel> fofoItemIdAmountModel = partnerOptionsAndItemAmountModel.getItemAmountModel();
763 
		for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {
764 
			LOGGER.info("fim" + fim.getFofoItemId());
28190 tejbeer 765 
 
28189 tejbeer 766 
			LOGGER.info("fimAmount" + fim.getAmount());
27861 tejbeer 767 
			Item item = itemRepository.selectById(fim.getItemId());
768 
			TagListing tagListing = tagListingRepository.selectByItemId(item.getId());
769 
			FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());
28188 tejbeer 770 
			LOGGER.info("category" + item.getCategoryId());
771 
			if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {
28190 tejbeer 772 
				if (fofoOrderItem.getMop() <= fim.getAmount()) {
27861 tejbeer 773 
 
28131 tejbeer 774 
					if (fim.getAmount() <= tagListing.getMrp()) {
27861 tejbeer 775 
						fofoOrderItem.setSellingPrice(fim.getAmount());
776 
					} else {
777 
						throw new ProfitMandiBusinessException("Amount", fim.getAmount(),
778 
								"Sum of amount is not less than  to MRP");
779 
					}
780 
 
781 
					LOGGER.info("fofoOrderItem2" + fofoOrderItem);
782 
 
28190 tejbeer 783 
				} else {
784 
					// TODO below mop condition need to added added
785 
					fofoOrderItem.setSellingPrice(fim.getAmount());
27861 tejbeer 786 
				}
787 
 
788 
			} else {
789 
				fofoOrderItem.setSellingPrice(fim.getAmount());
790 
				LOGGER.info("fofoOrderItem1" + fofoOrderItem);
791 
 
792 
			}
793 
			LOGGER.info("fofoOrderItem" + fofoOrderItem);
794 
 
24105 govind 795 
		}
796 
 
27861 tejbeer 797 
		/*
798 
		 * for (PaymentOptionTransactionModel paymentOptionTransactionModel :
799 
		 * paymentOptionTransactionModels) { amount = amount +
800 
		 * paymentOptionTransactionModel.getAmount(); } LOGGER.info("FofoOrder amount" +
801 
		 * fofoOrder.getTotalAmount() + "amount" + amount); if (amount ==
802 
		 * fofoOrder.getTotalAmount()) {
803 
		 */
804 
		if (paymentOptionTransactionModels.size() > 0) {
805 
			List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
806 
					.selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);
807 
			Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
808 
					.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
809 
			LOGGER.info(
810 
					"paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
811 
			for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {
812 
				if (paymentOptionIdPaymentOptionTransactionMap
813 
						.containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {
24105 govind 814 
 
27861 tejbeer 815 
					PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap
816 
							.get(paymentOptionTransactionModel.getPaymentOptionId());
24105 govind 817 
 
27861 tejbeer 818 
					if (paymentOptionTransactionModel.getAmount() == 0) {
819 
						fofoOrderPaymentOptionRepository.delete(paymentOptionTransaction);
820 
						LOGGER.info("deleted successfully");
821 
					} else {
24105 govind 822 
 
27861 tejbeer 823 
						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());
824 
						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);
825 
						LOGGER.info("updated successfully");
826 
 
24105 govind 827 
					}
27861 tejbeer 828 
				} else {
829 
					if (paymentOptionTransactionModel.getAmount() > 0) {
830 
						PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();
831 
						paymentOptionTransaction.setReferenceId(referenceId);
832 
						paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);
833 
						paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());
834 
						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());
835 
						paymentOptionTransaction.setFofoId(fofoId);
836 
						paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());
837 
						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);
838 
						LOGGER.info("inserted successfully");
839 
					}
24105 govind 840 
				}
841 
 
842 
			}
27861 tejbeer 843 
 
844 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24105 govind 845 
		}
27861 tejbeer 846 
		/*
847 
		 * else
848 
		 *
849 
		 * { throw new ProfitMandiBusinessException("Amount", amount,
850 
		 * "Sum of amount is not equal to total amount"); }
851 
		 */
24105 govind 852 
 
853 
		return "response";
27861 tejbeer 854 
 
24105 govind 855 
	}
24440 amit.gupta 856 
 
25726 amit.gupta 857 
	private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice, int itemId)
858 
			throws ProfitMandiBusinessException {
859 
		try {
860 
			Map<String, List<MobileInsurancePlan>> productDurationPlans = insuranceService.getAllPlans(itemId,
861 
					sellingPrice);
862 
			return productDurationPlans;
863 
		} catch (Exception e) {
864 
			e.printStackTrace();
865 
			throw new ProfitMandiBusinessException("Fetch Insurance Plans", "Insurance",
26647 tejbeer 866 
					"Could not fetch insurance Plans");
25726 amit.gupta 867 
		}
868 
 
24440 amit.gupta 869 
	}
24880 govind 870 
 
871 
	@GetMapping("/insuranceDetails")
872 
	public String getInsuranceDetails(HttpServletRequest request,
873 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
874 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
875 
			throws ProfitMandiBusinessException {
876 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
877 
		long size = 0;
878 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),
879 
				offset, limit);
880 
		size = insurancePolicyRepository.selectCountByRetailerId(loginDetails.getFofoId());
881 
		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository
882 
				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))
883 
				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));
884 
		if (size < limit) {
885 
			model.addAttribute("end", offset + size);
886 
		} else {
887 
			model.addAttribute("end", offset + limit);
888 
		}
889 
		model.addAttribute("start", offset + 1);
890 
		model.addAttribute("size", size);
891 
		model.addAttribute("insurancePolicies", insurancePolicies);
892 
		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);
893 
		return "insurance-details";
894 
	}
25092 amit.gupta 895 
 
24880 govind 896 
	@GetMapping("/insuranceDetailsPaginated")
897 
	public String getInsuranceDetailsPaginated(HttpServletRequest request,
898 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
899 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
900 
			throws ProfitMandiBusinessException {
901 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
902 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),
903 
				offset, limit);
904 
		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository
905 
				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))
906 
				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));
907 
		model.addAttribute("insurancePolicies", insurancePolicies);
908 
		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);
909 
		return "insurance-details-paginated";
910 
	}
26647 tejbeer 911 
 
28420 tejbeer 912 
	@GetMapping("/getMouForm")
913 
	public String getMouForm(HttpServletRequest request, Model model) throws Exception {
914 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
915 
 
916 
		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
917 
		if (mou != null) {
28425 tejbeer 918 
			if (mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
919 
				model.addAttribute("response", mvcResponseSender.createResponseString(true));
920 
			} else {
921 
				model.addAttribute("response", mvcResponseSender.createResponseString(false));
922 
			}
923 
 
28420 tejbeer 924 
		} else {
925 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
926 
 
927 
		}
928 
		return "response";
929 
 
930 
	}
931 
 
26647 tejbeer 932 
	@GetMapping("/pendingOrders")
26663 tejbeer 933 
	public String getPendingOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
26647 tejbeer 934 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
935 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
28420 tejbeer 936 
		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
937 
		if (mou == null) {
938 
			mou = new Mou();
939 
			mou.setFofoId(loginDetails.getFofoId());
940 
			mou.setCreateTimestamp(LocalDateTime.now());
28425 tejbeer 941 
			mou.setUpdateTimestamp(LocalDateTime.now());
28420 tejbeer 942 
			mouRepository.persist(mou);
28425 tejbeer 943 
		} else if (!mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
944 
			mou.setUpdateTimestamp(LocalDateTime.now());
28420 tejbeer 945 
		}
26647 tejbeer 946 
 
28339 tejbeer 947 
		List<PendingOrderItem> pendingOrderItem = null;
948 
 
28420 tejbeer 949 
		pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.PROCESSING,
950 
				loginDetails.getFofoId());
28339 tejbeer 951 
 
28358 tejbeer 952 
		Map<String, Object> map = null;
27046 tejbeer 953 
 
28420 tejbeer 954 
		map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
955 
		model.addAttribute("inventoryMap", map.get("inventoryMap"));
27046 tejbeer 956 
 
28350 tejbeer 957 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
958 
 
28358 tejbeer 959 
		LOGGER.info("partnerInventoryMap" + map.get("partnerInventoryMap"));
28350 tejbeer 960 
		model.addAttribute("isAdmin", isAdmin);
28358 tejbeer 961 
		return "pending_fofo_order";
962 
 
28350 tejbeer 963 
	}
964 
 
28339 tejbeer 965 
	@GetMapping("/billedOrders")
966 
	public String getBilledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
967 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
968 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
969 
 
970 
		List<PendingOrderItem> pendingOrderItem = null;
971 
 
972 
		if (isAdmin) {
973 
 
974 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);
975 
 
976 
		} else {
977 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
978 
					loginDetails.getFofoId());
27046 tejbeer 979 
		}
980 
 
28339 tejbeer 981 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
982 
 
983 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
26817 amit.gupta 984 
		model.addAttribute("isAdmin", isAdmin);
28339 tejbeer 985 
		return "billed_order_item";
26647 tejbeer 986 
	}
987 
 
28339 tejbeer 988 
	@GetMapping("/settledOrders")
989 
	public String getSettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
990 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
991 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
992 
 
993 
		List<PendingOrderItem> pendingOrderItem = null;
994 
 
995 
		if (isAdmin) {
996 
 
997 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.SETTLED);
998 
 
999 
		} else {
1000 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.SETTLED,
1001 
					loginDetails.getFofoId());
1002 
		}
1003 
 
1004 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1005 
 
1006 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1007 
		model.addAttribute("isAdmin", isAdmin);
1008 
		return "settled_order_item";
1009 
	}
1010 
 
1011 
	@GetMapping("/unsettledOrders")
1012 
	public String getunsettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
1013 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1014 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1015 
 
1016 
		List<PendingOrderItem> pendingOrderItem = null;
1017 
 
1018 
		if (isAdmin) {
1019 
 
1020 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.UNSETTLED);
1021 
 
1022 
		} else {
1023 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.UNSETTLED,
1024 
					loginDetails.getFofoId());
1025 
		}
1026 
 
1027 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1028 
 
1029 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1030 
		model.addAttribute("isAdmin", isAdmin);
1031 
		return "unsettled_order_item";
1032 
	}
1033 
 
1034 
	@GetMapping("/claimedOrders")
1035 
	public String getclaimedOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
1036 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1037 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1038 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1039 
				.collect(Collectors.toList());
1040 
 
1041 
		List<PendingOrderItem> pendingOrderItem = null;
1042 
 
1043 
		if (isAdmin) {
1044 
 
1045 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.CLAIMED);
1046 
			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1047 
			model.addAttribute("customRetailersMap", customRetailersMap);
1048 
 
1049 
		} else {
1050 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.CLAIMED,
1051 
					loginDetails.getFofoId());
1052 
		}
1053 
 
1054 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1055 
 
1056 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1057 
		model.addAttribute("isAdmin", isAdmin);
1058 
		return "claim_raised_order_item";
1059 
	}
1060 
 
26647 tejbeer 1061 
	@GetMapping("/getPendingOrderItem")
1062 
	public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)
1063 
			throws ProfitMandiBusinessException {
1064 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1065 
		Map<Integer, Item> itemMap = new HashMap<>();
1066 
		Map<Integer, CurrentInventorySnapshot> inventoryMap = new HashMap<>();
26817 amit.gupta 1067 
		PendingOrder pendingPO = pendingOrderRepository.selectById(orderId);
1068 
		Customer customer = customerRepository.selectById(pendingPO.getCustomerId());
26647 tejbeer 1069 
		List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);
1070 
		for (PendingOrderItem pendingOrderItem : pendingOrderItems) {
1071 
			Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1072 
			CurrentInventorySnapshot cis = currentInventorySnapshotRepository
28339 tejbeer 1073 
					.selectByItemAndFofoId(pendingOrderItem.getItemId(), pendingPO.getFofoId());
26647 tejbeer 1074 
			itemMap.put(pendingOrderItem.getItemId(), item);
1075 
			LOGGER.info("cis" + cis);
1076 
			inventoryMap.put(pendingOrderItem.getItemId(), cis);
1077 
		}
1078 
 
1079 
		LOGGER.info("inventoryMap" + inventoryMap);
1080 
		model.addAttribute("pendingOrderItems", pendingOrderItems);
1081 
		model.addAttribute("itemMap", itemMap);
1082 
		model.addAttribute("inventoryMap", inventoryMap);
26817 amit.gupta 1083 
		model.addAttribute("pendingPO", gson.toJson(pendingPO));
1084 
		model.addAttribute("pendingPOCustomer", gson.toJson(customer));
26721 tejbeer 1085 
		model.addAttribute("isAdmin", roleManager.isAdmin(loginDetails.getRoleIds()));
26647 tejbeer 1086 
		return "pending-order-item";
1087 
	}
26721 tejbeer 1088 
 
28352 tejbeer 1089 
	@RequestMapping(value = "/getPendingOrderItemById", method = RequestMethod.GET)
1090 
	public String getPendingOrderItemById(HttpServletRequest request, @RequestParam int id, Model model)
26721 tejbeer 1091 
			throws Exception {
27046 tejbeer 1092 
 
28352 tejbeer 1093 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1094 
		model.addAttribute("pendingOrderItem", pendingOrderItem);
1095 
		return "cancel-pending-order";
1096 
	}
1097 
 
28437 tejbeer 1098 
	@RequestMapping(value = "/getPendingOrderChangePartnerById", method = RequestMethod.GET)
1099 
	public String getPendingOrderChangePartnerById(HttpServletRequest request, @RequestParam int id, Model model)
1100 
			throws Exception {
1101 
 
1102 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
1103 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(true);
1104 
		model.addAttribute("customRetailersMap", customRetailersMap);
1105 
		model.addAttribute("pendingOrder", pendingOrder);
1106 
		return "change-partner-po";
1107 
	}
1108 
 
1109 
	@RequestMapping(value = "/changePendingOrderPartner", method = RequestMethod.POST)
1110 
	public String changePendingOrderPartner(HttpServletRequest request, @RequestParam int id, @RequestParam int fofoId,
1111 
			Model model) throws Exception {
1112 
 
1113 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
1114 
		pendingOrder.setFofoId(fofoId);
1115 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1116 
 
1117 
		return "response";
1118 
	}
1119 
 
28352 tejbeer 1120 
	@RequestMapping(value = "/cancelPendingOrderItem", method = RequestMethod.POST)
1121 
	public String cancelPendingOrderItem(HttpServletRequest request, @RequestParam int id, @RequestParam String reason,
1122 
			Model model) throws Exception {
1123 
 
27046 tejbeer 1124 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
26721 tejbeer 1125 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1126 
 
27046 tejbeer 1127 
		pendingOrderItem.setStatus(OrderStatus.CANCELLED);
1128 
		pendingOrderItem.setStatusDescription(loginDetails.getEmailId());
28352 tejbeer 1129 
		pendingOrderItem.setRemark(reason);
1130 
		pendingOrderItem.setCancelledTimestamp(LocalDateTime.now());
27057 tejbeer 1131 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
26721 tejbeer 1132 
 
27046 tejbeer 1133 
		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
26721 tejbeer 1134 
				.map(x -> x.getStatus()).collect(Collectors.toList());
1135 
 
28352 tejbeer 1136 
		Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
1137 
 
1138 
		List<Integer> catalogIds = new ArrayList<>();
1139 
 
1140 
		Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1141 
		pendingOrderItem.setItemName(item.getItemDescription());
1142 
		catalogIds.add(item.getCatalogItemId());
1143 
 
1144 
		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
1145 
		JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
1146 
		pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
1147 
		pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
1148 
		CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());
1149 
 
1150 
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");
1151 
 
1152 
		Map<String, Object> emailModel = new HashMap<>();
1153 
		emailModel.put("customer", customerAddress);
1154 
		emailModel.put("pendingOrder", pendingOrder);
1155 
		emailModel.put("date", dateTimeFormatter);
28427 tejbeer 1156 
		LOGGER.info("emal" + customer.getEmailId());
28352 tejbeer 1157 
		String[] customerEmail = null;
28427 tejbeer 1158 
		if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
28356 tejbeer 1159 
			customerEmail = new String[] { customer.getEmailId() };
28352 tejbeer 1160 
 
28356 tejbeer 1161 
			List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
1162 
 
28377 tejbeer 1163 
			emailService.sendMailWithAttachments("Order Cancellation", "order-cancellation.vm", emailModel,
28356 tejbeer 1164 
					customerEmail, null, bccTo.toArray(new String[0]));
28352 tejbeer 1165 
 
1166 
		}
1167 
 
28345 tejbeer 1168 
		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
1169 
				&& !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
1170 
				&& !status.contains(OrderStatus.CLAIMED)) {
27046 tejbeer 1171 
			pendingOrder.setStatus(OrderStatus.CLOSED);
26721 tejbeer 1172 
		}
1173 
		pendingOrderItemRepository.persist(pendingOrderItem);
28352 tejbeer 1174 
 
26721 tejbeer 1175 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1176 
 
1177 
		return "response";
1178 
	}
27046 tejbeer 1179 
 
28339 tejbeer 1180 
	@RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
1181 
	public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)
1182 
			throws Exception {
1183 
 
1184 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1185 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1186 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
1187 
 
1188 
		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
1189 
			pendingOrderItem.setStatus(OrderStatus.UNSETTLED);
1190 
			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
1191 
 
1192 
		} else {
1193 
			pendingOrderItem.setStatus(OrderStatus.SETTLED);
1194 
			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
1195 
 
1196 
		}
1197 
 
1198 
		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
1199 
				.map(x -> x.getStatus()).collect(Collectors.toList());
1200 
 
1201 
		List<Integer> catalogIds = new ArrayList<>();
1202 
 
1203 
		Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1204 
		pendingOrderItem.setItemName(item.getItemDescription());
1205 
		catalogIds.add(item.getCatalogItemId());
1206 
 
1207 
		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
1208 
		JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
1209 
		pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
1210 
		pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
1211 
		CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());
1212 
 
1213 
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");
1214 
 
1215 
		Map<String, Object> emailModel = new HashMap<>();
1216 
		emailModel.put("customer", customerAddress);
1217 
		emailModel.put("pendingOrder", pendingOrder);
1218 
		emailModel.put("date", dateTimeFormatter);
1219 
		Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
1220 
		String[] customerEmail = null;
28427 tejbeer 1221 
		if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
28356 tejbeer 1222 
			customerEmail = new String[] { customer.getEmailId() };
1223 
			List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
28339 tejbeer 1224 
 
1225 
			emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
28356 tejbeer 1226 
					customerEmail, null, bccTo.toArray(new String[0]));
28339 tejbeer 1227 
 
1228 
		}
28345 tejbeer 1229 
		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
1230 
				&& !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
1231 
				&& !status.contains(OrderStatus.CLAIMED))
28339 tejbeer 1232 
 
1233 
		{
1234 
			pendingOrder.setStatus(OrderStatus.CLOSED);
1235 
		}
1236 
		pendingOrderItemRepository.persist(pendingOrderItem);
1237 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1238 
 
1239 
		return "response";
1240 
	}
1241 
 
1242 
	@RequestMapping(value = "/raiseClaimOrderItem", method = RequestMethod.POST)
1243 
	public String raiseClaimOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
1244 
 
1245 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1246 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1247 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
1248 
 
1249 
		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
1250 
			pendingOrderItem.setStatus(OrderStatus.CLAIMED);
1251 
			pendingOrderItem.setClaimedTimestamp(LocalDateTime.now());
1252 
 
1253 
		}
1254 
		pendingOrderItemRepository.persist(pendingOrderItem);
1255 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1256 
 
1257 
		return "response";
1258 
	}
1259 
 
28344 tejbeer 1260 
	@RequestMapping(value = "/verifyOrderItem", method = RequestMethod.POST)
1261 
	public String verifyOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
1262 
 
1263 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1264 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1265 
		pendingOrderItem.setVerifiedTimestamp(LocalDateTime.now());
28350 tejbeer 1266 
 
1267 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1268 
 
28344 tejbeer 1269 
		return "response";
1270 
	}
1271 
 
27819 tejbeer 1272 
	@RequestMapping(value = "/cancelOrderByInvoice", method = RequestMethod.POST)
1273 
	public String cancelOrder(HttpServletRequest request, @RequestParam List<String> invoiceNumbers, Model model)
1274 
			throws Exception {
1275 
		orderService.cancelOrder(invoiceNumbers);
1276 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1277 
 
1278 
		return "response";
1279 
	}
1280 
 
28358 tejbeer 1281 
	@RequestMapping(value = "/getOnlineOrder", method = RequestMethod.GET)
1282 
	public String cancelOrder(HttpServletRequest request, Model model) throws Exception {
1283 
		return "online-order";
1284 
	}
1285 
 
1286 
	@GetMapping("/getAllOrdersByStatus")
1287 
	public String getAllOrdersByStatus(HttpServletRequest request, @RequestParam OrderStatus status,
28420 tejbeer 1288 
			@RequestParam(required = false) LocalDateTime startTime,
1289 
			@RequestParam(required = false) LocalDateTime endTime, Model model) throws ProfitMandiBusinessException {
28358 tejbeer 1290 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1291 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1292 
 
28420 tejbeer 1293 
		LOGGER.info("startTime" + startTime);
1294 
 
1295 
		LOGGER.info("endTime" + endTime);
1296 
 
28358 tejbeer 1297 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1298 
				.collect(Collectors.toList());
1299 
 
1300 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1301 
		model.addAttribute("customRetailersMap", customRetailersMap);
1302 
 
1303 
		List<PendingOrderItem> pendingOrderItem = null;
28420 tejbeer 1304 
		if (startTime == null) {
1305 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(status);
1306 
		} else {
1307 
			List<OrderStatus> statusList = new ArrayList<>();
1308 
			if (status.equals(OrderStatus.DELIVERED)) {
1309 
				statusList.add(OrderStatus.SETTLED);
1310 
				statusList.add(OrderStatus.UNSETTLED);
1311 
			} else {
1312 
				statusList.add(status);
1313 
			}
28429 tejbeer 1314 
			pendingOrderItem = pendingOrderItemRepository.selectByStatusAndCreateTimestamp(statusList,
1315 
					startTime.toLocalDate().atStartOfDay(), endTime);
28420 tejbeer 1316 
		}
28361 tejbeer 1317 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, 0);
28358 tejbeer 1318 
 
1319 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
28361 tejbeer 1320 
		model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
28358 tejbeer 1321 
 
1322 
		model.addAttribute("isAdmin", isAdmin);
1323 
		return "online-order-item";
1324 
	}
28377 tejbeer 1325 
 
1326 
	@GetMapping("/getAllOnlineOrder")
1327 
	public String getAllOrders(HttpServletRequest request, @RequestParam(required = false) LocalDate date, Model model)
1328 
			throws ProfitMandiBusinessException {
1329 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1330 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1331 
		if (date == null) {
1332 
			date = LocalDate.now().minusDays(3);
1333 
		}
1334 
 
1335 
		LOGGER.info("date" + date);
1336 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1337 
				.collect(Collectors.toList());
1338 
 
1339 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1340 
		model.addAttribute("customRetailersMap", customRetailersMap);
1341 
 
1342 
		List<PendingOrderItem> pendingOrderItem = null;
1343 
 
1344 
		pendingOrderItem = pendingOrderItemRepository.selectAll(date.atStartOfDay(), LocalDateTime.now());
1345 
 
1346 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, 0);
1347 
 
1348 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1349 
		model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
1350 
		model.addAttribute("date", date);
1351 
		model.addAttribute("isAdmin", isAdmin);
1352 
		return "online-all-order-item";
1353 
	}
21612 ashik.ali 1354 
}