Subversion Repositories SmartDukaan

Rev

Rev 29642 | Rev 30148 | 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));
29707 tejbeer 418 
		model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);
419 
 
23654 amit.gupta 420 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
421 
		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));
22927 ashik.ali 422 
		model.addAttribute("customerBillingAddress", orderService.getBillingAddress(customerAddress));
423 
		model.addAttribute("customerBillingAddressObj", customerAddress);
23548 ashik.ali 424 
		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
23366 ashik.ali 425 
		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
22927 ashik.ali 426 
		model.addAttribute("insurancePolicies", insurancePolicies);
23638 amit.gupta 427 
		model.addAttribute("markDefective", this.markDefective(fofoOrder));
22927 ashik.ali 428 
		return "sale-details";
22244 ashik.ali 429 
	}
23973 govind 430 
 
25562 amit.gupta 431 
	private void markDoa(FofoOrder fofoOrder, FofoOrderItem foi, boolean isAdmin) {
25606 tejbeer 432 
		if (isAdmin) {
24094 amit.gupta 433 
			foi.setDoa(true);
25562 amit.gupta 434 
			return;
24094 amit.gupta 435 
		}
29707 tejbeer 436 
		boolean isImei = foi.getFofoLineItems().stream()
437 
				.anyMatch(x -> org.apache.commons.lang3.StringUtils.isNotEmpty(x.getSerialNumber())
438 
						&& allowedDoaImeis.contains(x.getSerialNumber()));
24094 amit.gupta 439 
		LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);
440 
		LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
28263 amit.gupta 441 
		if (buyDate.isAfter(curDate.minusDays(45)) || isImei) {
24094 amit.gupta 442 
			foi.setDoa(true);
443 
		} else
444 
			foi.setDoa(
445 
					foi.getBrand().equals("Nokia") && foi.getCost() < 4990 && buyDate.isAfter(curDate.minusYears(1)));
23638 amit.gupta 446 
	}
23973 govind 447 
 
23638 amit.gupta 448 
	private boolean markDefective(FofoOrder fofoOrder) {
23973 govind 449 
		return fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS).plusDays(180)
450 
				.isAfter(LocalDateTime.now().truncatedTo(ChronoUnit.DAYS));
451 
 
23638 amit.gupta 452 
	}
23973 govind 453 
 
23584 ashik.ali 454 
	@RequestMapping(value = "/getSearchOrder")
23973 govind 455 
	public String getSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
23584 ashik.ali 456 
		return "search-order";
457 
	}
23973 govind 458 
 
27819 tejbeer 459 
	@RequestMapping(value = "/getInvoiceSearchOrder")
460 
	public String getInvoiceSearchOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
461 
		return "invoices-cancel";
462 
	}
463 
 
23584 ashik.ali 464 
	@RequestMapping(value = "/customerDetails", method = RequestMethod.PUT)
23973 govind 465 
	public String updateCustomerDetails(HttpServletRequest request, @RequestBody CustomCustomer customCustomer,
466 
			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)
24281 amit.gupta 467 
			throws Exception {
23973 govind 468 
 
23584 ashik.ali 469 
		orderService.updateCustomerDetails(customCustomer, invoiceNumber);
470 
		return this.getSearchOrderDetails(request, invoiceNumber, model);
471 
	}
23973 govind 472 
 
23584 ashik.ali 473 
	@RequestMapping(value = "/searchOrderDetails", method = RequestMethod.GET)
23973 govind 474 
	public String getSearchOrderDetails(HttpServletRequest request,
475 
			@RequestParam(name = ProfitMandiConstants.INVOICE_NUMBER) String invoiceNumber, Model model)
24281 amit.gupta 476 
			throws Exception {
23973 govind 477 
 
23584 ashik.ali 478 
		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
24271 amit.gupta 479 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
23584 ashik.ali 480 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
481 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
24105 govind 482 
		List<Integer> fofoPartnerPaymentOptions = fofoPartnerPaymentOptionRepository
483 
				.selectPaymentOptionIdsByFofoId(fofoOrder.getFofoId());
24276 amit.gupta 484 
		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
485 
			try {
486 
				return itemRepository.selectById(x.getItemId());
487 
			} catch (ProfitMandiBusinessException e) {
488 
				// TODO Auto-generated catch block
489 
				return null;
490 
			}
491 
		}));
24105 govind 492 
		LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);
23973 govind 493 
		List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
494 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
24105 govind 495 
		LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);
23973 govind 496 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
24105 govind 497 
				.paymentOptionIdPaymentOptionMapUsingPaymentOptions(fofoPartnerPaymentOptions);
498 
		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
499 
				.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
500 
		LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
23973 govind 501 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
502 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
23584 ashik.ali 503 
		this.addInsuranceProvider(insurancePolicies);
504 
		model.addAttribute("fofoOrder", fofoOrder);
24844 amit.gupta 505 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
24271 amit.gupta 506 
			fofoOrderItem.setDoa(true);
507 
		}
24844 amit.gupta 508 
 
24281 amit.gupta 509 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
510 
				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
511 
 
512 
		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
513 
				.collect(Collectors.toMap(foi -> foi.getId(),
514 
						foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));
515 
 
516 
		Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();
517 
 
518 
		for (FofoOrderItem foi : fofoOrderItems) {
519 
			for (FofoLineItem fli : foi.getFofoLineItems()) {
520 
				inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());
521 
			}
