Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
21577 ashik.ali 1 
package com.spice.profitmandi.web.controller;
2 
 
30039 tejbeer 3 
import com.fasterxml.jackson.databind.ObjectMapper;
21987 kshitij.so 4 
import com.google.gson.Gson;
25698 tejbeer 5 
import com.spice.profitmandi.common.enumuration.MessageType;
21577 ashik.ali 6 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
30323 amit.gupta 7 
import com.spice.profitmandi.common.model.*;
22472 ashik.ali 8 
import com.spice.profitmandi.common.util.ExcelUtils;
25140 amit.gupta 9 
import com.spice.profitmandi.common.util.PdfUtils;
28084 amit.gupta 10 
import com.spice.profitmandi.common.util.Utils;
11 
import com.spice.profitmandi.common.util.Utils.Attachment;
28701 tejbeer 12 
import com.spice.profitmandi.dao.entity.auth.AuthUser;
30323 amit.gupta 13 
import com.spice.profitmandi.dao.entity.catalog.*;
28701 tejbeer 14 
import com.spice.profitmandi.dao.entity.cs.Position;
25140 amit.gupta 15 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
24917 tejbeer 16 
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
24465 tejbeer 17 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
18 
import com.spice.profitmandi.dao.entity.fofo.LiveDemoSerialNumber;
30323 amit.gupta 19 
import com.spice.profitmandi.dao.entity.transaction.*;
28701 tejbeer 20 
import com.spice.profitmandi.dao.enumuration.catalog.ByPassRequestStatus;
21 
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
30323 amit.gupta 22 
import com.spice.profitmandi.dao.model.*;
28701 tejbeer 23 
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
30323 amit.gupta 24 
import com.spice.profitmandi.dao.repository.catalog.*;
28701 tejbeer 25 
import com.spice.profitmandi.dao.repository.cs.CsService;
26 
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
24465 tejbeer 27 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
26482 tejbeer 28 
import com.spice.profitmandi.dao.repository.dtr.Mongo;
24917 tejbeer 29 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
30456 amit.gupta 30 
import com.spice.profitmandi.dao.repository.fofo.*;
24917 tejbeer 31 
import com.spice.profitmandi.dao.repository.inventory.NotifyStatus;
30323 amit.gupta 32 
import com.spice.profitmandi.dao.repository.transaction.*;
27723 tejbeer 33 
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;
34 
import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;
25851 amit.gupta 35 
import com.spice.profitmandi.service.NotificationService;
22927 ashik.ali 36 
import com.spice.profitmandi.service.inventory.InventoryService;
27516 amit.gupta 37 
import com.spice.profitmandi.service.order.OrderService;
24465 tejbeer 38 
import com.spice.profitmandi.service.user.RetailerService;
22139 amit.gupta 39 
import com.spice.profitmandi.web.model.LoginDetails;
22069 ashik.ali 40 
import com.spice.profitmandi.web.util.CookiesProcessor;
24106 tejbeer 41 
import com.spice.profitmandi.web.util.MVCResponseSender;
24658 tejbeer 42 
import in.shop2020.model.v1.order.OrderStatus;
24739 tejbeer 43 
import in.shop2020.model.v1.order.TransactionServiceException;
30323 amit.gupta 44 
import org.apache.commons.csv.CSVFormat;
45 
import org.apache.commons.csv.CSVParser;
46 
import org.apache.commons.csv.CSVRecord;
47 
import org.apache.commons.io.FileUtils;
48 
import org.apache.commons.lang3.StringUtils;
49 
import org.apache.logging.log4j.LogManager;
50 
import org.apache.logging.log4j.Logger;
51 
import org.apache.thrift.TException;
52 
import org.json.JSONObject;
53 
import org.springframework.beans.factory.annotation.Autowired;
54 
import org.springframework.beans.factory.annotation.Qualifier;
55 
import org.springframework.beans.factory.annotation.Value;
56 
import org.springframework.core.io.ByteArrayResource;
57 
import org.springframework.core.io.ClassPathResource;
58 
import org.springframework.core.io.InputStreamResource;
59 
import org.springframework.http.HttpHeaders;
60 
import org.springframework.http.HttpStatus;
61 
import org.springframework.http.MediaType;
62 
import org.springframework.http.ResponseEntity;
63 
import org.springframework.mail.javamail.JavaMailSender;
64 
import org.springframework.stereotype.Controller;
65 
import org.springframework.transaction.annotation.Transactional;
66 
import org.springframework.ui.Model;
67 
import org.springframework.web.bind.annotation.*;
68 
import org.springframework.web.multipart.MultipartFile;
24658 tejbeer 69 
 
30323 amit.gupta 70 
import javax.servlet.http.HttpServletRequest;
71 
import javax.servlet.http.HttpServletResponse;
72 
import java.io.*;
73 
import java.net.URISyntaxException;
74 
import java.time.LocalDate;
75 
import java.time.LocalDateTime;
76 
import java.time.YearMonth;
77 
import java.time.format.DateTimeFormatter;
78 
import java.time.temporal.ChronoUnit;
79 
import java.util.*;
80 
import java.util.stream.Collectors;
81 
import java.util.stream.Stream;
82 
 
