Subversion Repositories SmartDukaan

import java.io.IOException;

import java.time.ZoneOffset;

import java.util.Iterator;

import java.util.Optional;

import javax.mail.MessagingException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import com.spice.profitmandi.common.model.NotifyItemIdModel;

import com.spice.profitmandi.common.model.NotifyOrderIdModel;

import com.spice.profitmandi.common.model.NotifyOrderModel;

import com.spice.profitmandi.dao.entity.dtr.NotificationCampaigns;

import com.spice.profitmandi.dao.entity.fofo.FofoStore;

import com.spice.profitmandi.dao.entity.transaction.NotifyColorChange;

import com.spice.profitmandi.dao.entity.transaction.NotifyItem;

import com.spice.profitmandi.dao.entity.transaction.NotifyOrder;

import com.spice.profitmandi.dao.repository.dtr.Mongo;

import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;

import com.spice.profitmandi.dao.repository.inventory.NotifyStatus;

import com.spice.profitmandi.dao.repository.transaction.NotifyColorChangeRepository;

import com.spice.profitmandi.dao.repository.transaction.NotifyItemRepository;

import com.spice.profitmandi.dao.repository.transaction.NotifyOrderRespository;

	private NotifyItemRepository notifyItemRespository;

	@Autowired

	@Autowired

	private NotifyItemRepository notifyItemRepository;

	@Autowired

	private NotifyColorChangeRepository notifyColorChangeRepository;

	@Autowired

	private NotifyOrderRespository notifyOrderRespository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	JavaMailSender mailSender;

	@Autowired

	private Mongo mongoClient;

			}

			List<NotifyOrder> notify = notifyOrderRespository.selectByorderIds(orderIds);

			for (NotifyOrder notifyOrder : notify) {

				List<NotifyItem> notifyItems = notifyItemRepository.selectByNotifyId(notifyOrder.getNotifyId());

				Iterator<NotifyItem> notifyItemsIterator = notifyItems.iterator();

				while(notifyItemsIterator.hasNext()) {

					NotifyItem notifyItem = notifyItemsIterator.next();

					if (LocalDateTime.now().isAfter(notifyItem.getResponseTime())) {

						notifyItemsIterator.remove();

					}

				}

				if(notifyItems.size() == 0) {

					if(NotifyStatus.pending== notifyOrder.getStatus() ) {

					notifyOrder.setStatus(NotifyStatus.rejected);

					}

				}

			}

			Map<Integer, Optional<NotifyOrder>> notifyOrders = notifyOrderRespository.selectByorderIds(orderIds)

					.stream().collect(Collectors.groupingBy(NotifyOrder::getOrderId,

							Collectors.maxBy((x1, x2) -> x1.getId() - x2.getId())));

			Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()

					.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

			List<com.spice.profitmandi.dao.entity.transaction.Order> pendingPaymentorder = orderRepository

					.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusDays(30), LocalDateTime.now(),

							OrderStatus.PAYMENT_PENDING);

			List<com.spice.profitmandi.dao.entity.transaction.Order> failedPaymentorder = orderRepository

					.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusDays(30), LocalDateTime.now(),

							OrderStatus.PAYMENT_FAILED);

			pendingPaymentorder.addAll(failedPaymentorder);

			model.addAttribute("inProcessorder", inProcessorder);

			model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

			model.addAttribute("pendingPaymentorder", pendingPaymentorder);

			model.addAttribute("latestNotifyOrders", notifyOrders);

		} else {

			model.addAttribute("inProcessorder", inProcessorder);

		}

	@RequestMapping(value = "/getNotifyItemColor", method = RequestMethod.GET)

	public String getNotifyItemColor(HttpServletRequest request, @RequestParam int catalogItemId,

			@RequestParam int itemId, Model model) throws ProfitMandiBusinessException {

		List<Item> availableColorItem = itemRepository.selectAllByCatalogItemId(catalogItemId);

		List<Order> inProcessselectedOrder = orderRepository.selectByItemIdOrderStatus(itemId,

				OrderStatus.SUBMITTED_FOR_PROCESSING);

		List<Integer> retailerIds = new ArrayList<>();

		for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessselectedOrder) {

			retailerIds.add(order.getRetailerId());

		}

		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()

				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

		LOGGER.info("item" + availableColorItem);

		LOGGER.info("inProcessselectedOrder" + inProcessselectedOrder);

		model.addAttribute("item", availableColorItem);

		model.addAttribute("inProcessselectedOrder", inProcessselectedOrder);

		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

		return "notify-order-modal";

	}

	@RequestMapping(value = "/notifyOrder", method = RequestMethod.POST)

	public String NotifyOrder(HttpServletRequest request, @RequestBody NotifyOrderModel notifyOrderModel, Model model)

			throws Exception {

		com.spice.profitmandi.dao.entity.transaction.NotifyItem notifyItem = null;

		List<Integer> orderIds = new ArrayList<>();

		NotifyColorChange notifytimestamp = new NotifyColorChange();

		notifytimestamp.setCreated(LocalDateTime.now());

		notifyColorChangeRepository.persist(notifytimestamp);

		for (NotifyItemIdModel itemid : notifyOrderModel.getItemIds()) {

			notifyItem = new com.spice.profitmandi.dao.entity.transaction.NotifyItem();

			notifyItem.setItemId(itemid.getItemId());

			notifyItem.setResponseTime(itemid.getResponseTime());

			notifyItem.setProcuredDate(itemid.getProcuredTime());

			notifyItem.setNotifyColorchangeId(notifytimestamp.getId());

			notifyItemRepository.persist(notifyItem);

			LOGGER.info("notifyItem" + notifyItem);

		}

		for (NotifyOrderIdModel st : notifyOrderModel.getOrderIds()) {

			List<NotifyOrder> existingOrder = notifyOrderRespository.selectByOrder(st.getOrderId());

			if(!existingOrder.isEmpty()) {

				LOGGER.info("existingOrder" + existingOrder);

				for(NotifyOrder notifyOrder: existingOrder) {

					if(NotifyStatus.pending == notifyOrder.getStatus()) {

					 notifyOrder.setStatus(NotifyStatus.rejected);

				}

				}	

			}

			NotifyOrder orderStatus = new NotifyOrder();

			orderStatus.setOrderId(st.getOrderId());

			orderStatus.setNotifyId(notifytimestamp.getId());

			orderStatus.setItemId(st.getOlditemId());

			Order id = orderRepository.selectById(st.getOrderId());

			orderStatus.setFofoId(id.getRetailerId());

			orderStatus.setStatus(NotifyStatus.pending);

			notifyOrderRespository.persist(orderStatus);

			LOGGER.info("itemStatus" + orderStatus);

			orderIds.add(st.getOrderId());

		}

		LOGGER.info("orderIds" + orderIds);

		List<Order> orders = orderRepository.selectByOrderIds(orderIds);

		for (Order order : orders) {

			LOGGER.info("order" + order.getId());

			Item item = itemRepository.selectById(order.getLineItem().getItemId());

			List<String> color = new ArrayList<>();

			for (NotifyItemIdModel itemid : notifyOrderModel.getItemIds()) {

				Item newItem = itemRepository.selectById(itemid.getItemId());

				color.add(newItem.getColor());

			}

			LOGGER.info("message" + item.getItemDescriptionNoColor() + "/" + item.getColor()

					+ "is currently not in stock with Brand/ND. The current availability is in" + color);

			  NotificationCampaigns notification = new NotificationCampaigns();

			  notification.setName("Notify Partner");

			  notification.setTitle("Notify Partner");

			  notification.setMessage(item.getItemDescriptionNoColor() +"/"+

			  item.getColor() +

			  "is currently not in stock with Brand/ND. The current availability is in" +

			  color); notification.setType("Url");

			  notification.setUrl("http://app.profitmandi.com/pages/home/notifyOrder");

			  notification.

			  setSql("SELECT distinct d1.user_id from devices d1 left join devices d2 on" +

			  "(d1.imeinumber = d2.imeinumber and d1.created < d2.created) " +

			  " where d2.id is null and d1.user_id = " +

			  userAccountRepository.selectUserIdByRetailerId(order. getRetailerId()));

			  notification.setExpiresat(LocalDateTime.now().plusDays(2).

			  toEpochSecond(ZoneOffset.UTC) * 1000); 

			  notification.setStatus("active");

			  notification.setSmsprocessed(0); notification.setNotification_processed(0);

			  notification.setNotification_type("GENERAL_NOTIFICATION");

			  mongoClient.persistNotificationCmpInfo(notification);

		}

		model.addAttribute("response", mvcResponseSender.createResponseString(true));

		return "response";

	}

	private void sendMailOfHtmlFomat(String email, String messageText, String subject)

			throws MessagingException, ProfitMandiBusinessException, IOException {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message);

		helper.setSubject(subject);

		helper.setText(messageText, true);

		helper.setTo(email);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	/*

	 * private String getMessage(List<NotifyOrderModel> notifyOrderModels, Order

	 * order) throws ProfitMandiBusinessException {

	 * 

	 * StringBuilder sb = new StringBuilder(); sb.

	 * append("<html><body><p>Notify Partner</p><p>Which have order out stock following model:-</p>"

	 * + "<div>" + order.getLineItem().getItem().getItemDescription() +

	 * "</div> <div>choose the model from following:- </div><br/><table style='border:1px solid black ;padding: 5px';>"

	 * ); sb.append("<tbody>\n" + "	    				<tr>\n" +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Color</th>\n"

	 * +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Procured Time</th>\n"

	 * +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Response Time</th>\n"

	 * + "	    				</tr>"); for (NotifyOrderModel notifyOrderModel :

	 * notifyOrderModels) { Item item =

	 * itemRepository.selectById(notifyOrderModel.getItemId()); sb.append("<tr>");

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * item.getColor() + "</td>");

	 * 

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * notifyOrderModel.getFormattedProcuredTime() + "</td>");

	 * 

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * notifyOrderModel.getFormattedResponseTime() + "</td>");

	 * 

	 * sb.append("</tr>"); }

	 * 

	 * sb.append("</tbody></table></body></html>"); return sb.toString(); }

	 */

	@RequestMapping(value = "/getAllNotifyOrder", method = RequestMethod.GET)

	public String getAllNotifyOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		List<NotifyOrder> notifyOrders= null;

		List<com.spice.profitmandi.dao.entity.transaction.Order> inProcessorder = orderRepository

				.selectAllOrderBeforeTwoDaysByStatus(OrderStatus.SUBMITTED_FOR_PROCESSING);

		List<Integer> orderIds = new ArrayList<>();

		 if(!inProcessorder.isEmpty()) {

			for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessorder) {

				orderIds.add(order.getId());

			}	

		 notifyOrders = notifyOrderRespository.selectByorderIds(orderIds);

		Set<Integer> oldItemIds = new HashSet<>();

		List<Integer> fofoIds = new ArrayList<>();

		List<Integer> notifyIds = new ArrayList<>();

		if (!notifyOrders.isEmpty()) {

			for (NotifyOrder notifyOrder : notifyOrders) {

				List<NotifyItem> notifyItems = notifyItemRepository.selectByNotifyId(notifyOrder.getNotifyId());

				Iterator<NotifyItem> notifyItemsIterator = notifyItems.iterator();

				while(notifyItemsIterator.hasNext()) {

					NotifyItem notifyItem = notifyItemsIterator.next();

					if (LocalDateTime.now().isAfter(notifyItem.getResponseTime())) {

						notifyItemsIterator.remove();

					}

				}

				if(notifyItems.size() == 0) {

					if(NotifyStatus.pending == notifyOrder.getStatus()) {

					notifyOrder.setStatus(NotifyStatus.rejected);

					LOGGER.info("existingOrder" + notifyOrder);

					}

				}

				oldItemIds.add(notifyOrder.getItemId());

				fofoIds.add(notifyOrder.getFofoId());

				notifyIds.add(notifyOrder.getNotifyId());

			}

			List<NotifyColorChange> notifyColorChanges = notifyColorChangeRepository.selectByNotifyId(notifyIds);

			Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = this.notifyOrdersToNotifyId(notifyColorChanges);

			Map<Integer, CustomRetailer> fofoIdsAndRetailerName = retailerService.getFofoRetailers(fofoIds);

			Map<Integer, String> itemdescription = inventoryService.getItemIdDescriptionMap(oldItemIds);

			model.addAttribute("notifyOrders", notifyOrders);

			model.addAttribute("notifyIdNotifyColorMap", notifyIdNotifyColorMap);

			model.addAttribute("itemdescription", itemdescription);

			model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);

		} else {

			model.addAttribute("notifyOrders", notifyOrders);

		}}

		 else {

			 model.addAttribute("notifyOrders", notifyOrders);

		 }

		return "notify_order";

	}

	private Map<Integer, NotifyColorChange> notifyOrdersToNotifyId(List<NotifyColorChange> notifyColorChanges) {

		Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = new HashMap<>();

		for (NotifyColorChange notifyColorChange : notifyColorChanges) {

			notifyIdNotifyColorMap.put(notifyColorChange.getId(), notifyColorChange);

		}

		return notifyIdNotifyColorMap;

	}