522 
			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
523 
					.selectAllByOrderItemId(foi.getId());
524 
			for (CustomerReturnItem customerReturnItem : customerReturnItems) {
525 
				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),
526 
						inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);
527 
			}
528 
		}
529 
		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",
530 
				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));
24271 amit.gupta 531 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
24281 amit.gupta 532 
		model.addAttribute("inventoryItemBilledQtyMap", StringUtils.toString(inventoryItemBilledQtyMap));
533 
		model.addAttribute("fofoOrderItemIdLineItemsMap", StringUtils.toString(fofoOrderItemIdLineItemMap));
24276 amit.gupta 534 
		model.addAttribute("itemsMap", itemsMap);
24271 amit.gupta 535 
		model.addAttribute("markDefective", true);
23584 ashik.ali 536 
		model.addAttribute("customer", customer);
537 
		model.addAttribute("customerAddress", customerAddress);
538 
		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);
539 
		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
24105 govind 540 
		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);
23584 ashik.ali 541 
		model.addAttribute("insurancePolicies", insurancePolicies);
24105 govind 542 
		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);
543 
		model.addAttribute("totalNumberOfPaymentOptionId", fofoPartnerPaymentOptions.size());
24844 amit.gupta 544 
		model.addAttribute("stateNames",
545 
				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
23584 ashik.ali 546 
		return "search-order-details";
547 
	}
23973 govind 548 
 
549 
	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(
550 
			List<PaymentOptionTransaction> paymentOptionTransactions) {
23366 ashik.ali 551 
		Set<Integer> paymentOptionIds = new HashSet<>();
23973 govind 552 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
23548 ashik.ali 553 
			paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());
23366 ashik.ali 554 
		}
555 
		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(paymentOptionIds);
556 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();
23973 govind 557 
		for (PaymentOption paymentOption : paymentOptions) {
23366 ashik.ali 558 
			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);
559 
		}
560 
		return paymentOptionIdPaymentOptionMap;
561 
	}
23973 govind 562 
 
24105 govind 563 
	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(
564 
			List<Integer> fofoPartnerPaymentOptions) {
565 
		List<PaymentOption> paymentOptions = paymentOptionRepository
566 
				.selectByIds(new HashSet<>(fofoPartnerPaymentOptions));
567 
		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = new HashMap<>();
568 
		for (PaymentOption paymentOption : paymentOptions) {
569 
			paymentOptionIdPaymentOptionMap.put(paymentOption.getId(), paymentOption);
570 
		}
571 
		return paymentOptionIdPaymentOptionMap;
572 
	}
573 
 
574 
	private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(
575 
			List<PaymentOptionTransaction> paymentOptionTransactions) {
576 
		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = new HashMap<>();
577 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
578 
			paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),
579 
					paymentOptionTransaction);
580 
		}
581 
		return paymentOptionIdPaymentOptionTransactionMap;
582 
	}
583 
 
21985 kshitij.so 584 
	@RequestMapping(value = "/create-order", method = RequestMethod.POST)
23973 govind 585 
	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
586 
			Model model) throws ProfitMandiBusinessException {
26647 tejbeer 587 
		// throw new ProfitMandiBusinessException("Billing is on hold temporarily",
588 
		// "Billing is on hold temporarily", "Billing is on hold temporarily");
26531 amit.gupta 589 
		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
22927 ashik.ali 590 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 591 
 
23823 amit.gupta 592 
		int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);
28339 tejbeer 593 
 
22280 ashik.ali 594 
		LOGGER.info("Order has been created successfully...");
26531 amit.gupta 595 
		return "redirect:/get-order/?orderId=" + fofoOrderId;
21612 ashik.ali 596 
	}
23973 govind 597 
 
23638 amit.gupta 598 
	@RequestMapping(value = "/order/bad_return", method = RequestMethod.POST)
23973 govind 599 
	public ResponseEntity<?> badReturn(HttpServletRequest request, @RequestBody FoiBadReturnRequest foiBadReturnRequest,
600 
			Model model) throws ProfitMandiBusinessException {
23638 amit.gupta 601 
		LOGGER.info("request at uri {} body {}", request.getRequestURI(), foiBadReturnRequest);
602 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
24282 amit.gupta 603 
		CustomerCreditNote custmoerCreditNote;
24844 amit.gupta 604 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
24282 amit.gupta 605 
			FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
606 
			FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());
607 
			custmoerCreditNote = orderService.badReturn(fo.getFofoId(), foiBadReturnRequest);
608 
		} else {
609 
			custmoerCreditNote = orderService.badReturn(fofoDetails.getFofoId(), foiBadReturnRequest);
610 
		}
23654 amit.gupta 611 
		return responseSender.ok(custmoerCreditNote.getId());
23638 amit.gupta 612 
	}
21985 kshitij.so 613 
 
21689 ashik.ali 614 
	@RequestMapping(value = "/generateInvoice")
23973 govind 615 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,
616 
			@RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws ProfitMandiBusinessException {
617 
		LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(),
618 
				ProfitMandiConstants.ORDER_ID, orderId);
22139 amit.gupta 619 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
23594 ashik.ali 620 
		PdfModel pdfModel = null;