21577 ashik.ali 83 
@Controller
24123 tejbeer 84 
@Transactional(rollbackFor = Throwable.class)
21577 ashik.ali 85 
public class InventoryController {
21987 kshitij.so 86 
 
23568 govind 87 
	private static final Logger LOGGER = LogManager.getLogger(InventoryController.class);
26482 tejbeer 88 
 
26292 amit.gupta 89 
	private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("M/d/yyyy H:m:s");
21987 kshitij.so 90 
 
27583 tejbeer 91 
	private static final List<String> imeis = Arrays.asList("351030944216680", "351030944217183", "351030944217886",
92 
			"351030944507286", "351081710231270", "351081710238713", "351081710238796", "351081710241279",
93 
			"351081710244737", "355777112655976");
94 
 
28701 tejbeer 95 
	List<EscalationType> esclationType = Arrays.asList(EscalationType.L3, EscalationType.L4);
96 
 
97 
	List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com");
98 
 
21577 ashik.ali 99 
	@Autowired
22927 ashik.ali 100 
	private CookiesProcessor cookiesProcessor;
24123 tejbeer 101 
 
22354 ashik.ali 102 
	@Autowired
23784 ashik.ali 103 
	@Qualifier("fofoInventoryService")
22927 ashik.ali 104 
	private InventoryService inventoryService;
24465 tejbeer 105 
 
24203 amit.gupta 106 
	@Autowired
24950 tejbeer 107 
	TagListingRepository tagListingRepository;
108 
 
109 
	@Autowired
24203 amit.gupta 110 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
24123 tejbeer 111 
 
24106 tejbeer 112 
	@Autowired
113 
	private TagRankingRepository tagRankingRepository;
24123 tejbeer 114 
 
24106 tejbeer 115 
	@Autowired
24465 tejbeer 116 
	private InventoryItemRepository inventoryItemRepository;
117 
 
118 
	@Autowired
119 
	private LiveDemoBillingRespository liveDemoBillingRespository;
120 
 
121 
	@Autowired
24123 tejbeer 122 
	private ItemRepository itemRepository;
123 
 
124 
	@Autowired
26512 amit.gupta 125 
	private Gson gson;
126 
 
127 
	@Autowired
24465 tejbeer 128 
	private RetailerService retailerService;
129 
 
130 
	@Autowired
24106 tejbeer 131 
	private MVCResponseSender mvcResponseSender;
24123 tejbeer 132 
 
24465 tejbeer 133 
	@Autowired
134 
	FofoStoreRepository fofoStoreRepository;
135 
 
24658 tejbeer 136 
	@Autowired
137 
	private OrderRepository orderRepository;
138 
 
24739 tejbeer 139 
	@Autowired
24917 tejbeer 140 
	private NotifyItemRepository notifyItemRepository;
24739 tejbeer 141 
 
24917 tejbeer 142 
	@Autowired
143 
	private NotifyColorChangeRepository notifyColorChangeRepository;
144 
 
145 
	@Autowired
146 
	private NotifyOrderRespository notifyOrderRespository;
147 
 
148 
	@Autowired
25851 amit.gupta 149 
	private NotificationService notificationService;
150 
 
151 
	@Autowired
25066 tejbeer 152 
	private NotifyMessageRepository notifyMessageRepository;
153 
 
154 
	@Autowired
24917 tejbeer 155 
	private UserAccountRepository userAccountRepository;
156 
 
27516 amit.gupta 157 
	@Autowired
158 
	private OrderService orderService;
27583 tejbeer 159 
 
21987 kshitij.so 160 
	@Value("${saholic.api.host}")
161 
	private String host;
23786 amit.gupta 162 
 
21987 kshitij.so 163 
	@Value("${saholic.api.port}")
164 
	private int port;
23786 amit.gupta 165 
 
21987 kshitij.so 166 
	@Value("${saholic.api.webapp}")
167 
	private String webapp;
168 
 
24917 tejbeer 169 
	@Autowired
170 
	JavaMailSender mailSender;
171 
 
26031 tejbeer 172 
	@Autowired
173 
	private NotifyCancelOrderRepository notifyCancelOrderRepository;
174 
 
26482 tejbeer 175 
	@Autowired
27723 tejbeer 176 
	private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;
177 
 
178 
	@Autowired
179 
	private WarehouseScanRepository warehouseScanRepository;
180 
 
181 
	@Autowired
182 
	private FofoOrderRepository fofoOrderRepository;
183 
	@Autowired
26482 tejbeer 184 
	private Mongo mongoClient;
185 
 
28701 tejbeer 186 
	@Autowired
187 
	private FocusedModelByPassRepository focusedModelByPassRepository;
188 
 
189 
	@Autowired
190 
	private CsService csService;
191 
 
192 
	@Autowired
193 
	AuthRepository authRepository;
194 
 
195 
	@Autowired
196 
	PositionRepository positionRepository;
197 
 
28754 tejbeer 198 
	@Autowired
30456 amit.gupta 199 
	ActivatedImeiRepository activatedImeiRepository;
200 
 
201 
	@Autowired
28754 tejbeer 202 
	HighDemandItemsRepository highDemandItemsRepository;
203 
 
23786 amit.gupta 204 
	@RequestMapping(value = "/getCurrentInventorySnapshot")
205 
	public String getCurrentAvailability(HttpServletRequest request,
30565 tejbeer 206 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
207 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
208 
			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)
23786 amit.gupta 209 
			throws ProfitMandiBusinessException {
22927 ashik.ali 210 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 211 
		Map<String, Object> map = inventoryService.getCurrentInventorySnapshot(loginDetails.getFofoId(), offset, limit,
212 
				searchTerm);
22927 ashik.ali 213 
		model.addAllAttributes(map);
21987 kshitij.so 214 
		return "inventory-snapshot";
21612 ashik.ali 215 
	}
21987 kshitij.so 216 
 
23786 amit.gupta 217 
	@RequestMapping(value = "/getBadInventorySnapshot")
218 
	public String getBadAvailability(HttpServletRequest request,
219 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
220 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
221 
			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)
222 
			throws ProfitMandiBusinessException {
24123 tejbeer 223 
		if (searchTerm == null) {
224 
			searchTerm = "";
24052 amit.gupta 225 
		}
22927 ashik.ali 226 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 227 
		Map<String, Object> map = inventoryService.getBadInventorySnapshot(loginDetails.getFofoId(), offset, limit,
228 
				searchTerm);
22927 ashik.ali 229 
		model.addAllAttributes(map);
21987 kshitij.so 230 
		return "bad-inventory-snapshot";
231 
	}
232 
 
23786 amit.gupta 233 
	@RequestMapping(value = "/getPaginatedCurrentInventorySnapshot")
234 
	public String getPaginatedCurrentInventorySnapshot(HttpServletRequest request,
235 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
236 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
237 
			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)
238 
			throws ProfitMandiBusinessException {
24123 tejbeer 239 
		if (searchTerm == null) {
240 
			searchTerm = "";
24052 amit.gupta 241 
		}
22927 ashik.ali 242 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 243 
		Map<String, Object> map = inventoryService.getPaginatedCurrentInventorySnapshot(loginDetails.getFofoId(),
244 
				offset, limit, searchTerm);
22927 ashik.ali 245 
		model.addAllAttributes(map);
21987 kshitij.so 246 
		return "inventory-snapshot-paginated";
247 
	}
23786 amit.gupta 248 
 
249 
	@RequestMapping(value = "/getCatalog")
250 
	public String getCatalog(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,
27583 tejbeer 251 
			@RequestParam(name = "limit", defaultValue = "20") int limit,
252 
			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm,
27618 tejbeer 253 
			@RequestParam(name = "itemId", required = false, defaultValue = "0") int itemId,
254 
			@RequestParam(name = "accesories", required = false, defaultValue = "0") boolean accesories,
27596 tejbeer 255 
 
27618 tejbeer 256 
			@RequestParam(name = "brand", required = false, defaultValue = "") String brand, Model model)
257 
 
23786 amit.gupta 258 
			throws ProfitMandiBusinessException {
22927 ashik.ali 259 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24123 tejbeer 260 
		if (searchTerm == null) {
261 
			searchTerm = "";
24052 amit.gupta 262 
		}
24739 tejbeer 263 
 
27583 tejbeer 264 
		Map<String, Object> map = inventoryService.getCatalog(loginDetails.getFofoId(), offset, limit, searchTerm,
27618 tejbeer 265 
				itemId, brand, accesories);
22927 ashik.ali 266 
		model.addAllAttributes(map);
24203 amit.gupta 267 
		model.addAttribute("hasGift", hasGift(loginDetails.getFofoId()));
24658 tejbeer 268 
 
21987 kshitij.so 269 
		return "catalog";
270 
	}
23786 amit.gupta 271 
 
24465 tejbeer 272 
	// This method is currently hardcoded to faciliate watches sold as gift.
24203 amit.gupta 273 
	private boolean hasGift(int fofoId) {
274 
		try {
24465 tejbeer 275 
			return currentInventorySnapshotRepository.selectByItemIdAndFofoId(ProfitMandiConstants.GIFT_ID, fofoId)
276 
					.getAvailability() > 0;
24203 amit.gupta 277 
		} catch (ProfitMandiBusinessException e) {
278 
			return false;
279 
		}
280 
	}
281 
 
23786 amit.gupta 282 
	@RequestMapping(value = "/getPaginatedCatalog")
283 
	public String getCatalogPaginated(HttpServletRequest request,
284 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
27583 tejbeer 285 
			@RequestParam(name = "limit", defaultValue = "20") int limit,
286 
			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm,
27596 tejbeer 287 
			@RequestParam(name = "itemId", required = false, defaultValue = "0") int itemId,
27618 tejbeer 288 
			@RequestParam(name = "accesories", required = false, defaultValue = "0") boolean accesories,
289 
			@RequestParam(name = "brand", required = false, defaultValue = "") String brand, Model model)
23786 amit.gupta 290 
			throws ProfitMandiBusinessException {
22927 ashik.ali 291 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24123 tejbeer 292 
		if (searchTerm == null) {
293 
			searchTerm = "";
24052 amit.gupta 294 
		}
23786 amit.gupta 295 
		Map<String, Object> map = inventoryService.getPaginatedCatalog(loginDetails.getFofoId(), offset, limit,
27618 tejbeer 296 
				searchTerm, itemId, brand, accesories);
22927 ashik.ali 297 
		model.addAllAttributes(map);
21987 kshitij.so 298 
		return "catalog-paginated";
299 
	}
300 
 
23786 amit.gupta 301 
	@RequestMapping(value = "/checkItemAvailability")
302 
	public String getItemAvailability(HttpServletRequest request,
303 
			@RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, Model model)
304 
			throws ProfitMandiBusinessException {
22927 ashik.ali 305 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 306 
		CustomCurrentInventorySnapshot customCurrentInventorySnapshot = inventoryService.checkItemAvailability(itemId,
307 
				loginDetails.getFofoId());
25812 amit.gupta 308 
		/*
309 
		 * customCurrentInventorySnapshot
310 
		 * .setIconUrl(Utils.getIconUrl(customCurrentInventorySnapshot.getCatalogItemId(
311 
		 * ), host, port, webapp));
312 
		 */
22927 ashik.ali 313 
		model.addAttribute("currentInventorySnapshot", new Gson().toJson(customCurrentInventorySnapshot));
314 
		return "current-item-availability";
23786 amit.gupta 315 
 
21577 ashik.ali 316 
	}
23786 amit.gupta 317 
 
23192 ashik.ali 318 
	@RequestMapping(value = "/cart", method = RequestMethod.POST)
23786 amit.gupta 319 
	public String addToCart(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)
320 
			throws ProfitMandiBusinessException {
22927 ashik.ali 321 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 322 
 
22927 ashik.ali 323 
		Map<String, Object> map = inventoryService.addToCart(cartData, loginDetails.getFofoId());
324 
		model.addAllAttributes(map);
21987 kshitij.so 325 
		return "cart";
326 
	}
23786 amit.gupta 327 
 
23192 ashik.ali 328 
	@RequestMapping(value = "/validate-cart", method = RequestMethod.POST)
23786 amit.gupta 329 
	public String validateCart(HttpServletRequest request, HttpServletResponse response,
330 
			@RequestParam(name = "cartData") String cartData, Model model) throws ProfitMandiBusinessException {
22927 ashik.ali 331 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 332 
 
22927 ashik.ali 333 
		Map<String, Object> map = inventoryService.validateCart(cartData, loginDetails.getFofoId());
334 
		model.addAllAttributes(map);
21987 kshitij.so 335 
		return "validate-cart";
336 
	}
337 
 
23786 amit.gupta 338 
	@RequestMapping(value = "/grnHistory")
24123 tejbeer 339 
	public String getGrnHistory(HttpServletRequest request, @RequestParam(required = false) LocalDateTime startTime,
23886 amit.gupta 340 
			@RequestParam(required = false) LocalDateTime endTime,
23786 amit.gupta 341 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
342 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
343 
			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,
344 
			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)
345 
			throws ProfitMandiBusinessException {
22927 ashik.ali 346 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24123 tejbeer 347 
		Map<String, Object> map = inventoryService.getGrnHistory(loginDetails.getFofoId(), startTime, endTime, offset,
348 
				limit, purchaseReference, searchType);
22927 ashik.ali 349 
		model.addAllAttributes(map);
21987 kshitij.so 350 
		return "grn-history";
21636 ashik.ali 351 
	}
21987 kshitij.so 352 
 
25140 amit.gupta 353 
	@RequestMapping(value = "/downloadPurchaseInvoices")
354 
	public ResponseEntity<?> downloadPurchaseInvoices(HttpServletRequest request,
355 
			@RequestParam(required = false) LocalDateTime startTime,
356 
			@RequestParam(required = false) LocalDateTime endTime,
357 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
358 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
359 
			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,
360 
			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)
361 
			throws ProfitMandiBusinessException {
362 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
363 
		Map<String, Object> map = inventoryService.getGrnHistory(loginDetails.getFofoId(), startTime, endTime, offset,
364 
				limit, purchaseReference, searchType);
365 
 
366 
		List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");
367 
 
368 
		if (fofoOrders.size() == 0) {
369 
			throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");
370 
		}
371 
 
372 
		final HttpHeaders headers = new HttpHeaders();
373 
		headers.setContentType(MediaType.APPLICATION_PDF);
374 
		headers.set("Content-disposition", "inline; filename=invoices.pdf");
375 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
30323 amit.gupta 376 
		List<InvoicePdfModel> pdfModels = new ArrayList<>();
25140 amit.gupta 377 
		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
378 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
379 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
380 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
381 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
382 
	}
383 
 
23786 amit.gupta 384 
	@RequestMapping(value = "/getPaginatedGrnHistory")
385 
	public String getPaginatedGrnHistory(HttpServletRequest request,
23886 amit.gupta 386 
			@RequestParam(required = false) LocalDateTime startTime,
387 
			@RequestParam(required = false) LocalDateTime endTime,
23786 amit.gupta 388 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
389 
			@RequestParam(name = "limit", defaultValue = "10") int limit,
390 
			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,
391 
			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)
392 
			throws ProfitMandiBusinessException {
22927 ashik.ali 393 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
24123 tejbeer 394 
		Map<String, Object> map = inventoryService.getPaginatedGrnHistory(loginDetails.getFofoId(), startTime, endTime,
395 
				offset, limit);
22927 ashik.ali 396 
		model.addAllAttributes(map);
21987 kshitij.so 397 
		return "grn-history-paginated";
398 
	}
399 
 
23786 amit.gupta 400 
	@RequestMapping(value = "/grnHistoryDetailByPurchaseId")
401 
	public String grnHistoryByPurchaseId(HttpServletRequest request,
402 
			@RequestParam(name = ProfitMandiConstants.PURCHASE_ID) int purchaseId, Model model)
403 
			throws ProfitMandiBusinessException {
22927 ashik.ali 404 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 405 
		Map<String, Object> map = inventoryService.getGrnHistoryDetail(loginDetails.getFofoId(), purchaseId, host, port,
406 
				webapp);
22927 ashik.ali 407 
		model.addAllAttributes(map);
21987 kshitij.so 408 
		return "grn-details";
21636 ashik.ali 409 
	}
21987 kshitij.so 410 
 
23786 amit.gupta 411 
	@RequestMapping(value = "/grnHistoryDetailByPurchaseReference")
412 
	public String grnHistoryByPurchaseReference(HttpServletRequest request,
413 
			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE) String purchaseReference, Model model)
414 
			throws ProfitMandiBusinessException {
22927 ashik.ali 415 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 416 
		Map<String, Object> map = inventoryService.getGrnHistoryDetail(loginDetails.getFofoId(), purchaseReference,
417 
				host, port, webapp);
22927 ashik.ali 418 
		model.addAllAttributes(map);
21987 kshitij.so 419 
		return "grn-details";
21654 ashik.ali 420 
	}
23786 amit.gupta 421 
 
26248 amit.gupta 422 
	@RequestMapping(value = "/activatedImeis")
423 
	public String activatedImeis(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
424 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
425 
 
426 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByActivatedNotSold(loginDetails.getFofoId());
427 
		inventoryItems.stream().forEach(x -> {
428 
			try {
429 
				x.setItem(itemRepository.selectById(x.getItemId()));
430 
			} catch (Exception e) {
431 
				e.printStackTrace();
432 
			}
433 
		});
434 
		model.addAttribute("inventoryItems", inventoryItems);
435 
		return "activated-imeis";
436 
	}
27583 tejbeer 437 
 
30456 amit.gupta 438 
	@RequestMapping(value = "/activated-imeis-grn-pending")
30565 tejbeer 439 
	public String activatedImeisGrnPending(HttpServletRequest request, Model model)
440 
			throws ProfitMandiBusinessException {
30456 amit.gupta 441 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
442 
 
30565 tejbeer 443 
		List<Order> openOrders = orderRepository.selectGrnTimestampNull(loginDetails.getFofoId(),
444 
				Arrays.asList(OrderStatus.SHIPPED_FROM_WH, OrderStatus.DELIVERY_SUCCESS));
445 
		List<ImeiActivationTimestampModel> imeiActivationTimestampModels = activatedImeiRepository
446 
				.selectActivatedImeisByOrders(openOrders.stream().map(x -> x.getId()).collect(Collectors.toList()));
30456 amit.gupta 447 
		Map<Integer, Order> ordersMap = openOrders.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
448 
		model.addAttribute("ordersMap", ordersMap);
449 
		model.addAttribute("imeiActivationTimestampModels", imeiActivationTimestampModels);
450 
		return "activated-imeis-grn-pending";
451 
	}
452 
 
27516 amit.gupta 453 
	@RequestMapping(value = "/view-invoices")
454 
	public String viewInvoices(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
455 
		return "view-dummy-invoices";
456 
	}
27583 tejbeer 457 
 
27516 amit.gupta 458 
	@RequestMapping(value = "/dummy-invoices")
27583 tejbeer 459 
	public ResponseEntity<?> downloadInvoices(HttpServletRequest request, @RequestParam String serialNumber,
30565 tejbeer 460 
			Model model) throws ProfitMandiBusinessException {
27544 amit.gupta 461 
		byte[] bytes = null;
27583 tejbeer 462 
		if (!imeis.contains(serialNumber)) {
463 
 
30323 amit.gupta 464 
			InvoicePdfModel pdfModel = orderService.getDummyPdfModel(serialNumber);
27544 amit.gupta 465 
			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
466 
			PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
467 
			bytes = byteArrayOutputStream.toByteArray();
468 
		} else {
469 
			ClassPathResource resource = new ClassPathResource("/META-INF/" + serialNumber + ".pdf");
470 
			try {
471 
				bytes = FileUtils.readFileToByteArray(resource.getFile());
27583 tejbeer 472 
			} catch (Exception e) {
473 
 
27544 amit.gupta 474 
			}
475 
		}
27516 amit.gupta 476 
		final HttpHeaders headers = new HttpHeaders();
477 
		headers.setContentType(MediaType.APPLICATION_PDF);
27544 amit.gupta 478 
		headers.set("Content-disposition", "inline; filename=invoice-" + serialNumber + ".pdf");
479 
		headers.setContentLength(bytes.length);
480 
		final InputStream inputStream = new ByteArrayInputStream(bytes);
27516 amit.gupta 481 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
482 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
483 
	}
