Subversion Repositories SmartDukaan

Rev

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