23973 govind 621 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
23594 ashik.ali 622 
			pdfModel = orderService.getInvoicePdfModel(orderId);
23973 govind 623 
		} else {
23594 ashik.ali 624 
			pdfModel = orderService.getInvoicePdfModel(fofoDetails.getFofoId(), orderId);
625 
		}
21689 ashik.ali 626 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
24844 amit.gupta 627 
		PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
21689 ashik.ali 628 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
23973 govind 629 
		final HttpHeaders headers = new HttpHeaders();
630 
		headers.setContentType(MediaType.APPLICATION_PDF);
631 
		headers.set("Content-disposition", "inline; filename=invoice-" + pdfModel.getInvoiceNumber() + ".pdf");
632 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
633 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
634 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
635 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
21689 ashik.ali 636 
	}
23973 govind 637 
 
24844 amit.gupta 638 
	@RequestMapping(value = "/generateInvoices")
639 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,
640 
			@RequestParam LocalDateTime startDate, @RequestParam LocalDateTime endDate, @RequestParam int partnerId)
641 
			throws ProfitMandiBusinessException {
642 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
643 
		List<PdfModel> pdfModels = new ArrayList<>();
644 
		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
645 
			List<Integer> orderIds = fofoOrderRepository.selectByFofoId(partnerId, startDate, endDate, 0, 0).stream()
646 
					.map(x -> x.getId()).collect(Collectors.toList());
647 
			for (int orderId : orderIds) {
648 
				pdfModels.add(orderService.getInvoicePdfModel(orderId));
649 
			}
650 
			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
651 
			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
652 
			LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
653 
			final HttpHeaders headers = new HttpHeaders();
654 
			headers.setContentType(MediaType.APPLICATION_PDF);
655 
			headers.set("Content-disposition", "inline; filename=invoice-" + partnerId + ".pdf");
656 
			headers.setContentLength(byteArrayOutputStream.toByteArray().length);
657 
			final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
658 
			final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
659 
			return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
660 
		} else {
661 
			throw new ProfitMandiBusinessException("Auth", fofoDetails.getEmailId(), "Unauthorised access");
662 
		}
663 
	}
664 
 
22244 ashik.ali 665 
	@RequestMapping(value = "/saleHistory")
23973 govind 666 
	public String saleHistory(HttpServletRequest request,
667 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
668 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
669 
			@RequestParam(required = false) LocalDateTime startTime,
670 
			@RequestParam(required = false) LocalDateTime endTime,
671 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
672 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
673 
			throws ProfitMandiBusinessException {
22927 ashik.ali 674 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 675 
 
676 
		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,
677 
				startTime, endTime, offset, limit);
23203 ashik.ali 678 
		model.addAllAttributes(map);
22244 ashik.ali 679 
		return "sale-history";
680 
	}
23973 govind 681 
 
25092 amit.gupta 682 
	@RequestMapping(value = "/downloadInvoices")
683 
	public ResponseEntity<?> downloadInvoices(HttpServletRequest request,
684 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
685 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
686 
			@RequestParam(required = false) LocalDateTime startTime,
687 
			@RequestParam(required = false) LocalDateTime endTime,
688 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
689 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
690 
			throws ProfitMandiBusinessException {
691 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
692 
 
693 
		Map<String, Object> map = orderService.getSaleHistory(loginDetails.getFofoId(), searchType, searchValue,
694 
				startTime, endTime, offset, 100);
25562 amit.gupta 695 
		List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");
25092 amit.gupta 696 
 
25562 amit.gupta 697 
		if (fofoOrders.size() == 0) {
25092 amit.gupta 698 
			throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");
699 
		}
700 
 
25093 amit.gupta 701 
		final HttpHeaders headers = new HttpHeaders();
25092 amit.gupta 702 
		headers.setContentType(MediaType.APPLICATION_PDF);
703 
		headers.set("Content-disposition", "inline; filename=invoices.pdf");
704 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
705 
		List<PdfModel> pdfModels = new ArrayList<>();
25562 amit.gupta 706 
		for (FofoOrder fofoOrder : fofoOrders) {
25092 amit.gupta 707 
			try {
708 
				pdfModels.add(orderService.getInvoicePdfModel(fofoOrder.getId()));
25606 tejbeer 709 
			} catch (Exception e) {
710 
				LOGGER.info("could not create invoice for {}, invoice number {}", fofoOrder.getId(),
711 
						fofoOrder.getInvoiceNumber());
25092 amit.gupta 712 
			}
713 
		}
714 
		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
715 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
716 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
717 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
718 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
719 
	}
720 
 
23973 govind 721 
	@RequestMapping(value = "/credit-note/{creditNoteId}")
722 
	public ResponseEntity<?> downloadCreditNote(HttpServletRequest request, @PathVariable int creditNoteId)
723 
			throws ProfitMandiBusinessException {
23654 amit.gupta 724 
		CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);
725 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
726 
		PdfUtils.generateAndWriteCustomerCreditNotes(Arrays.asList(creditNotePdfModel), byteArrayOutputStream);
727 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
23973 govind 728 
		final HttpHeaders headers = new HttpHeaders();
729 
		headers.setContentType(MediaType.APPLICATION_PDF);
730 
		headers.set("Content-disposition",
731 
				"inline; filename=invoice-" + creditNotePdfModel.getCreditNoteNumber() + ".pdf");
732 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
733 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
734 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
735 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
23654 amit.gupta 736 
	}