28714 tejbeer 484 
 
28084 amit.gupta 485 
	@RequestMapping(value = "/dummy-invoices-bulk")
486 
	public ResponseEntity<?> downloadInvoicesBulk(HttpServletRequest request, @RequestParam List<String> serialNumbers,
487 
			Model model) throws Exception {
488 
		byte[] bytes = null;
28701 tejbeer 489 
		List<Attachment> attachments = new ArrayList<>();
490 
		for (String serialNumber : serialNumbers) {
28084 amit.gupta 491 
			if (!imeis.contains(serialNumber)) {
30323 amit.gupta 492 
				InvoicePdfModel pdfModel = null;
28088 amit.gupta 493 
				try {
494 
					pdfModel = orderService.getDummyPdfModel(serialNumber);
28701 tejbeer 495 
				} catch (Exception e) {
28088 amit.gupta 496 
					continue;
497 
				}
28084 amit.gupta 498 
				ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
499 
				PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
500 
				bytes = byteArrayOutputStream.toByteArray();
501 
			} else {
502 
				ClassPathResource resource = new ClassPathResource("/META-INF/" + serialNumber + ".pdf");
503 
				try {
504 
					bytes = FileUtils.readFileToByteArray(resource.getFile());
505 
				} catch (Exception e) {
28088 amit.gupta 506 
					continue;
28084 amit.gupta 507 
				}
508 
			}
509 
			attachments.add(new Attachment("invoice-" + serialNumber + ".pdf", new ByteArrayResource(bytes)));
510 
		}
28109 tejbeer 511 
 
512 
		Utils.sendMailWithAttachments(mailSender, new String[] { "kuldeep.kumar@smartdukaan.com" }, null,
513 
				"Invoices List", "PFA", attachments.toArray(new Attachment[attachments.size()]));
28084 amit.gupta 514 
		return new ResponseEntity<Boolean>(true, HttpStatus.OK);
515 
	}
26248 amit.gupta 516 
 
22472 ashik.ali 517 
	@RequestMapping(value = "/getInventoryItemAgingByInterval", method = RequestMethod.POST)
23786 amit.gupta 518 
	public String getInventoryItemAgingByInterval(HttpServletRequest request, @RequestBody List<Integer> intervals,
519 
			Model model, @RequestParam(name = "searchContent", defaultValue = "") String searchContent,
520 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
521 
			@RequestParam(name = "limit", defaultValue = "10") int limit) throws ProfitMandiBusinessException {
22927 ashik.ali 522 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 523 
		Map<String, Object> map = inventoryService.getPaginatedItemAgingByInterval(loginDetails.getFofoId(), intervals,
524 
				searchContent, offset, limit);
22927 ashik.ali 525 
		model.addAllAttributes(map);
22523 ashik.ali 526 
		return "item-aging";
527 
	}
23786 amit.gupta 528 
 
22523 ashik.ali 529 
	@RequestMapping(value = "/downloadInventoryItemAgingByInterval", method = RequestMethod.POST)
23786 amit.gupta 530 
	public ResponseEntity<?> downloadInventoryItemAgingByInterval(HttpServletRequest request,
531 
			@RequestBody List<Integer> intervals, Model model) throws ProfitMandiBusinessException {
22927 ashik.ali 532 
		LOGGER.info("Request received at url{} with body {}", request.getRequestURI(), intervals);
533 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
23786 amit.gupta 534 
 
535 
		List<InventoryItemAgingModel> inventoryItemAgingModels = inventoryService
536 
				.getItemAgingByInterval(fofoDetails.getFofoId(), intervals);
537 
 
22486 ashik.ali 538 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
539 
		ExcelUtils.writeInventoryItemAgingModels(inventoryItemAgingModels, intervals, byteArrayOutputStream);
23786 amit.gupta 540 
 
541 
		final HttpHeaders headers = new HttpHeaders();
542 
		// private static final String CONTENT_TYPE_XLSX =
543 
		// "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
544 
		headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
545 
		// headers.set("Content-Type", "application/vnd.ms-excel");
22486 ashik.ali 546 
		headers.set("Content-disposition", "inline; filename=InventoryItemAging.xlsx");
23786 amit.gupta 547 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
548 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
549 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
550 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
22472 ashik.ali 551 
	}
27583 tejbeer 552 
 
26968 amit.gupta 553 
	@RequestMapping(value = "/aging-report", method = RequestMethod.GET)
27583 tejbeer 554 
	public ResponseEntity<?> downloadInventoryItemAgingByInterval(HttpServletRequest request)
555 
			throws ProfitMandiBusinessException {
556 
 
557 
		List<Integer> intervals = Arrays.asList(5, 15, 30, 45);
26961 amit.gupta 558 
		List<InventoryItemAgingModel> inventoryItemAgingModels = inventoryService.getItemAgingByInterval(intervals)
26979 amit.gupta 559 
				.values().stream().flatMap(Collection::stream).collect(Collectors.toList());
560 
		LOGGER.info("Fofo Id {}", inventoryItemAgingModels.get(0).getFofoId());
26961 amit.gupta 561 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
562 
		ExcelUtils.writeInventoryItemAgingModels(inventoryItemAgingModels, intervals, byteArrayOutputStream);
27583 tejbeer 563 
 
26961 amit.gupta 564 
		final HttpHeaders headers = new HttpHeaders();
565 
		// private static final String CONTENT_TYPE_XLSX =
566 
		// "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
567 
		headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
568 
		// headers.set("Content-Type", "application/vnd.ms-excel");
569 
		headers.set("Content-disposition", "inline; filename=InventoryItemAging.xlsx");
570 
		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
571 
		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
572 
		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
573 
		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
574 
	}
24123 tejbeer 575 
 
24106 tejbeer 576 
	@RequestMapping(value = "/featurePanel", method = RequestMethod.GET)
25371 tejbeer 577 
	public String FeaturePanel(HttpServletRequest request, Model model) throws Exception {
21987 kshitij.so 578 
 
24106 tejbeer 579 
		List<TagRanking> tagRanking = null;
25362 tejbeer 580 
		tagRanking = tagRankingRepository.getAllTagRanking();
24106 tejbeer 581 
		LOGGER.info("tagRanking" + tagRanking);
582 
		if (!tagRanking.isEmpty()) {
25371 tejbeer 583 
			Set<Integer> catalogIds = tagRanking.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());
24798 tejbeer 584 
			List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);
585 
			Map<Integer, String> catalogDescription = items.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(),
586 
					x -> x.getItemDescription(), (description1, description2) -> description1));
587 
 
588 
			LOGGER.info("catalogDescription" + catalogDescription);
24465 tejbeer 589 
			model.addAttribute("tagRanking", tagRanking);
24798 tejbeer 590 
			model.addAttribute("catalogDescription", catalogDescription);
24106 tejbeer 591 
 
592 
		} else {
593 
			model.addAttribute("tagRanking", tagRanking);
25362 tejbeer 594 
 
24106 tejbeer 595 
		}
596 
 
597 
		return "feature";
598 
 
599 
	}
24123 tejbeer 600 
 
26279 amit.gupta 601 
	@PostMapping(value = "/imei/upload")
26294 amit.gupta 602 
	public String uploadContent(HttpServletRequest request, @RequestPart("file") MultipartFile file, Model model)
26279 amit.gupta 603 
			throws Exception {
26482 tejbeer 604 
		/*
605 
		 * if(brand==null) { throw new
606 
		 * ProfitMandiBusinessException("Please select brand", "Brand empty",
607 
		 * "Brand required"); }
608 
		 */
26279 amit.gupta 609 
		List<CSVRecord> masterDataList = readFile(file);
610 
 
26482 tejbeer 611 
		Map<String, LocalDateTime> imeisActivationMap = masterDataList.stream()
612 
				.collect(Collectors.toMap(x -> x.get(0).trim(), x -> {
613 
					if (!StringUtils.isEmpty(x.get(1).trim())) {
614 
						return LocalDateTime.parse((String) (x.get(1).trim()), formatter);
26299 amit.gupta 615 
					} else {
616 
						return null;
617 
					}
618 
				}));
619 
		inventoryService.addActivatedImeis(imeisActivationMap);
620 
		model.addAttribute("response", true);
26294 amit.gupta 621 
		return "response";
26279 amit.gupta 622 
	}
623 
 
624 
	private List<CSVRecord> readFile(MultipartFile file) throws Exception {
625 
		List<CSVRecord> records = null;
626 
		try (CSVParser parser = new CSVParser(new InputStreamReader(file.getInputStream()), CSVFormat.DEFAULT)) {
627 
			records = parser.getRecords();
628 
			if (records.size() < 2) {
629 
				throw new ProfitMandiBusinessException("Uploaded File", "", "No records Found");
630 
			}
631 
			records.remove(0);
26482 tejbeer 632 
		} catch (Exception e) {
26279 amit.gupta 633 
			throw new ProfitMandiBusinessException("Parsing Failed", "parse failed", "file parse failed");
634 
		}
635 
		return records;
636 
	}
637 
 
24106 tejbeer 638 
	@RequestMapping(value = "/itemfeature", method = RequestMethod.POST)
24123 tejbeer 639 
	public String Itemfeature(HttpServletRequest request, @RequestBody ItemFeatureDataModel itemFeatureDatatModel,
640 
			Model model) throws Exception {
25371 tejbeer 641 
		TagRanking tagRanking = tagRankingRepository.selectBycatalogItemId(itemFeatureDatatModel.getCatalogItemId());
642 
		LOGGER.info("tagRanking" + tagRanking);
643 
		if (tagRanking == null) {
644 
			tagRanking = new TagRanking();
645 
			tagRanking.setCatalogItemId(itemFeatureDatatModel.getCatalogItemId());
25363 tejbeer 646 
		}
24106 tejbeer 647 
		tagRanking.setFeature(itemFeatureDatatModel.getFeature());
25363 tejbeer 648 
		tagRanking.setRankPoints(itemFeatureDatatModel.getRankPoints());
25371 tejbeer 649 
 
24123 tejbeer 650 
		tagRankingRepository.persist(tagRanking);
24106 tejbeer 651 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
652 
		return "response";
653 
	}
654 
 
24798 tejbeer 655 
	@RequestMapping(value = "/removeFeature", method = RequestMethod.DELETE)
656 
	public String removeTagRankingEnteries(HttpServletRequest request,
657 
			@RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {
24917 tejbeer 658 
 
24798 tejbeer 659 
		tagRankingRepository.deleteById(id);
660 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
661 
		return "response";
662 
	}
663 
 
24465 tejbeer 664 
	@RequestMapping(value = "/getDemolistbyfofoId", method = RequestMethod.GET)
665 
	public String DemoListbyFofoId(HttpServletRequest request,
666 
			@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {
667 
 
668 
		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
669 
				.collect(Collectors.toList());
30426 tejbeer 670 
 
671 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
672 
		Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
673 
				.filter(x -> x != null).collect(Collectors.toList()).stream()
674 
				.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
24465 tejbeer 675 
		String customRetailers = JSONObject.valueToString(customRetailersMap.values());
676 
		List<String> serailNumberList = liveDemoBillingRespository.selectAllSerialNumber();
677 
		LOGGER.info("serailNumberList" + serailNumberList);
678 
		List<InventoryItem> inventoryItem = null;
679 
		List<InventoryItem> inventoryItem1 = new ArrayList<>();
680 
		if (fofoId > 0) {
681 
			List<Item> items = itemRepository.selectAllByBrand("Live Demo");
682 
			Set<Integer> itemIds = new HashSet<>();
683 
			for (Item Item : items) {
684 
				itemIds.add(Item.getId());
685 
			}
686 
			inventoryItem = inventoryItemRepository.selectByFofoIdItemIds(fofoId, itemIds);
687 
 
688 
			Set<String> serial = new HashSet<>();
689 
			for (InventoryItem invItem : inventoryItem) {
24658 tejbeer 690 
				if (!serailNumberList.contains(invItem.getSerialNumber())) {
24465 tejbeer 691 
					inventoryItem1.add(invItem);
25371 tejbeer 692 
 
24465 tejbeer 693 
				}
694 
 
695 
			}
696 
 
697 
			LOGGER.info("inventoyItem" + inventoryItem1);
698 
			model.addAttribute("customRetailers", customRetailers);
25371 tejbeer 699 
 
24465 tejbeer 700 
			model.addAttribute("liveDemo", inventoryItem1);
701 
			CustomRetailer fofoIdsAndRetailerName = retailerService.getFofoRetailer(fofoId);
702 
 
703 
			model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);
704 
 
705 
		}
706 
 
707 
		else {
708 
			model.addAttribute("customRetailers", customRetailers);
709 
			model.addAttribute("liveDemo", inventoryItem1);
710 
		}
711 
 
712 
		return "live_demo_billing";
713 
 
714 
	}
715 
 
716 
	@RequestMapping(value = "/enableliveDemoSerailNumber", method = RequestMethod.POST)
717 
	public String EnableliveDemoSerailNumber(HttpServletRequest request, @RequestParam String serial_number,
718 
			Model model) throws Exception {
719 
 
720 
		LiveDemoSerialNumber liveDemoSerialNumber = new LiveDemoSerialNumber();
721 
		liveDemoSerialNumber.setSerialNumber(serial_number);
722 
 
723 
		liveDemoBillingRespository.persist(liveDemoSerialNumber);
724 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
725 
		return "response";
726 
	}
727 
 
24739 tejbeer 728 
	@RequestMapping(value = "/getInProcessOrder", method = RequestMethod.GET)
729 
	public String getInProcessOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
730 
 
731 
		List<com.spice.profitmandi.dao.entity.transaction.Order> inProcessorder = orderRepository
25067 tejbeer 732 
				.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);
