Subversion Repositories SmartDukaan

Rev

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