23973 govind 737 
 
22291 ashik.ali 738 
	@RequestMapping(value = "/getPaginatedSaleHistory")
23973 govind 739 
	public String getSaleHistoryPaginated(HttpServletRequest request,
740 
			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
741 
			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
742 
			@RequestParam(required = false) LocalDateTime startTime,
743 
			@RequestParam(required = false) LocalDateTime endTime,
744 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
745 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
746 
			throws ProfitMandiBusinessException {
22927 ashik.ali 747 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23973 govind 748 
		Map<String, Object> map = orderService.getSaleHistoryPaginated(loginDetails.getFofoId(), searchType,
749 
				searchValue, startTime, endTime, offset, limit);
23203 ashik.ali 750 
		model.addAllAttributes(map);
22291 ashik.ali 751 
		return "sale-history-paginated";
752 
	}
753 
 
24105 govind 754 
	@PutMapping(value = "/updatePaymentTransaction")
755 
	public String updateTransactionDetails(HttpServletRequest request, @RequestParam String referenceType,
756 
			@RequestParam int fofoId, @RequestParam int referenceId,
27861 tejbeer 757 
			@RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,
28055 tejbeer 758 
			@RequestParam float totalAmount, Model model) throws Exception {
27861 tejbeer 759 
 
760 
		List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel
761 
				.getPaymentOptionTransactionModel();
24105 govind 762 
		LOGGER.info(paymentOptionTransactionModels);
27861 tejbeer 763 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, referenceId);
764 
		LOGGER.info("sdssd" + fofoOrder);
765 
		fofoOrder.setTotalAmount(totalAmount);
766 
		List<FofoItemIdAmountModel> fofoItemIdAmountModel = partnerOptionsAndItemAmountModel.getItemAmountModel();
767 
		for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {
768 
			LOGGER.info("fim" + fim.getFofoItemId());
28190 tejbeer 769 
 
28189 tejbeer 770 
			LOGGER.info("fimAmount" + fim.getAmount());
27861 tejbeer 771 
			Item item = itemRepository.selectById(fim.getItemId());
772 
			TagListing tagListing = tagListingRepository.selectByItemId(item.getId());
773 
			FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());
28188 tejbeer 774 
			LOGGER.info("category" + item.getCategoryId());
775 
			if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {
28190 tejbeer 776 
				if (fofoOrderItem.getMop() <= fim.getAmount()) {
27861 tejbeer 777 
 
28131 tejbeer 778 
					if (fim.getAmount() <= tagListing.getMrp()) {
27861 tejbeer 779 
						fofoOrderItem.setSellingPrice(fim.getAmount());
780 
					} else {
781 
						throw new ProfitMandiBusinessException("Amount", fim.getAmount(),
782 
								"Sum of amount is not less than  to MRP");
783 
					}
784 
 
785 
					LOGGER.info("fofoOrderItem2" + fofoOrderItem);
786 
 
28190 tejbeer 787 
				} else {
788 
					// TODO below mop condition need to added added
789 
					fofoOrderItem.setSellingPrice(fim.getAmount());
27861 tejbeer 790 
				}
791 
 
792 
			} else {
793 
				fofoOrderItem.setSellingPrice(fim.getAmount());
794 
				LOGGER.info("fofoOrderItem1" + fofoOrderItem);
795 
 
796 
			}
797 
			LOGGER.info("fofoOrderItem" + fofoOrderItem);
798 
 
24105 govind 799 
		}
800 
 
27861 tejbeer 801 
		/*
802 
		 * for (PaymentOptionTransactionModel paymentOptionTransactionModel :
803 
		 * paymentOptionTransactionModels) { amount = amount +
804 
		 * paymentOptionTransactionModel.getAmount(); } LOGGER.info("FofoOrder amount" +
805 
		 * fofoOrder.getTotalAmount() + "amount" + amount); if (amount ==
806 
		 * fofoOrder.getTotalAmount()) {
807 
		 */
808 
		if (paymentOptionTransactionModels.size() > 0) {
809 
			List<PaymentOptionTransaction> paymentOptionTransactions = fofoOrderPaymentOptionRepository
810 
					.selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);
811 
			Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
812 
					.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
813 
			LOGGER.info(
814 
					"paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
815 
			for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {
816 
				if (paymentOptionIdPaymentOptionTransactionMap
817 
						.containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {
24105 govind 818 
 
27861 tejbeer 819 
					PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap
820 
							.get(paymentOptionTransactionModel.getPaymentOptionId());
24105 govind 821 
 
27861 tejbeer 822 
					if (paymentOptionTransactionModel.getAmount() == 0) {
823 
						fofoOrderPaymentOptionRepository.delete(paymentOptionTransaction);
824 
						LOGGER.info("deleted successfully");
825 
					} else {
24105 govind 826 
 
27861 tejbeer 827 
						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());
828 
						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);
829 
						LOGGER.info("updated successfully");
830 
 
24105 govind 831 
					}
27861 tejbeer 832 
				} else {
833 
					if (paymentOptionTransactionModel.getAmount() > 0) {
834 
						PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();
835 
						paymentOptionTransaction.setReferenceId(referenceId);
836 
						paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);
837 
						paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());
838 
						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());