24917 tejbeer 733 
		List<Integer> retailerIds = new ArrayList<>();
734 
		List<Integer> orderIds = new ArrayList<>();
735 
		if (!inProcessorder.isEmpty()) {
736 
			for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessorder) {
737 
				retailerIds.add(order.getRetailerId());
738 
				orderIds.add(order.getId());
24739 tejbeer 739 
 
24917 tejbeer 740 
			}
24739 tejbeer 741 
 
25640 tejbeer 742 
			List<NotifyOrder> notify = notifyOrderRespository.selectByorderIds(orderIds);
743 
			for (NotifyOrder notifyOrder : notify) {
25449 tejbeer 744 
 
25640 tejbeer 745 
				Order orderdetail = orderRepository.selectById(notifyOrder.getOrderId());
25449 tejbeer 746 
				if (!orderdetail.getStatus().equals(OrderStatus.SUBMITTED_FOR_PROCESSING)) {
25640 tejbeer 747 
					notifyOrder.setStatus(NotifyStatus.rejected);
25449 tejbeer 748 
				}
25640 tejbeer 749 
			}
24950 tejbeer 750 
 
24917 tejbeer 751 
			Map<Integer, Optional<NotifyOrder>> notifyOrders = notifyOrderRespository.selectByorderIds(orderIds)
752 
					.stream().collect(Collectors.groupingBy(NotifyOrder::getOrderId,
753 
							Collectors.maxBy((x1, x2) -> x1.getId() - x2.getId())));
24950 tejbeer 754 
 
26110 tejbeer 755 
			Map<Integer, NotifyCancel> notifyCancelOrders = notifyCancelOrderRepository.selectByOrderIds(orderIds)
756 
					.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
24917 tejbeer 757 
			Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()
758 
					.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));
759 
 
760 
			model.addAttribute("inProcessorder", inProcessorder);
761 
			model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);
762 
			model.addAttribute("latestNotifyOrders", notifyOrders);
26110 tejbeer 763 
			model.addAttribute("notifyCancelOrders", notifyCancelOrders);
24917 tejbeer 764 
		} else {
765 
			model.addAttribute("inProcessorder", inProcessorder);
766 
		}
24739 tejbeer 767 
		return "review_order";
768 
	}
769 
 
28109 tejbeer 770 
	@RequestMapping(value = "/getPaymentPendingOrder", method = RequestMethod.GET)
771 
	public String getPaymentPendingOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
772 
 
773 
		List<com.spice.profitmandi.dao.entity.transaction.Order> pendingPaymentorder = orderRepository
774 
				.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusMonths(3), LocalDateTime.now(),
775 
						OrderStatus.PAYMENT_PENDING);
776 
		List<com.spice.profitmandi.dao.entity.transaction.Order> failedPaymentorder = orderRepository
777 
				.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusMonths(3), LocalDateTime.now(),
778 
						OrderStatus.PAYMENT_FAILED);
779 
		pendingPaymentorder.addAll(failedPaymentorder);
780 
		model.addAttribute("pendingPaymentorder", pendingPaymentorder);
781 
 
782 
		return "payment-pending-order";
783 
	}
784 
 
24739 tejbeer 785 
	@RequestMapping(value = "/getKeepInTabOrder", method = RequestMethod.GET)
786 
	public String getKeepInTabOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
787 
 
788 
		List<com.spice.profitmandi.dao.entity.transaction.Order> keepatab = orderRepository
789 
				.selectAllOrder(OrderStatus.KEEP_A_TAB);
790 
 
791 
		model.addAttribute("keepatab", keepatab);
792 
 
793 
		return "keep-a-tab";
794 
	}
795 
 
796 
	@RequestMapping(value = "/closeOrder", method = RequestMethod.POST)
797 
	public String closeOrder(HttpServletRequest request, @RequestParam int orderId, Model model) throws Exception {
24798 tejbeer 798 
 
24739 tejbeer 799 
		Order order = orderRepository.selectById(orderId);
24798 tejbeer 800 
		if (order != null) {
24739 tejbeer 801 
			order.setStatus(OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);
24798 tejbeer 802 
 
24739 tejbeer 803 
			model.addAttribute("response", mvcResponseSender.createResponseString(true));
804 
 
24798 tejbeer 805 
		} else {
24739 tejbeer 806 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
807 
 
808 
		}
809 
		return "response";
24658 tejbeer 810 
	}
811 
 
25640 tejbeer 812 
	@RequestMapping(value = "/getcancelOrderItems", method = RequestMethod.GET)
813 
	public String getcancelOrderItems(HttpServletRequest request, @RequestParam int itemId, Model model)
814 
			throws Exception {
815 
 
816 
		List<Order> inProcessselectedOrder = orderRepository.selectByItemIdOrderStatus(itemId,
817 
				OrderStatus.SUBMITTED_FOR_PROCESSING);
818 
 
819 
		List<Integer> retailerIds = new ArrayList<>();
820 
		for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessselectedOrder) {
821 
			retailerIds.add(order.getRetailerId());
822 
 
823 
		}
824 
 
825 
		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()
826 
				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));
827 
 
828 
		model.addAttribute("inProcessCancelOrder", inProcessselectedOrder);
829 
		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);
830 
 
831 
		return "cancel-order-modal";
832 
	}
833 
 
24739 tejbeer 834 
	@RequestMapping(value = "/cancelOrder", method = RequestMethod.POST)
25640 tejbeer 835 
	public String cancelOrder(HttpServletRequest request, @RequestBody OrderCancellationModel orderCancellationModel,
836 
			Model model) throws Exception {
24739 tejbeer 837 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
25640 tejbeer 838 
		LOGGER.info("orderId" + orderCancellationModel.getOrderIds());
839 
 
24739 tejbeer 840 
		try {
25699 tejbeer 841 
			// List<Order> orders =
842 
			// orderRepository.selectByOrderIds(orderCancellationModel.getOrderIds());
25640 tejbeer 843 
 
25699 tejbeer 844 
			List<Order> orders = orderRepository.selectByOrderIdsOrdersStatus(orderCancellationModel.getOrderIds(),
845 
					OrderStatus.SUBMITTED_FOR_PROCESSING);
846 
			if (!orders.isEmpty()) {
847 
				for (Order order : orders) {
25640 tejbeer 848 
 
25699 tejbeer 849 
					orderRepository.refundOrder(order.getId(), loginDetails.getEmailId(),
850 
							orderCancellationModel.getReason(), OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);
851 
					List<NotifyOrder> notifyOrders = notifyOrderRespository.selectByOrder(order.getId());
852 
					for (NotifyOrder notifyOrder : notifyOrders) {
853 
						if (notifyOrder.getStatus() == NotifyStatus.pending) {
854 
							notifyOrder.setStatus(NotifyStatus.rejected);
855 
						}
25449 tejbeer 856 
					}
25699 tejbeer 857 
					sendCancellationNotificationToPartner(order, orderCancellationModel.getReason());
858 
					model.addAttribute("response", mvcResponseSender.createResponseString(true));
859 
 
25640 tejbeer 860 
				}
861 
			}
24739 tejbeer 862 
		} catch (TransactionServiceException | TException e) {
863 
			model.addAttribute("response", mvcResponseSender.createResponseString(false));
864 
 
865 
		}
25640 tejbeer 866 
 
24739 tejbeer 867 
		return "response";
868 
	}
869 
 
25039 amit.gupta 870 
	private void sendCancellationNotificationToPartner(Order order, String reason) throws Exception {
871 
		Item item = itemRepository.selectById(order.getLineItem().getItemId());
25383 tejbeer 872 
 
25851 amit.gupta 873 
		SendNotificationModel sendNotificationModel = new SendNotificationModel();
874 
		sendNotificationModel.setCampaignName("Order Cancellation");
875 
		sendNotificationModel.setTitle(String.format("Order %s %d(Pcs) cancelled", item.getItemDescription(),
25140 amit.gupta 876 
				order.getLineItem().getQuantity()));
25851 amit.gupta 877 
		sendNotificationModel.setType("url");
878 
		sendNotificationModel.setMessage(reason);
26482 tejbeer 879 
		sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/orderDetails");
25851 amit.gupta 880 
		sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
881 
		sendNotificationModel.setMessageType(MessageType.notification);
25857 tejbeer 882 
		int userId = userAccountRepository.selectUserIdByRetailerId(order.getRetailerId());
25873 tejbeer 883 
		sendNotificationModel.setUserIds(Arrays.asList(userId));
25851 amit.gupta 884 
		notificationService.sendNotification(sendNotificationModel);
25140 amit.gupta 885 
 
25039 amit.gupta 886 
	}
887 
 
24917 tejbeer 888 
	@RequestMapping(value = "/getNotifyItemColor", method = RequestMethod.GET)
889 
	public String getNotifyItemColor(HttpServletRequest request, @RequestParam int catalogItemId,
890 
			@RequestParam int itemId, Model model) throws ProfitMandiBusinessException {
891 
 
24950 tejbeer 892 
		List<Item> availableColorItems = itemRepository.selectAllByCatalogItemId(catalogItemId);
893 
		Iterator<Item> itemsIterator = availableColorItems.iterator();
24917 tejbeer 894 
 
24950 tejbeer 895 
		while (itemsIterator.hasNext()) {
896 
			Item item = itemsIterator.next();
897 
			TagListing itemTagListing = tagListingRepository.selectByItemId(item.getId());
898 
 
899 
			if (itemTagListing == null) {
900 
				itemsIterator.remove();
901 
 
902 
			}
903 
 
904 
			else if (!itemTagListing.isActive()) {
905 
				itemsIterator.remove();
906 
 
907 
			}
908 
		}
909 
 
24917 tejbeer 910 
		List<Order> inProcessselectedOrder = orderRepository.selectByItemIdOrderStatus(itemId,
911 
				OrderStatus.SUBMITTED_FOR_PROCESSING);
912 
		List<Integer> retailerIds = new ArrayList<>();
913 
 
914 
		for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessselectedOrder) {
915 
			retailerIds.add(order.getRetailerId());
916 
 
917 
		}
918 
 
919 
		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()
920 
				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));
24950 tejbeer 921 
		LOGGER.info("item" + availableColorItems);
922 
		model.addAttribute("item", availableColorItems);
24917 tejbeer 923 
		model.addAttribute("inProcessselectedOrder", inProcessselectedOrder);
924 
		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);
925 
 
926 
		return "notify-order-modal";
927 
	}
928 
 
929 
	@RequestMapping(value = "/notifyOrder", method = RequestMethod.POST)
930 
	public String NotifyOrder(HttpServletRequest request, @RequestBody NotifyOrderModel notifyOrderModel, Model model)