839 
						paymentOptionTransaction.setFofoId(fofoId);
840 
						paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());
841 
						fofoOrderPaymentOptionRepository.persist(paymentOptionTransaction);
842 
						LOGGER.info("inserted successfully");
843 
					}
24105 govind 844 
				}
845 
 
846 
			}
27861 tejbeer 847 
 
848 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
24105 govind 849 
		}
27861 tejbeer 850 
		/*
851 
		 * else
852 
		 *
853 
		 * { throw new ProfitMandiBusinessException("Amount", amount,
854 
		 * "Sum of amount is not equal to total amount"); }
855 
		 */
24105 govind 856 
 
857 
		return "response";
27861 tejbeer 858 
 
24105 govind 859 
	}
24440 amit.gupta 860 
 
25726 amit.gupta 861 
	private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice, int itemId)
862 
			throws ProfitMandiBusinessException {
863 
		try {
864 
			Map<String, List<MobileInsurancePlan>> productDurationPlans = insuranceService.getAllPlans(itemId,
865 
					sellingPrice);
866 
			return productDurationPlans;
867 
		} catch (Exception e) {
868 
			e.printStackTrace();
869 
			throw new ProfitMandiBusinessException("Fetch Insurance Plans", "Insurance",
26647 tejbeer 870 
					"Could not fetch insurance Plans");
25726 amit.gupta 871 
		}
872 
 
24440 amit.gupta 873 
	}
24880 govind 874 
 
875 
	@GetMapping("/insuranceDetails")
876 
	public String getInsuranceDetails(HttpServletRequest request,
877 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
878 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
879 
			throws ProfitMandiBusinessException {
880 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
881 
		long size = 0;
882 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),
883 
				offset, limit);
884 
		size = insurancePolicyRepository.selectCountByRetailerId(loginDetails.getFofoId());
885 
		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository
886 
				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))
887 
				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));
888 
		if (size < limit) {
889 
			model.addAttribute("end", offset + size);
890 
		} else {
891 
			model.addAttribute("end", offset + limit);
892 
		}
893 
		model.addAttribute("start", offset + 1);
894 
		model.addAttribute("size", size);
895 
		model.addAttribute("insurancePolicies", insurancePolicies);
896 
		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);
897 
		return "insurance-details";
898 
	}
25092 amit.gupta 899 
 
24880 govind 900 
	@GetMapping("/insuranceDetailsPaginated")
901 
	public String getInsuranceDetailsPaginated(HttpServletRequest request,
902 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
903 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
904 
			throws ProfitMandiBusinessException {
905 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
906 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerId(loginDetails.getFofoId(),
907 
				offset, limit);
908 
		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository
909 
				.selectByIds(insurancePolicies.stream().map(x -> x.getProviderId()).collect(Collectors.toSet()))
910 
				.stream().collect(Collectors.toMap(InsuranceProvider::getId, InsuranceProvider::getName));
911 
		model.addAttribute("insurancePolicies", insurancePolicies);
912 
		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);
913 
		return "insurance-details-paginated";
914 
	}
26647 tejbeer 915 
 
28420 tejbeer 916 
	@GetMapping("/getMouForm")
917 
	public String getMouForm(HttpServletRequest request, Model model) throws Exception {
918 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
919 
 
920 
		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
921 
		if (mou != null) {
28425 tejbeer 922 
			if (mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
923 
				model.addAttribute("response", mvcResponseSender.createResponseString(true));
924 
			} else {
925 
				model.addAttribute("response", mvcResponseSender.createResponseString(false));
926 
			}
927 
 
28420 tejbeer 928 
		} else {
929 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
930 
 
931 
		}
932 
		return "response";
933 
 
934 
	}
935 
 
26647 tejbeer 936 
	@GetMapping("/pendingOrders")
26663 tejbeer 937 
	public String getPendingOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
26647 tejbeer 938 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
939 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
28420 tejbeer 940 
		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());
941 
		if (mou == null) {
942 
			mou = new Mou();
943 
			mou.setFofoId(loginDetails.getFofoId());
944 
			mou.setCreateTimestamp(LocalDateTime.now());
28425 tejbeer 945 
			mou.setUpdateTimestamp(LocalDateTime.now());
28420 tejbeer 946 
			mouRepository.persist(mou);
28425 tejbeer 947 
		} else if (!mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {
948 
			mou.setUpdateTimestamp(LocalDateTime.now());
28420 tejbeer 949 
		}
26647 tejbeer 950 
 
28339 tejbeer 951 
		List<PendingOrderItem> pendingOrderItem = null;
952 
 
28420 tejbeer 953 
		pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.PROCESSING,
954 
				loginDetails.getFofoId());
28339 tejbeer 955 
 
28358 tejbeer 956 
		Map<String, Object> map = null;
27046 tejbeer 957 
 
28420 tejbeer 958 
		map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
959 
		model.addAttribute("inventoryMap", map.get("inventoryMap"));
27046 tejbeer 960 
 
28350 tejbeer 961 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
962 
 
28358 tejbeer 963 
		LOGGER.info("partnerInventoryMap" + map.get("partnerInventoryMap"));
28350 tejbeer 964 
		model.addAttribute("isAdmin", isAdmin);
28358 tejbeer 965 
		return "pending_fofo_order";
966 
 
28350 tejbeer 967 
	}
968 
 
28339 tejbeer 969 
	@GetMapping("/billedOrders")
970 
	public String getBilledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
971 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
972 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
973 
 
974 
		List<PendingOrderItem> pendingOrderItem = null;
975 
 
976 
		if (isAdmin) {
977 
 
978 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);
979 
 
980 
		} else {
981 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
982 
					loginDetails.getFofoId());
27046 tejbeer 983 
		}
984 
 
28339 tejbeer 985 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
986 
 
987 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
26817 amit.gupta 988 
		model.addAttribute("isAdmin", isAdmin);
28339 tejbeer 989 
		return "billed_order_item";
26647 tejbeer 990 
	}
991 
 
28339 tejbeer 992 
	@GetMapping("/settledOrders")
993 
	public String getSettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
994 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
995 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
996 
 
997 
		List<PendingOrderItem> pendingOrderItem = null;
998 
 
999 
		if (isAdmin) {
1000 
 
1001 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.SETTLED);
1002 
 
1003 
		} else {
1004 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.SETTLED,
1005 
					loginDetails.getFofoId());
1006 
		}
1007 
 
1008 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1009 
 
1010 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1011 
		model.addAttribute("isAdmin", isAdmin);
1012 
		return "settled_order_item";
1013 
	}
1014 
 
1015 
	@GetMapping("/unsettledOrders")
1016 
	public String getunsettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
1017 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1018 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1019 
 
1020 
		List<PendingOrderItem> pendingOrderItem = null;
1021 
 
1022 
		if (isAdmin) {
1023 
 
1024 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.UNSETTLED);
1025 
 
1026 
		} else {
1027 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.UNSETTLED,
1028 
					loginDetails.getFofoId());
1029 
		}
1030 
 
1031 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1032 
 
1033 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1034 
		model.addAttribute("isAdmin", isAdmin);
1035 
		return "unsettled_order_item";
1036 
	}
1037 
 
1038 
	@GetMapping("/claimedOrders")
1039 
	public String getclaimedOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
1040 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1041 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1042 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1043 
				.collect(Collectors.toList());
1044 
 
1045 
		List<PendingOrderItem> pendingOrderItem = null;
1046 
 
1047 
		if (isAdmin) {
1048 
 
1049 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.CLAIMED);
1050 
			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1051 
			model.addAttribute("customRetailersMap", customRetailersMap);
1052 
 
1053 
		} else {
1054 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.CLAIMED,
1055 
					loginDetails.getFofoId());
1056 
		}
1057 
 
1058 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
1059 
 
1060 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1061 
		model.addAttribute("isAdmin", isAdmin);
1062 
		return "claim_raised_order_item";
1063 
	}
1064 
 
26647 tejbeer 1065 
	@GetMapping("/getPendingOrderItem")
1066 
	public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)
1067 
			throws ProfitMandiBusinessException {
1068 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1069 
		Map<Integer, Item> itemMap = new HashMap<>();
1070 
		Map<Integer, CurrentInventorySnapshot> inventoryMap = new HashMap<>();
26817 amit.gupta 1071 
		PendingOrder pendingPO = pendingOrderRepository.selectById(orderId);
1072 
		Customer customer = customerRepository.selectById(pendingPO.getCustomerId());
26647 tejbeer 1073 
		List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);
1074 
		for (PendingOrderItem pendingOrderItem : pendingOrderItems) {
1075 
			Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1076 
			CurrentInventorySnapshot cis = currentInventorySnapshotRepository
28339 tejbeer 1077 
					.selectByItemAndFofoId(pendingOrderItem.getItemId(), pendingPO.getFofoId());
26647 tejbeer 1078 
			itemMap.put(pendingOrderItem.getItemId(), item);
1079 
			LOGGER.info("cis" + cis);
1080 
			inventoryMap.put(pendingOrderItem.getItemId(), cis);
1081 
		}
1082 
 
1083 
		LOGGER.info("inventoryMap" + inventoryMap);
1084 
		model.addAttribute("pendingOrderItems", pendingOrderItems);
1085 
		model.addAttribute("itemMap", itemMap);
1086 
		model.addAttribute("inventoryMap", inventoryMap);
26817 amit.gupta 1087 
		model.addAttribute("pendingPO", gson.toJson(pendingPO));
1088 
		model.addAttribute("pendingPOCustomer", gson.toJson(customer));
26721 tejbeer 1089 
		model.addAttribute("isAdmin", roleManager.isAdmin(loginDetails.getRoleIds()));
26647 tejbeer 1090 
		return "pending-order-item";
1091 
	}
26721 tejbeer 1092 
 
28352 tejbeer 1093 
	@RequestMapping(value = "/getPendingOrderItemById", method = RequestMethod.GET)
1094 
	public String getPendingOrderItemById(HttpServletRequest request, @RequestParam int id, Model model)
26721 tejbeer 1095 
			throws Exception {
27046 tejbeer 1096 
 
28352 tejbeer 1097 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1098 
		model.addAttribute("pendingOrderItem", pendingOrderItem);
1099 
		return "cancel-pending-order";
1100 
	}
1101 
 
28437 tejbeer 1102 
	@RequestMapping(value = "/getPendingOrderChangePartnerById", method = RequestMethod.GET)
1103 
	public String getPendingOrderChangePartnerById(HttpServletRequest request, @RequestParam int id, Model model)