931 
			throws Exception {
932 
 
933 
		com.spice.profitmandi.dao.entity.transaction.NotifyItem notifyItem = null;
934 
		List<Integer> orderIds = new ArrayList<>();
935 
 
936 
		NotifyColorChange notifytimestamp = new NotifyColorChange();
937 
		notifytimestamp.setCreated(LocalDateTime.now());
938 
		notifyColorChangeRepository.persist(notifytimestamp);
25066 tejbeer 939 
		NotifyMessage notifyMessage = new NotifyMessage();
940 
		notifyMessage.setNotifyId(notifytimestamp.getId());
941 
		notifyMessage.setNotifyMessages(notifyOrderModel.getMessage());
25140 amit.gupta 942 
		notifyMessageRepository.persist(notifyMessage);
24917 tejbeer 943 
		for (NotifyItemIdModel itemid : notifyOrderModel.getItemIds()) {
944 
 
945 
			notifyItem = new com.spice.profitmandi.dao.entity.transaction.NotifyItem();
946 
			notifyItem.setItemId(itemid.getItemId());
947 
			notifyItem.setResponseTime(itemid.getResponseTime());
948 
			notifyItem.setProcuredDate(itemid.getProcuredTime());
949 
			notifyItem.setNotifyColorchangeId(notifytimestamp.getId());
950 
			notifyItemRepository.persist(notifyItem);
951 
			LOGGER.info("notifyItem" + notifyItem);
952 
		}
953 
		for (NotifyOrderIdModel st : notifyOrderModel.getOrderIds()) {
954 
			List<NotifyOrder> existingOrder = notifyOrderRespository.selectByOrder(st.getOrderId());
24950 tejbeer 955 
			if (!existingOrder.isEmpty()) {
24917 tejbeer 956 
				LOGGER.info("existingOrder" + existingOrder);
24950 tejbeer 957 
				for (NotifyOrder notifyOrder : existingOrder) {
958 
					if (NotifyStatus.pending == notifyOrder.getStatus()) {
959 
						notifyOrder.setStatus(NotifyStatus.rejected);
26105 tejbeer 960 
						notifyOrder.setUpdateTimestamp(LocalDateTime.now());
24950 tejbeer 961 
					}
24917 tejbeer 962 
				}
963 
			}
964 
			NotifyOrder orderStatus = new NotifyOrder();
965 
			orderStatus.setOrderId(st.getOrderId());
966 
			orderStatus.setNotifyId(notifytimestamp.getId());
967 
			orderStatus.setItemId(st.getOlditemId());
968 
			Order id = orderRepository.selectById(st.getOrderId());
969 
			orderStatus.setFofoId(id.getRetailerId());
970 
			orderStatus.setStatus(NotifyStatus.pending);
971 
			notifyOrderRespository.persist(orderStatus);
972 
 
973 
			LOGGER.info("itemStatus" + orderStatus);
974 
			orderIds.add(st.getOrderId());
975 
		}
976 
 
977 
		LOGGER.info("orderIds" + orderIds);
978 
		List<Order> orders = orderRepository.selectByOrderIds(orderIds);
979 
		for (Order order : orders) {
980 
			LOGGER.info("order" + order.getId());
981 
 
25140 amit.gupta 982 
			NotifyMessage message = notifyMessageRepository.selectByNotifyId(notifytimestamp.getId());
983 
 
25851 amit.gupta 984 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
985 
			sendNotificationModel.setCampaignName("Notify Partner");
986 
			sendNotificationModel.setMessage(message.getNotifyMessages());
987 
			sendNotificationModel.setType("url");
988 
			sendNotificationModel.setTitle("Alert");
26959 tejbeer 989 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifyOrder");
25851 amit.gupta 990 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
991 
			sendNotificationModel.setMessageType(MessageType.notification);
25857 tejbeer 992 
			int userId = userAccountRepository.selectUserIdByRetailerId(order.getRetailerId());
25873 tejbeer 993 
 
994 
			sendNotificationModel.setUserIds(Arrays.asList(userId));
25851 amit.gupta 995 
			notificationService.sendNotification(sendNotificationModel);
25140 amit.gupta 996 
 
24917 tejbeer 997 
		}
998 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
999 
		return "response";
1000 
	}
1001 
 
1002 
	@RequestMapping(value = "/getAllNotifyOrder", method = RequestMethod.GET)
1003 
	public String getAllNotifyOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
24950 tejbeer 1004 
		List<NotifyOrder> notifyOrders = null;
24917 tejbeer 1005 
		List<com.spice.profitmandi.dao.entity.transaction.Order> inProcessorder = orderRepository
25067 tejbeer 1006 
				.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);
24950 tejbeer 1007 
 
24917 tejbeer 1008 
		List<Integer> orderIds = new ArrayList<>();
24950 tejbeer 1009 
		if (!inProcessorder.isEmpty()) {
24917 tejbeer 1010 
			for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessorder) {
24950 tejbeer 1011 
 
24917 tejbeer 1012 
				orderIds.add(order.getId());
1013 
 
24950 tejbeer 1014 
			}
1015 
			notifyOrders = notifyOrderRespository.selectByorderIds(orderIds);
1016 
			Set<Integer> oldItemIds = new HashSet<>();
1017 
			List<Integer> fofoIds = new ArrayList<>();
1018 
			List<Integer> notifyIds = new ArrayList<>();
1019 
			if (!notifyOrders.isEmpty()) {
1020 
				for (NotifyOrder notifyOrder : notifyOrders) {
1021 
					oldItemIds.add(notifyOrder.getItemId());
1022 
					fofoIds.add(notifyOrder.getFofoId());
1023 
					notifyIds.add(notifyOrder.getNotifyId());
24917 tejbeer 1024 
				}
1025 
 
24950 tejbeer 1026 
				List<NotifyColorChange> notifyColorChanges = notifyColorChangeRepository.selectByNotifyId(notifyIds);
1027 
				Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = this
1028 
						.notifyOrdersToNotifyId(notifyColorChanges);
30426 tejbeer 1029 
				Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
30565 tejbeer 1030 
				Map<Integer, CustomRetailer> fofoIdsAndRetailerName = fofoIds.stream().distinct()
30426 tejbeer 1031 
						.map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream()
1032 
						.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
24950 tejbeer 1033 
				Map<Integer, String> itemdescription = inventoryService.getItemIdDescriptionMap(oldItemIds);
24917 tejbeer 1034 
 
24950 tejbeer 1035 
				model.addAttribute("notifyOrders", notifyOrders);
1036 
				model.addAttribute("notifyIdNotifyColorMap", notifyIdNotifyColorMap);
1037 
				model.addAttribute("itemdescription", itemdescription);
1038 
				model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);
24917 tejbeer 1039 
 
24950 tejbeer 1040 
			} else {
1041 
				model.addAttribute("notifyOrders", notifyOrders);
1042 
			}
24917 tejbeer 1043 
		} else {
1044 
			model.addAttribute("notifyOrders", notifyOrders);
24950 tejbeer 1045 
		}
24917 tejbeer 1046 
		return "notify_order";
1047 
	}
1048 
 
1049 
	private Map<Integer, NotifyColorChange> notifyOrdersToNotifyId(List<NotifyColorChange> notifyColorChanges) {
1050 
		Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = new HashMap<>();
1051 
		for (NotifyColorChange notifyColorChange : notifyColorChanges) {
1052 
			notifyIdNotifyColorMap.put(notifyColorChange.getId(), notifyColorChange);
1053 
		}
1054 
		return notifyIdNotifyColorMap;
1055 
	}
1056 
 
26031 tejbeer 1057 
	@RequestMapping(value = "/getItems", method = RequestMethod.GET)
1058 
	public String getItems(HttpServletRequest request, @RequestParam int catalogItemId, Model model) throws Exception {
1059 
 
1060 
		Set<Integer> itemIds = itemRepository.selectAllByCatalogItemId(catalogItemId).stream().map(x -> x.getId())
1061 
				.collect(Collectors.toSet());
1062 
 
1063 
		List<Order> notAvailableProcessingOrder = orderRepository.selectByItemIdsOrderStatus(itemIds,
1064 
				OrderStatus.SUBMITTED_FOR_PROCESSING);
1065 
		LOGGER.info("notAvailableProcessingOrder" + notAvailableProcessingOrder);
1066 
 
1067 
		List<Integer> retailerIds = new ArrayList<>();
1068 
		for (com.spice.profitmandi.dao.entity.transaction.Order order : notAvailableProcessingOrder) {
1069 
			retailerIds.add(order.getRetailerId());
1070 
 
1071 
		}
1072 
 
1073 
		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()
1074 
				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));
1075 
 
1076 
		model.addAttribute("notAvailableProcessingOrder", notAvailableProcessingOrder);
1077 
		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);
1078 
 
1079 
		return "partner-cancel-order-modal";
1080 
	}
1081 
 
1082 
	@RequestMapping(value = "/notifyCancelOrder", method = RequestMethod.POST)
1083 
	public String NotifyCancelOrder(HttpServletRequest request, @RequestBody NotifyOrderModel notifyOrderModel,
1084 
			Model model) throws Exception {
1085 
		for (NotifyOrderIdModel st : notifyOrderModel.getOrderIds()) {
1086 
			LOGGER.info("orderId" + st.getOrderId());
1087 
			Order order = orderRepository.selectById(st.getOrderId());
26110 tejbeer 1088 
			NotifyCancel nc = notifyCancelOrderRepository.selectByOrderId(st.getOrderId());
1089 
			if (nc == null) {
1090 
				nc = new NotifyCancel();
1091 
				nc.setOrderId(st.getOrderId());
1092 
				nc.setItemId(st.getOlditemId());
1093 
				nc.setFofoId(order.getRetailerId());
1094 
				nc.setCancellation(false);
1095 
				nc.setCreatedTimestamp(LocalDateTime.now());
1096 
				nc.setUpdatedTimestamp(LocalDateTime.now());
1097 
				notifyCancelOrderRepository.persist(nc);
1098 
			} else {
1099 
				nc.setOrderId(st.getOrderId());
1100 
				nc.setItemId(st.getOlditemId());
1101 
				nc.setFofoId(order.getRetailerId());
1102 
				nc.setCancellation(false);
1103 
				nc.setUpdatedTimestamp(LocalDateTime.now());
1104 
				notifyCancelOrderRepository.persist(nc);
1105 
			}
26031 tejbeer 1106 
 
1107 
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
1108 
			sendNotificationModel.setCampaignName("Notify Partner");
1109 
			sendNotificationModel.setMessage(notifyOrderModel.getMessage());
1110 
			sendNotificationModel.setType("url");
1111 
			sendNotificationModel.setTitle("Alert");
26482 tejbeer 1112 
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifyCancelOrder");
26031 tejbeer 1113 
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
1114 
			sendNotificationModel.setMessageType(MessageType.notification);
1115 
			int userId = userAccountRepository.selectUserIdByRetailerId(order.getRetailerId());
1116 
 
1117 
			sendNotificationModel.setUserIds(Arrays.asList(userId));
1118 
			notificationService.sendNotification(sendNotificationModel);
1119 
 
1120 
		}
1121 
 
1122 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1123 
		return "response";
1124 
	}
26039 tejbeer 1125 
 
1126 
	@RequestMapping(value = "/getNotifiedCancelOrder", method = RequestMethod.GET)
1127 
	public String getNotifiedCancelOrder(HttpServletRequest request, Model model) throws Exception {
1128 
 
1129 
		List<NotifyCancel> notifyCancels = notifyCancelOrderRepository.selectAllNonCancelOrder();
1130 
		if (!notifyCancels.isEmpty()) {
1131 
			List<Integer> retailerIds = new ArrayList<>();
1132 
			Set<Integer> itemIds = new HashSet<>();
1133 
			for (NotifyCancel nc : notifyCancels) {
1134 
				retailerIds.add(nc.getFofoId());
1135 
				itemIds.add(nc.getItemId());
1136 
			}
1137 
 
30426 tejbeer 1138 
			Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
26039 tejbeer 1139 
 
30426 tejbeer 1140 
			Map<Integer, CustomRetailer> fofoIdsAndRetailerName = retailerIds.stream()
1141 
					.map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream()
1142 
					.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
26039 tejbeer 1143 
			Map<Integer, String> itemdescription = inventoryService.getItemIdDescriptionMap(itemIds);
1144 
			model.addAttribute("notifyCancels", notifyCancels);
1145 
			model.addAttribute("itemdescription", itemdescription);
1146 
			model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);
1147 
		} else {
1148 
 
1149 
			model.addAttribute("notifyCancels", notifyCancels);
1150 
 
1151 
		}
1152 
		return "notify_cancel";
1153 
	}
1154 
 
1155 
	@RequestMapping(value = "/getNotifyItems", method = RequestMethod.GET)
1156 
	public String getNotifyItems(HttpServletRequest request, @RequestParam int itemId, Model model) throws Exception {
1157 
		Item item = itemRepository.selectById(itemId);
1158 
 
1159 
		List<Integer> itemIds = itemRepository.selectAllByCatalogItemId(item.getCatalogItemId()).stream()
1160 
				.map(x -> x.getId()).collect(Collectors.toList());
1161 
 
1162 
		List<NotifyCancel> ncs = notifyCancelOrderRepository.selectByItemIdsAndStatus(itemIds);
1163 
		List<Integer> retailerIds = new ArrayList<>();
1164 
		Map<Integer, Object> orders = new HashMap<>();
1165 
		for (NotifyCancel nc : ncs) {
1166 
			retailerIds.add(nc.getFofoId());
1167 
			Order od = orderRepository.selectById(nc.getOrderId());
1168 
			orders.put(nc.getOrderId(), od);
1169 
		}
1170 
 
1171 
		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()
1172 
				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));
1173 
 
1174 
		model.addAttribute("notifyItems", ncs);
1175 
		model.addAttribute("orders", orders);
1176 
		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);
1177 
 