1104 
			throws Exception {
1105 
 
1106 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
1107 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(true);
1108 
		model.addAttribute("customRetailersMap", customRetailersMap);
1109 
		model.addAttribute("pendingOrder", pendingOrder);
1110 
		return "change-partner-po";
1111 
	}
1112 
 
1113 
	@RequestMapping(value = "/changePendingOrderPartner", method = RequestMethod.POST)
1114 
	public String changePendingOrderPartner(HttpServletRequest request, @RequestParam int id, @RequestParam int fofoId,
1115 
			Model model) throws Exception {
1116 
 
1117 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(id);
1118 
		pendingOrder.setFofoId(fofoId);
1119 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1120 
 
1121 
		return "response";
1122 
	}
1123 
 
28352 tejbeer 1124 
	@RequestMapping(value = "/cancelPendingOrderItem", method = RequestMethod.POST)
1125 
	public String cancelPendingOrderItem(HttpServletRequest request, @RequestParam int id, @RequestParam String reason,
1126 
			Model model) throws Exception {
1127 
 
27046 tejbeer 1128 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
26721 tejbeer 1129 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1130 
 
27046 tejbeer 1131 
		pendingOrderItem.setStatus(OrderStatus.CANCELLED);
1132 
		pendingOrderItem.setStatusDescription(loginDetails.getEmailId());
28352 tejbeer 1133 
		pendingOrderItem.setRemark(reason);
1134 
		pendingOrderItem.setCancelledTimestamp(LocalDateTime.now());
27057 tejbeer 1135 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
26721 tejbeer 1136 
 
27046 tejbeer 1137 
		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
26721 tejbeer 1138 
				.map(x -> x.getStatus()).collect(Collectors.toList());
1139 
 
28352 tejbeer 1140 
		Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
1141 
 
1142 
		List<Integer> catalogIds = new ArrayList<>();
1143 
 
1144 
		Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1145 
		pendingOrderItem.setItemName(item.getItemDescription());
1146 
		catalogIds.add(item.getCatalogItemId());
1147 
 
1148 
		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
1149 
		JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
1150 
		pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
1151 
		pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
1152 
		CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());
1153 
 
1154 
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");
1155 
 
1156 
		Map<String, Object> emailModel = new HashMap<>();
1157 
		emailModel.put("customer", customerAddress);
1158 
		emailModel.put("pendingOrder", pendingOrder);
1159 
		emailModel.put("date", dateTimeFormatter);
28427 tejbeer 1160 
		LOGGER.info("emal" + customer.getEmailId());
28352 tejbeer 1161 
		String[] customerEmail = null;
28427 tejbeer 1162 
		if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
28356 tejbeer 1163 
			customerEmail = new String[] { customer.getEmailId() };
28352 tejbeer 1164 
 
28356 tejbeer 1165 
			List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
1166 
 
28377 tejbeer 1167 
			emailService.sendMailWithAttachments("Order Cancellation", "order-cancellation.vm", emailModel,
28356 tejbeer 1168 
					customerEmail, null, bccTo.toArray(new String[0]));
28352 tejbeer 1169 
 
1170 
		}
1171 
 
28345 tejbeer 1172 
		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
1173 
				&& !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
1174 
				&& !status.contains(OrderStatus.CLAIMED)) {
27046 tejbeer 1175 
			pendingOrder.setStatus(OrderStatus.CLOSED);
26721 tejbeer 1176 
		}
1177 
		pendingOrderItemRepository.persist(pendingOrderItem);
28352 tejbeer 1178 
 
26721 tejbeer 1179 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1180 
 
1181 
		return "response";
1182 
	}
27046 tejbeer 1183 
 
28339 tejbeer 1184 
	@RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
1185 
	public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)
1186 
			throws Exception {
1187 
 
1188 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1189 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1190 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
1191 
 
1192 
		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
1193 
			pendingOrderItem.setStatus(OrderStatus.UNSETTLED);
1194 
			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
1195 
 
1196 
		} else {
1197 
			pendingOrderItem.setStatus(OrderStatus.SETTLED);
1198 
			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
1199 
 
1200 
		}
1201 
 
1202 
		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
1203 
				.map(x -> x.getStatus()).collect(Collectors.toList());
1204 
 
1205 
		List<Integer> catalogIds = new ArrayList<>();
1206 
 
1207 
		Item item = itemRepository.selectById(pendingOrderItem.getItemId());
1208 
		pendingOrderItem.setItemName(item.getItemDescription());
1209 
		catalogIds.add(item.getCatalogItemId());
1210 
 
1211 
		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
1212 
		JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
1213 
		pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
1214 
		pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
1215 
		CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());
1216 
 
1217 
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");
1218 
 
1219 
		Map<String, Object> emailModel = new HashMap<>();
1220 
		emailModel.put("customer", customerAddress);
1221 
		emailModel.put("pendingOrder", pendingOrder);
1222 
		emailModel.put("date", dateTimeFormatter);
1223 
		Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
1224 
		String[] customerEmail = null;
28427 tejbeer 1225 
		if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
28356 tejbeer 1226 
			customerEmail = new String[] { customer.getEmailId() };
1227 
			List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
28339 tejbeer 1228 
 
1229 
			emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
28356 tejbeer 1230 
					customerEmail, null, bccTo.toArray(new String[0]));