1178 
		return "notify_cancel_order_modal";
1179 
	}
1180 
 
1181 
	@RequestMapping(value = "/changeNotifyCancelRequest", method = RequestMethod.POST)
1182 
	public String changeNotifyCancelRequest(HttpServletRequest request, @RequestBody NotifyOrderModel notifyOrderModel,
1183 
			Model model) throws Exception {
1184 
		List<Integer> orderIds = notifyOrderModel.getOrderIds().stream().map(x -> x.getOrderId())
1185 
				.collect(Collectors.toList());
1186 
 
1187 
		List<NotifyCancel> ncs = notifyCancelOrderRepository.selectByOrderIds(orderIds);
1188 
		for (NotifyCancel nc : ncs) {
1189 
			nc.setCancellation(true);
1190 
		}
1191 
 
1192 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1193 
		return "response";
1194 
	}
26482 tejbeer 1195 
 
1196 
	@RequestMapping(value = "/getProducts", method = RequestMethod.GET)
1197 
	public String getProducts(HttpServletRequest request, Model model)
1198 
			throws ProfitMandiBusinessException, URISyntaxException, IOException {
1199 
 
1200 
		return "product-detail";
1201 
	}
1202 
 
1203 
	@RequestMapping(value = "/getProductInfo", method = RequestMethod.GET)
1204 
	public String getProductInfo(HttpServletRequest request, long catalogId, Model model) throws Exception {
1205 
		ContentPojo cp = mongoClient.getEntityById(catalogId);
26493 tejbeer 1206 
		model.addAttribute("cp", cp);
1207 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
26482 tejbeer 1208 
		return "product-info";
1209 
	}
26493 tejbeer 1210 
 
1211 
	@RequestMapping(value = "/getProductCompareInfo", method = RequestMethod.GET)
26512 amit.gupta 1212 
	public String getProductCompareInfo(HttpServletRequest request, @RequestParam List<Long> catalogIds, Model model)
26493 tejbeer 1213 
			throws Exception {
1214 
		List<ContentPojo> cps = new ArrayList<>();
27583 tejbeer 1215 
		Set<Integer> cataogIds = catalogIds.stream().mapToInt(Long::intValue).boxed().collect(Collectors.toSet());
27596 tejbeer 1216 
		LOGGER.info("tagListingMOP" + cataogIds);
26512 amit.gupta 1217 
		for (Long cId : catalogIds) {
1218 
			ContentPojo cp = mongoClient.getEntityById(cId);
26959 tejbeer 1219 
			if (cp.getName() == null) {
26512 amit.gupta 1220 
				cp.setName(itemRepository.selectAllByCatalogItemId(cId.intValue()).get(0).getItemDescriptionNoColor());
1221 
			}
27583 tejbeer 1222 
			List<Item> items = itemRepository.selectAllByCatalogItemId(cId.intValue());
27596 tejbeer 1223 
			LOGGER.info("itemsMop" + items);
27618 tejbeer 1224 
			int i = 0;
1225 
			for (Item item : items) {
1226 
				TagListing tagListing = tagListingRepository.selectByItemId(items.get(i).getId());
1227 
 
1228 
				if (tagListing != null) {
1229 
					cp.setPrice(tagListing.getMop());
1230 
 
1231 
					LOGGER.info("tagListingMOP" + tagListing);
1232 
 
1233 
					break;
1234 
 
1235 
				}
1236 
				i++;
27596 tejbeer 1237 
			}
27618 tejbeer 1238 
			cps.add(cp);
27583 tejbeer 1239 
 
26493 tejbeer 1240 
		}
26959 tejbeer 1241 
 
26498 amit.gupta 1242 
		List<Map<String, String>> entityList = new ArrayList<>();
26959 tejbeer 1243 
		for (ContentPojo cp : cps) {
26498 amit.gupta 1244 
			Map<String, String> specsMap = new HashMap<>();
26959 tejbeer 1245 
			for (SpecificationGroup sg : cp.getDetailedSpecs()) {
26498 amit.gupta 1246 
				String title = sg.getTitle();
26959 tejbeer 1247 
				for (Specification s : sg.getSpecs()) {
26498 amit.gupta 1248 
					String key = title + s.getName();
1249 
					specsMap.put(key, String.join(", ", s.getValues()));
1250 
				}
1251 
			}
1252 
			entityList.add(specsMap);
27723 tejbeer 1253 
 
26498 amit.gupta 1254 
		}
26959 tejbeer 1255 
 
26493 tejbeer 1256 
		LOGGER.info("cps" + cps);
26959 tejbeer 1257 
		model.addAttribute("cps", cps);
1258 
		model.addAttribute("catalogIds", gson.toJson(catalogIds, List.class));
1259 
		model.addAttribute("entityList", entityList);
26493 tejbeer 1260 
		return "product-compare";
1261 
	}
27723 tejbeer 1262 
 
1263 
	@RequestMapping(value = "/inventory", method = RequestMethod.GET)
1264 
	public String Inventory(HttpServletRequest request,
1265 
			@RequestParam(name = "warehouseIds", required = true, defaultValue = "0") List<Integer> warehouseIds,
1266 
			Model model) throws Exception {
1267 
		model.addAttribute("warehouseId", warehouseIds);
1268 
		LOGGER.info("warehouseIds" + warehouseIds);
1269 
 
1270 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
1271 
		if (warehouseIds.contains(0)) {
1272 
			warehouseIds.addAll(warehouseMap.keySet());
1273 
		}
1274 
 
27739 tejbeer 1275 
		long poTodayValue = 0;
1276 
		long poThreedaysValue = 0;
1277 
		long poSevendaysValue = 0;
1278 
		long poTodayQty = 0;
1279 
		long poThreedaysQty = 0;
1280 
		long poSevendaysQty = 0;
1281 
 
27723 tejbeer 1282 
		List<OpenPoModel> openPO = warehousePurchaseOrderRepository.selectOpenPol(warehouseIds);
27739 tejbeer 1283 
		for (OpenPoModel po : openPO) {
1284 
			poTodayValue += po.getTodayValue();
1285 
			poThreedaysValue += po.getThreedaysValue();
1286 
			poSevendaysValue += po.getSevendaysValue();
1287 
			poTodayQty += po.getTodayQty();
1288 
			poThreedaysQty += po.getThreedaysQty();
1289 
			poSevendaysQty += po.getSevendaysQty();
1290 
		}
1291 
		OpenPoModel poModel = new OpenPoModel();
1292 
		poModel.setBrand("Total Values");
1293 
		poModel.setTodayValue(poTodayValue);
1294 
		poModel.setThreedaysValue(poThreedaysValue);
1295 
		poModel.setSevendaysValue(poSevendaysValue);
1296 
		poModel.setSevendaysQty(poSevendaysQty);
1297 
		poModel.setThreedaysQty(poThreedaysQty);
1298 
		poModel.setTodayQty(poTodayQty);
1299 
		openPO.add(poModel);
1300 
 
1301 
		long purtodayValue = 0;
1302 
		long purthreedaysValue = 0;
27749 tejbeer 1303 
		long purlmsValue = 0;
27739 tejbeer 1304 
		long purmtd = 0;
1305 
		long purtodayQty = 0;
1306 
		long purthreedaysQty = 0;
27749 tejbeer 1307 
		long purlmsQty = 0;
27739 tejbeer 1308 
		long purmtdQty = 0;
1309 
 
27723 tejbeer 1310 
		List<OurPurchaseModel> purchase = warehouseScanRepository.selectOurPurchase(warehouseIds);
27739 tejbeer 1311 
 
1312 
		for (OurPurchaseModel pm : purchase) {
1313 
			purtodayValue += pm.getTodayValue();
1314 
			purthreedaysValue += pm.getThreedaysValue();
27749 tejbeer 1315 
			purlmsValue += pm.getLms();
27739 tejbeer 1316 
			purmtd += pm.getMtd();
1317 
			purtodayQty += pm.getTodayQty();
27749 tejbeer 1318 
			purthreedaysQty += pm.getThreedaysQty();
1319 
			purlmsQty += pm.getLmsQty();
27739 tejbeer 1320 
			purmtdQty += pm.getMtdQty();
1321 
		}
1322 
		OurPurchaseModel omp = new OurPurchaseModel();
1323 
		omp.setBrand("Total Values");
1324 
		omp.setTodayValue(purtodayValue);
1325 
		omp.setThreedaysValue(purthreedaysValue);
27749 tejbeer 1326 
		omp.setLms(purlmsValue);
27739 tejbeer 1327 
		omp.setMtd(purmtd);
1328 
		omp.setTodayQty(purtodayQty);
1329 
		omp.setThreedaysQty(purthreedaysQty);
27749 tejbeer 1330 
		omp.setLmsQty(purlmsQty);
27739 tejbeer 1331 
		omp.setMtdQty(purmtdQty);
1332 
		purchase.add(omp);
27749 tejbeer 1333 
 
27723 tejbeer 1334 
		List<BrandWiseTertiaryModel> tertiary = fofoOrderRepository.selectGroupByBrandPartnerTertiary(warehouseIds);
27739 tejbeer 1335 
		long tertodayValue = 0;
1336 
		long terthreedaysValue = 0;
1337 
		long termtd = 0;
1338 
		long terlmtd = 0;
27749 tejbeer 1339 
		long terlms = 0;
27739 tejbeer 1340 
		long tertodayQty = 0;
1341 
		long terthreedaysQty = 0;
1342 
		long termtdQty = 0;
1343 
		long terlmtdQty = 0;
27749 tejbeer 1344 
		long terlmsQty = 0;
27739 tejbeer 1345 
		for (BrandWiseTertiaryModel btm : tertiary) {
1346 
			tertodayValue += btm.getTodayValue();
1347 
			terthreedaysValue += btm.getThreedaysValue();
1348 
			termtd += btm.getMtd();
1349 
			terlmtd += btm.getLmtd();
27749 tejbeer 1350 
			terlms += btm.getLms();
27739 tejbeer 1351 
			tertodayQty += btm.getTodayQty();
1352 
			terthreedaysQty += btm.getThreedaysQty();
1353 
			termtdQty += btm.getMtdQty();
1354 
			terlmtdQty += btm.getLmtdQty();
27749 tejbeer 1355 
			terlmsQty += btm.getLmsQty();
27739 tejbeer 1356 
		}
1357 
		BrandWiseTertiaryModel bwt = new BrandWiseTertiaryModel();
1358 
		bwt.setBrand("Total Values");
1359 
		bwt.setTodayValue(tertodayValue);
1360 
		bwt.setThreedaysValue(terthreedaysValue);
1361 
		bwt.setMtd(termtd);
1362 
		bwt.setLmtd(terlmtd);
27749 tejbeer 1363 
		bwt.setLms(terlms);
27739 tejbeer 1364 
		bwt.setTodayQty(tertodayQty);
1365 
		bwt.setThreedaysQty(terthreedaysQty);
1366 
		bwt.setMtdQty(termtdQty);
1367 
		bwt.setLmtdQty(terlmtdQty);
27749 tejbeer 1368 
		bwt.setLmsQty(terlmsQty);
27739 tejbeer 1369 
		tertiary.add(bwt);
27749 tejbeer 1370 
 
27723 tejbeer 1371 
		List<SecondaryOrderBillingModel> billing = orderRepository.selectAllBilledOrderGroupByBrand(warehouseIds);
27739 tejbeer 1372 
		long sectodayValue = 0;
1373 
		long secthreedaysValue = 0;
1374 
		long secmtd = 0;
1375 
		long seclmtd = 0;
27749 tejbeer 1376 
		long seclms = 0;
27739 tejbeer 1377 
		long sectodayQty = 0;
1378 
		long secthreedaysQty = 0;
1379 
		long secmtdQty = 0;
1380 
		long seclmtdQty = 0;
27749 tejbeer 1381 
		long seclmsQty = 0;
27739 tejbeer 1382 
		for (SecondaryOrderBillingModel sbm : billing) {
1383 
			sectodayValue += sbm.getTodayValue();
1384 
			secthreedaysValue += sbm.getThreedaysValue();
1385 
			secmtd += sbm.getMtd();
1386 
			seclmtd += sbm.getLmtd();
27749 tejbeer 1387 
			seclms += sbm.getLms();
27739 tejbeer 1388 
			sectodayQty += sbm.getTodayQty();
1389 
			secthreedaysQty += sbm.getThreedaysQty();
1390 
			secmtdQty += sbm.getMtdQty();
1391 
			seclmtdQty += sbm.getLmtdQty();
27749 tejbeer 1392 
			seclmsQty += sbm.getLmsQty();
27739 tejbeer 1393 
		}
1394 
 
1395 
		SecondaryOrderBillingModel som = new SecondaryOrderBillingModel();
1396 
		som.setBrand("Total Values");
1397 
		som.setTodayValue(sectodayValue);
1398 
		som.setThreedaysValue(secthreedaysValue);
1399 
		som.setMtd(secmtd);
1400 
		som.setLmtd(seclmtd);
27749 tejbeer 1401 
		som.setLms(seclms);
27739 tejbeer 1402 
		som.setTodayQty(sectodayQty);
1403 
		som.setThreedaysQty(secthreedaysQty);
1404 
		som.setMtdQty(secmtdQty);
1405 
		som.setLmtdQty(seclmtdQty);
27749 tejbeer 1406 
		som.setLmsQty(seclmsQty);
27739 tejbeer 1407 
		billing.add(som);
27723 tejbeer 1408 
		LOGGER.info("openPO" + openPO);
1409 
		LOGGER.info("purchase" + purchase);
1410 
		LOGGER.info("tertiary" + tertiary);
1411 
		LOGGER.info("billing" + billing);
1412 
 
1413 
		LOGGER.info("warehouseIds" + warehouseIds);
1414 
		model.addAttribute("warehouseMap", warehouseMap);
1415 
		model.addAttribute("openPO", openPO);
1416 
		model.addAttribute("purchase", purchase);
1417 
		model.addAttribute("tertiary", tertiary);
1418 
		model.addAttribute("billing", billing);
1419 
 
1420 
		return "inventory-listing";
1421 
 
1422 
	}
27738 tejbeer 1423 
 
1424 
	@RequestMapping(value = "/getOpenPoItemByBrand", method = RequestMethod.GET)
1425 
	public String Inventory(HttpServletRequest request,
1426 
			@RequestParam(name = "warehouseIds", required = true, defaultValue = "0") List<Integer> warehouseIds,
27749 tejbeer 1427 
			@RequestParam(name = "brand", required = true, defaultValue = "") List<String> brand, int timeValue,
1428 
			Model model) throws Exception {
27738 tejbeer 1429 
		model.addAttribute("warehouseId", warehouseIds);
1430 
		LOGGER.info("warehouseIds" + warehouseIds);
1431 
 
1432 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
1433 
		if (warehouseIds.contains(0)) {
1434 
			warehouseIds.addAll(warehouseMap.keySet());
1435 
		}
27749 tejbeer 1436 
		LOGGER.info("brand" + brand);
1437 
 
1438 
		if (brand.contains("Total Values")) {
1439 
			List<String> poBrands = warehousePurchaseOrderRepository.selectOpenPol(warehouseIds).stream()
1440 
					.map(x -> x.getBrand()).collect(Collectors.toList());
1441 
 
1442 
			brand.addAll(poBrands);
1443 
		}
1444 
 
1445 
		LOGGER.info("brand" + brand);
27738 tejbeer 1446 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
1447 
		List<OpenPoItemModel> openPOItem = null;
1448 
		if (timeValue != 0) {
1449 
			openPOItem = warehousePurchaseOrderRepository.selectOpenPoItem(warehouseIds, brand,
1450 
					curDate.minusDays(timeValue), curDate);
1451 
		} else {
1452 
			openPOItem = warehousePurchaseOrderRepository.selectTodayOpenPoItem(warehouseIds, brand, curDate);
1453 
		}
1454 
		LOGGER.info("openPOItem" + openPOItem);
1455 
 
1456 
		model.addAttribute("openPOItem", openPOItem);
1457 
 
1458 
		return "inventory-listing-po-item";
1459 
 
1460 
	}
1461 
 
1462 
	@RequestMapping(value = "/getOurPurchaseItemByBrand", method = RequestMethod.GET)
1463 
	public String getOurPurchaseItemByBrand(HttpServletRequest request,
1464 
			@RequestParam(name = "warehouseIds", required = true, defaultValue = "0") List<Integer> warehouseIds,
27749 tejbeer 1465 
			@RequestParam(name = "brand", required = true, defaultValue = "") List<String> brand, int timeValue,
1466 
			Model model) throws Exception {
27738 tejbeer 1467 
		model.addAttribute("warehouseId", warehouseIds);
1468 
		LOGGER.info("warehouseIds" + warehouseIds);
1469 
 
1470 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
1471 
		if (warehouseIds.contains(0)) {
1472 
			warehouseIds.addAll(warehouseMap.keySet());
1473 
		}
1474 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
27749 tejbeer 1475 
 
1476 
		if (brand.contains("Total Values")) {
1477 
			List<String> purchasebrands = warehouseScanRepository.selectOurPurchase(warehouseIds).stream()
1478 
					.map(x -> x.getBrand()).collect(Collectors.toList());
1479 
 
1480 
			brand.addAll(purchasebrands);
1481 
		}
27738 tejbeer 1482 
		List<OurPurchaseItemModel> ourPurchaseItem = null;
1483 
		if (timeValue != 0) {
27749 tejbeer 1484 
			if (timeValue == 1) {
27738 tejbeer 1485 
				ourPurchaseItem = warehouseScanRepository.selectOurPurchaseItemByBrand(warehouseIds, brand,
27749 tejbeer 1486 
						curDate.withDayOfMonth(1), curDate.plusDays(1));
1487 
 
1488 
			} else if (timeValue == -1) {
1489 
 
1490 
				ourPurchaseItem = warehouseScanRepository.selectOurPurchaseItemByBrand(warehouseIds, brand,
1491 
						curDate.minusMonths(1).withDayOfMonth(1), curDate.withDayOfMonth(1));
1492 
 
27738 tejbeer 1493 
			} else {
1494 
				ourPurchaseItem = warehouseScanRepository.selectOurPurchaseItemByBrand(warehouseIds, brand,
27749 tejbeer 1495 
						curDate.minusDays(timeValue), curDate);
1496 
 
27738 tejbeer 1497 
			}
1498 
		} else {
1499 
			ourPurchaseItem = warehouseScanRepository.selectTodayOurPurchaseItemByBrand(warehouseIds, brand, curDate);
1500 
		}
1501 
		LOGGER.info("ourPurchaseItem" + ourPurchaseItem);
1502 
 
1503 
		model.addAttribute("ourPurchaseItem", ourPurchaseItem);
27749 tejbeer 1504 
		model.addAttribute("warehouseMap", warehouseMap);
27738 tejbeer 1505 
 
1506 
		return "inventory-listing-purchase-item";
1507 
 
1508 
	}
1509 
 
27867 tejbeer 1510 
	@RequestMapping(value = "/getWarehouseWiseSecondaryBillingByBrand", method = RequestMethod.GET)
1511 
	public String getWarehouseWiseSecondaryBillingByBrand(HttpServletRequest request,
1512 
			@RequestParam(name = "brand", required = true, defaultValue = "") String brand, int timeValue, Model model)
1513 
			throws Exception {
27738 tejbeer 1514 
 
1515 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
27749 tejbeer 1516 
		int dayOfMonth = curDate.getDayOfMonth();
1517 
		LocalDateTime startOfMonth = curDate.withDayOfMonth(1);
1518 
		int lengthOfMonth = YearMonth.from(startOfMonth.minusMonths(1)).lengthOfMonth();
1519 
 
27867 tejbeer 1520 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
1521 
		SecondaeryOrderDateRange sr = null;
1522 
		if (brand.equals("Total Values")) {
1523 
			brand = null;
27749 tejbeer 1524 
		}
27738 tejbeer 1525 
		if (timeValue != 0) {
1526 
			if (timeValue == 1) {
1527 
 
27867 tejbeer 1528 
				sr = getSecondaryModel(brand, curDate.withDayOfMonth(1), curDate.plusDays(1));
1529 
 
27738 tejbeer 1530 
			} else if (timeValue == 2) {
27749 tejbeer 1531 
				LOGGER.info("curDate" + curDate.withDayOfMonth(1).minusMonths(1));
1532 
				LOGGER.info("curDate" + curDate.minusMonths(1).plusDays(Math.min(dayOfMonth, lengthOfMonth)));
1533 
 
27867 tejbeer 1534 
				sr = getSecondaryModel(brand, curDate.withDayOfMonth(1).minusMonths(1),
27749 tejbeer 1535 
						startOfMonth.minusMonths(1).plusDays(Math.min(dayOfMonth, lengthOfMonth)));
27867 tejbeer 1536 
 
27749 tejbeer 1537 
			} else if (timeValue == -1) {
27867 tejbeer 1538 
 
1539 
				sr = getSecondaryModel(brand, curDate.minusMonths(1).withDayOfMonth(1), startOfMonth);
1540 
 
27749 tejbeer 1541 
			} else {
27738 tejbeer 1542 
 
27867 tejbeer 1543 
				sr = getSecondaryModel(brand, curDate.minusDays(timeValue), curDate);
27738 tejbeer 1544 
			}
1545 
 
1546 
		} else {
27867 tejbeer 1547 
			sr = getSecondaryModel(brand, curDate, curDate.plusDays(1));
27738 tejbeer 1548 
		}
1549 
 
27867 tejbeer 1550 
		Map<BrandRegionModel, Map<LocalDate, SecondaryWarehouseWiseOrderBilllingModel>> brandWarehouseOrderMap = sr
1551 
				.getSecondaryModel().stream()
1552 
				.collect(Collectors.groupingBy(x -> new BrandRegionModel(x.getWarehouseId(), x.getBrand()),
1553 
						Collectors.collectingAndThen(Collectors.toList(),
1554 
								x -> x.stream().collect(Collectors.toMap(y -> y.getBillingTimestamp(), y -> y)))));
27738 tejbeer 1555 
 
27893 tejbeer 1556 
		Map<LocalDate, Integer> dateWiseTotal = sr.getSecondaryModel().stream().collect(
1557 
				Collectors.groupingBy(x -> x.getBillingTimestamp(), Collectors.summingInt(x -> (int) x.getValue())));
1558 
 
1559 
		Map<LocalDate, Integer> dateWiseQtyTotal = sr.getSecondaryModel().stream().collect(
1560 
				Collectors.groupingBy(x -> x.getBillingTimestamp(), Collectors.summingInt(x -> (int) x.getQty())));
1561 
 
1562 
		LOGGER.info("dateWiseTotal" + dateWiseTotal);
1563 
 
27867 tejbeer 1564 
		brandWarehouseOrderMap.entrySet().stream().forEach(x -> {
27893 tejbeer 1565 
			x.getKey().setTotal(x.getValue().entrySet().stream()
1566 
					.collect(Collectors.summingInt(y -> (int) y.getValue().getValue())));
27867 tejbeer 1567 
		});
1568 
 
27893 tejbeer 1569 
		brandWarehouseOrderMap.entrySet().stream().forEach(x -> {
1570 
			x.getKey().setQty(
1571 
					x.getValue().entrySet().stream().collect(Collectors.summingInt(y -> (int) y.getValue().getQty())));
1572 
		});
27867 tejbeer 1573 
		LOGGER.info("brandWarehouseOrderMap" + brandWarehouseOrderMap);
1574 
 
1575 
		model.addAttribute("brandWarehouseOrderMap", brandWarehouseOrderMap);
27893 tejbeer 1576 
		model.addAttribute("dateWiseTotal", dateWiseTotal);
1577 
		model.addAttribute("dateWiseQtyTotal", dateWiseQtyTotal);
27867 tejbeer 1578 
		model.addAttribute("dateRange", sr.getDateRange());
1579 
		model.addAttribute("warehouseMap", warehouseMap);
1580 
		return "secondary-warehouse-billing-order";
1581 
 
1582 
	}
1583 
 
1584 
	public SecondaeryOrderDateRange getSecondaryModel(String brand, LocalDateTime startDate, LocalDateTime endDate) {
1585 
 
1586 
		SecondaeryOrderDateRange sr = new SecondaeryOrderDateRange();
1587 
		List<SecondaryWarehouseWiseOrderBilllingModel> secondaryOrderbilling = orderRepository
1588 
				.selectAllBilledOrderGroupByBrandWarehouse(brand, startDate, endDate).stream()
1589 
				.sorted(Comparator.comparing(SecondaryWarehouseWiseOrderBilllingModel::getBillingTimestamp))
1590 
				.collect(Collectors.toList());
1591 
		long noOfDaysBetween = ChronoUnit.DAYS.between(startDate, endDate);
1592 
 
1593 
		List<LocalDate> dateRange = Stream.iterate(startDate.toLocalDate(), date -> date.plusDays(1))
1594 
				.limit(noOfDaysBetween).collect(Collectors.toList());
1595 
 
1596 
		sr.setDateRange(dateRange);
1597 
		sr.setSecondaryModel(secondaryOrderbilling);
1598 
 
1599 
		return sr;
1600 
 
1601 
	}
1602 
 
1603 
	@RequestMapping(value = "/getSecondaryBillingItemByBrand", method = RequestMethod.GET)