28339 tejbeer 1231 
 
1232 
		}
28345 tejbeer 1233 
		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
1234 
				&& !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
1235 
				&& !status.contains(OrderStatus.CLAIMED))
28339 tejbeer 1236 
 
1237 
		{
1238 
			pendingOrder.setStatus(OrderStatus.CLOSED);
1239 
		}
1240 
		pendingOrderItemRepository.persist(pendingOrderItem);
1241 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1242 
 
1243 
		return "response";
1244 
	}
1245 
 
1246 
	@RequestMapping(value = "/raiseClaimOrderItem", method = RequestMethod.POST)
1247 
	public String raiseClaimOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
1248 
 
1249 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1250 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1251 
		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
1252 
 
1253 
		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
1254 
			pendingOrderItem.setStatus(OrderStatus.CLAIMED);
1255 
			pendingOrderItem.setClaimedTimestamp(LocalDateTime.now());
1256 
 
1257 
		}
1258 
		pendingOrderItemRepository.persist(pendingOrderItem);
1259 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1260 
 
1261 
		return "response";
1262 
	}
1263 
 
28344 tejbeer 1264 
	@RequestMapping(value = "/verifyOrderItem", method = RequestMethod.POST)
1265 
	public String verifyOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
1266 
 
1267 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1268 
		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
1269 
		pendingOrderItem.setVerifiedTimestamp(LocalDateTime.now());
28350 tejbeer 1270 
 
1271 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1272 
 
28344 tejbeer 1273 
		return "response";
1274 
	}
1275 
 
27819 tejbeer 1276 
	@RequestMapping(value = "/cancelOrderByInvoice", method = RequestMethod.POST)
1277 
	public String cancelOrder(HttpServletRequest request, @RequestParam List<String> invoiceNumbers, Model model)
1278 
			throws Exception {
1279 
		orderService.cancelOrder(invoiceNumbers);
1280 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1281 
 
1282 
		return "response";
1283 
	}
1284 
 
28358 tejbeer 1285 
	@RequestMapping(value = "/getOnlineOrder", method = RequestMethod.GET)
1286 
	public String cancelOrder(HttpServletRequest request, Model model) throws Exception {
1287 
		return "online-order";
1288 
	}
1289 
 
1290 
	@GetMapping("/getAllOrdersByStatus")
1291 
	public String getAllOrdersByStatus(HttpServletRequest request, @RequestParam OrderStatus status,
28420 tejbeer 1292 
			@RequestParam(required = false) LocalDateTime startTime,
1293 
			@RequestParam(required = false) LocalDateTime endTime, Model model) throws ProfitMandiBusinessException {
28358 tejbeer 1294 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1295 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1296 
 
28420 tejbeer 1297 
		LOGGER.info("startTime" + startTime);
1298 
 
1299 
		LOGGER.info("endTime" + endTime);
1300 
 
28358 tejbeer 1301 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1302 
				.collect(Collectors.toList());
1303 
 
1304 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1305 
		model.addAttribute("customRetailersMap", customRetailersMap);
1306 
 
1307 
		List<PendingOrderItem> pendingOrderItem = null;
28420 tejbeer 1308 
		if (startTime == null) {
1309 
			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(status);
1310 
		} else {
1311 
			List<OrderStatus> statusList = new ArrayList<>();
1312 
			if (status.equals(OrderStatus.DELIVERED)) {
1313 
				statusList.add(OrderStatus.SETTLED);
1314 
				statusList.add(OrderStatus.UNSETTLED);
1315 
			} else {
1316 
				statusList.add(status);
1317 
			}
28429 tejbeer 1318 
			pendingOrderItem = pendingOrderItemRepository.selectByStatusAndCreateTimestamp(statusList,
1319 
					startTime.toLocalDate().atStartOfDay(), endTime);
28420 tejbeer 1320 
		}
28361 tejbeer 1321 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, 0);
28358 tejbeer 1322 
 
1323 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
28361 tejbeer 1324 
		model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
28358 tejbeer 1325 
 
1326 
		model.addAttribute("isAdmin", isAdmin);
1327 
		return "online-order-item";
1328 
	}
28377 tejbeer 1329 
 
1330 
	@GetMapping("/getAllOnlineOrder")
1331 
	public String getAllOrders(HttpServletRequest request, @RequestParam(required = false) LocalDate date, Model model)
1332 
			throws ProfitMandiBusinessException {
1333 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1334 
		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
1335 
		if (date == null) {
1336 
			date = LocalDate.now().minusDays(3);
1337 
		}
1338 
 
1339 
		LOGGER.info("date" + date);
1340 
		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
1341 
				.collect(Collectors.toList());
1342 
 
1343 
		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
1344 
		model.addAttribute("customRetailersMap", customRetailersMap);
1345 
 
1346 
		List<PendingOrderItem> pendingOrderItem = null;
1347 
 
1348 
		pendingOrderItem = pendingOrderItemRepository.selectAll(date.atStartOfDay(), LocalDateTime.now());
1349 
 
1350 
		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, 0);
1351 
 
1352 
		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
1353 
		model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
1354 
		model.addAttribute("date", date);
1355 
		model.addAttribute("isAdmin", isAdmin);
1356 
		return "online-all-order-item";
1357 
	}
21612 ashik.ali 1358 
}