1604 
	public String getSecondaryBillingItemByBrand(HttpServletRequest request,
1605 
			@RequestParam(name = "warehouseId", required = true, defaultValue = "0") int warehouseId,
1606 
			@RequestParam(name = "brand", required = true, defaultValue = "") String brand,
27893 tejbeer 1607 
			@RequestParam List<LocalDate> date, Model model) throws Exception {
27867 tejbeer 1608 
 
1609 
		List<SecondaryOrderItemBillingModel> orderItemBilling = orderRepository
1610 
				.selectAllBilledOrderItemByBrand(warehouseId, brand, date);
1611 
 
1612 
		LOGGER.info("orderItemBilling" + orderItemBilling);
1613 
		model.addAttribute("billedItem", orderItemBilling);
1614 
		model.addAttribute("date", date);
1615 
		model.addAttribute("brand", brand);
27738 tejbeer 1616 
		return "inventory-listing-billing-item";
1617 
 
1618 
	}
1619 
 
1620 
	@RequestMapping(value = "/getPartnerTertiaryItemByBrand", method = RequestMethod.GET)
1621 
	public String getPartnerTertiaryItemByBrand(HttpServletRequest request,
1622 
			@RequestParam(name = "warehouseIds", required = true, defaultValue = "0") List<Integer> warehouseIds,
27749 tejbeer 1623 
			@RequestParam(name = "brand", required = true, defaultValue = "") List<String> brand, int timeValue,
1624 
			Model model) throws Exception {
27738 tejbeer 1625 
		model.addAttribute("warehouseId", warehouseIds);
1626 
		LOGGER.info("warehouseIds" + warehouseIds);
1627 
 
1628 
		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
1629 
		if (warehouseIds.contains(0)) {
1630 
			warehouseIds.addAll(warehouseMap.keySet());
1631 
		}
1632 
		LocalDateTime curDate = LocalDate.now().atStartOfDay();
1633 
		int dayOfMonth = curDate.getDayOfMonth();
1634 
		LocalDateTime startOfMonth = curDate.withDayOfMonth(1);
27749 tejbeer 1635 
		int lengthOfMonth = YearMonth.from(startOfMonth.minusMonths(1)).lengthOfMonth();
1636 
		if (brand.contains("Total Values")) {
1637 
			List<String> tertiaryBrands = fofoOrderRepository.selectGroupByBrandPartnerTertiary(warehouseIds).stream()
1638 
					.map(x -> x.getBrand()).collect(Collectors.toList());
27738 tejbeer 1639 
 
27749 tejbeer 1640 
			brand.addAll(tertiaryBrands);
1641 
		}
27738 tejbeer 1642 
		List<BrandItemWiseTertiaryModel> tertiaryItem = null;
1643 
		if (timeValue != 0) {
1644 
			if (timeValue == 1) {
27749 tejbeer 1645 
 
27738 tejbeer 1646 
				tertiaryItem = fofoOrderRepository.selectItemPartnerTertiaryByBrand(warehouseIds, brand,
1647 
						curDate.withDayOfMonth(1), curDate.plusDays(1));
1648 
 
1649 
			} else if (timeValue == 2) {
27749 tejbeer 1650 
				LOGGER.info("curDate" + startOfMonth.minusMonths(1));
1651 
				LOGGER.info("curDate" + startOfMonth.minusMonths(1).plusDays(Math.min(dayOfMonth, lengthOfMonth)));
27738 tejbeer 1652 
 
1653 
				tertiaryItem = fofoOrderRepository.selectItemPartnerTertiaryByBrand(warehouseIds, brand,
27749 tejbeer 1654 
						startOfMonth.minusMonths(1),
27738 tejbeer 1655 
						startOfMonth.minusMonths(1).plusDays(Math.min(dayOfMonth, lengthOfMonth)));
1656 
 
27749 tejbeer 1657 
			} else if (timeValue == -1) {
1658 
				LOGGER.info("date" + curDate.minusMonths(1).withDayOfMonth(1));
1659 
				LOGGER.info("date" + curDate.minusMonths(1).withDayOfMonth(lengthOfMonth).plusDays(1));
1660 
 
1661 
				tertiaryItem = fofoOrderRepository.selectItemPartnerTertiaryByBrand(warehouseIds, brand,
1662 
						curDate.minusMonths(1).withDayOfMonth(1), startOfMonth);
27738 tejbeer 1663 
			} else {
1664 
				tertiaryItem = fofoOrderRepository.selectItemPartnerTertiaryByBrand(warehouseIds, brand,
1665 
						curDate.minusDays(timeValue), curDate);
1666 
			}
1667 
 
1668 
		} else {
1669 
			tertiaryItem = fofoOrderRepository.selectTodayItemPartnerTertiaryByBrand(warehouseIds, brand, curDate);
1670 
		}
1671 
		LOGGER.info("tertiaryItem" + tertiaryItem);
1672 
 
1673 
		model.addAttribute("tertiaryItem", tertiaryItem);
1674 
 
1675 
		return "inventory-item-tertiary-item";
1676 
 
1677 
	}
28701 tejbeer 1678 
 
1679 
	@RequestMapping(value = "/planogram")
1680 
	public String Planogram(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
1681 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
1682 
		String email = loginDetails.getEmailId();
1683 
		AuthUser authUser = authRepository.selectByEmailOrMobile(email);
1684 
		List<FocusedModelByPassRequest> byPassRequest = null;
1685 
		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
1686 
 
1687 
		Set<Integer> authfofoIds = null;
1688 
 
1689 
		List<Position> positions = positionRepository.selectPositionByAuthId(authUser.getId());
1690 
 
1691 
		if (emails.contains(authUser.getEmailId())) {
1692 
			authfofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");
1693 
			LOGGER.info("fofoIds" + authfofoIds);
1694 
		} else {
1695 
 
1696 
			for (Position ps : positions) {
1697 
				if (esclationType.contains(ps.getEscalationType())) {
1698 
					authfofoIds = storeGuyMap.get(email);
1699 
					break;
1700 
				}
1701 
 
1702 
			}
1703 
		}
1704 
		if (authfofoIds != null) {
1705 
			byPassRequest = focusedModelByPassRepository.selectByStatusAndFofoIds(new ArrayList<>(authfofoIds),
1706 
					ByPassRequestStatus.PENDING);
1707 
		}
1708 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
1709 
		model.addAttribute("customRetailerMap", customRetailerMap);
1710 
		model.addAttribute("byPassRequest", byPassRequest);
1711 
		return "planogram";
1712 
	}
1713 
 
1714 
	@RequestMapping(value = "/byPassRequestAction", method = RequestMethod.PUT)
1715 
	public String addAmountToWalletRequestRejected(HttpServletRequest request,
1716 
			@RequestParam(name = "id", defaultValue = "0") int id, @RequestParam ByPassRequestStatus status,
30244 tejbeer 1717 
			@RequestParam(name = "reason", required = false) String reason, Model model) throws Exception {
28701 tejbeer 1718 
 
1719 
		FocusedModelByPassRequest byPassRequest = focusedModelByPassRepository.selectById(id);
1720 
		if (status.equals(ByPassRequestStatus.APPROVED)) {
1721 
			byPassRequest.setByPass(true);
1722 
			byPassRequest.setStatus(ByPassRequestStatus.APPROVED);
1723 
			byPassRequest.setUpdatedTimestamp(LocalDateTime.now());
29707 tejbeer 1724 
			byPassRequest.setReason(reason);
28701 tejbeer 1725 
		} else if (status.equals(ByPassRequestStatus.REJECTED)) {
1726 
			byPassRequest.setByPass(false);
1727 
			byPassRequest.setStatus(ByPassRequestStatus.REJECTED);
1728 
			byPassRequest.setUpdatedTimestamp(LocalDateTime.now());
29707 tejbeer 1729 
			byPassRequest.setReason(reason);
28701 tejbeer 1730 
		}
1731 
 
1732 
		SendNotificationModel sendNotificationModel = new SendNotificationModel();
28714 tejbeer 1733 
		sendNotificationModel.setCampaignName("Billing Request");
1734 
		sendNotificationModel.setTitle("Billing Request");
1735 
		sendNotificationModel.setMessage(String.format("Your Billing  Request is " + " " + status
1736 
				+ "Please ensure to order the missing focus models as soon as possible"));
28701 tejbeer 1737 
		sendNotificationModel.setType("url");
1738 
		sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
1739 
		sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
1740 
		sendNotificationModel.setMessageType(MessageType.notification);
1741 
		sendNotificationModel
1742 
				.setUserIds(Arrays.asList(userAccountRepository.selectUserIdByRetailerId(byPassRequest.getFofoId())));
1743 
 
1744 
		notificationService.sendNotification(sendNotificationModel);
1745 
 
1746 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1747 
		return "response";
1748 
	}
1749 
 
28754 tejbeer 1750 
	@RequestMapping(value = "/highDemandItem", method = RequestMethod.GET)
1751 
	public String highDemandItem(HttpServletRequest request, Model model) throws Exception {
1752 
		List<HighDemandItem> hdis = highDemandItemsRepository.selectAll();
1753 
		if (!hdis.isEmpty()) {
1754 
			Map<Integer, Item> itemMap = this.getItemByCatalogId(hdis);
1755 
			model.addAttribute("itemMap", itemMap);
1756 
		}
1757 
 
1758 
		model.addAttribute("hdis", hdis);
1759 
 
1760 
		return "high_demand_item";
1761 
	}
1762 
 
1763 
	private Map<Integer, Item> getItemByCatalogId(List<HighDemandItem> hdis) {
1764 
		Map<Integer, Item> itemMap = new HashMap<>();
1765 
		for (HighDemandItem hdi : hdis) {
1766 
			List<Item> items = itemRepository.selectAllByCatalogItemId(hdi.getCatalogId());
1767 
			itemMap.put(items.get(0).getCatalogItemId(), items.get(0));
1768 
		}
1769 
 
1770 
		return itemMap;
1771 
	}
1772 
 
1773 
	@RequestMapping(value = "/addHighDemandItem", method = RequestMethod.POST)
1774 
	public String addHighDemandItem(HttpServletRequest request, @RequestParam int catalogId, @RequestParam int qty,
1775 
			Model model) throws Exception {
1776 
		HighDemandItem hdi = highDemandItemsRepository.selectByFofoIdAndCatalogId(catalogId);
1777 
 
1778 
		if (hdi == null) {
1779 
			hdi = new HighDemandItem();
1780 
			hdi.setCatalogId(catalogId);
1781 
			hdi.setQty(qty);
1782 
			hdi.setCreateTimestamp(LocalDateTime.now());
1783 
			hdi.setUpdateTimestamp(LocalDateTime.now());
1784 
			highDemandItemsRepository.persist(hdi);
1785 
		}
1786 
 
1787 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1788 
		return "response";
1789 
	}
1790 
 
1791 
	@RequestMapping(value = "/removeHighDemandItem", method = RequestMethod.DELETE)
1792 
	public String removeHighDemandItem(HttpServletRequest request,
1793 
			@RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {
1794 
		highDemandItemsRepository.deleteById(id);
1795 
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
1796 
		return "response";
1797 
	}
1798 
 
28795 tejbeer 1799 
	@GetMapping(value = "/imei")
1800 
	public String getImei(HttpServletRequest request, Model model, @RequestParam int fofoId, @RequestParam String query)
1801 
			throws Exception {
1802 
 
1803 
		List<String> serialNumber = inventoryItemRepository.selectAllByFofoId(fofoId, query).stream()
1804 
				.map(x -> x.getSerialNumber()).collect(Collectors.toList());
1805 
		LOGGER.info("serialNumber" + serialNumber);
1806 
		LOGGER.info("query" + query);
1807 
 
1808 
		model.addAttribute("response", mvcResponseSender.createResponseString(serialNumber));
1809 
 
1810 
		return "response";
1811 
	}
1812 
 
30039 tejbeer 1813 
	@Autowired
1814 
	private ObjectMapper objectMapper;
1815 
 
1816 
	@RequestMapping(value = "/imei/validate", method = RequestMethod.GET)
30040 tejbeer 1817 
	public String validateImei(HttpServletRequest request, @RequestParam String imei, Model model) throws Exception {
30039 tejbeer 1818 
		boolean isImei = false;
1819 
 
30041 tejbeer 1820 
		try {
30040 tejbeer 1821 
			InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(imei);
30244 tejbeer 1822 
 
30041 tejbeer 1823 
			isImei = true;
30039 tejbeer 1824 
 
30041 tejbeer 1825 
		} catch (Exception e) {
1826 
			isImei = false;
30039 tejbeer 1827 
		}
1828 
 
1829 
		model.addAttribute("response", objectMapper.writeValueAsString(isImei));
1830 
		return "response";
1831 
	}
1832 
 
27867 tejbeer 1833 
}