Subversion Repositories SmartDukaan

Rev

Rev 31238 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 31238 Rev 32067
Line 21... Line 21...
21 
import org.apache.logging.log4j.Logger;
 21 
import org.apache.logging.log4j.Logger;
22 
import org.springframework.beans.factory.annotation.Autowired;
 22 
import org.springframework.beans.factory.annotation.Autowired;
23 
import org.springframework.stereotype.Controller;
 23 
import org.springframework.stereotype.Controller;
24 
import org.springframework.transaction.annotation.Transactional;
 24 
import org.springframework.transaction.annotation.Transactional;
25 
import org.springframework.ui.Model;
 25 
import org.springframework.ui.Model;
- 
 
 26 
import org.springframework.util.StringUtils;
26 
import org.springframework.web.bind.annotation.RequestBody;
 27 
import org.springframework.web.bind.annotation.RequestBody;
27 
import org.springframework.web.bind.annotation.RequestMapping;
 28 
import org.springframework.web.bind.annotation.RequestMapping;
28 
import org.springframework.web.bind.annotation.RequestMethod;
 29 
import org.springframework.web.bind.annotation.RequestMethod;
29 
import org.springframework.web.bind.annotation.RequestParam;
 30 
import org.springframework.web.bind.annotation.RequestParam;
30 
 
 31 
 
Line 35... Line 36...
35 
 
 36 
 
36 
@Controller
 37 
@Controller
37 
@Transactional(rollbackFor = Throwable.class)
 38 
@Transactional(rollbackFor = Throwable.class)
38 
public class HygieneController {
 39 
public class HygieneController {
39 
 
 40 
 
40 
	@Autowired
 41 
    @Autowired
41 
	private FofoOrderRepository fofoOrderRepository;
 42 
    private FofoOrderRepository fofoOrderRepository;
42 
 
 43 
 
43 
	@Autowired
 44 
    @Autowired
44 
	private CustomerAddressRepository customerAddressRepository;
 45 
    private CustomerAddressRepository customerAddressRepository;
45 
 
 46 
 
46 
	@Autowired
 47 
    @Autowired
47 
	private RetailerService retailerService;
 48 
    private RetailerService retailerService;
48 
 
 49 
 
49 
	@Autowired
 50 
    @Autowired
50 
	private FofoOrderItemRepository fofoOrderItemRepository;
 51 
    private FofoOrderItemRepository fofoOrderItemRepository;
51 
 
 52 
 
52 
	@Autowired
 53 
    @Autowired
53 
	private HygieneDataRepository hygieneDataRepository;
 54 
    private HygieneDataRepository hygieneDataRepository;
54 
 
 55 
 
55 
	@Autowired
 56 
    @Autowired
56 
	private ItemRepository itemRepository;
 57 
    private ItemRepository itemRepository;
57 
 
 58 
 
58 
	@Autowired
 59 
    @Autowired
59 
	private MVCResponseSender mvcResponseSender;
 60 
    private MVCResponseSender mvcResponseSender;
60 
 
 61 
 
61 
	private static final Logger LOGGER = LogManager.getLogger(HygieneController.class);
 62 
    private static final Logger LOGGER = LogManager.getLogger(HygieneController.class);
62 
 
 63 
 
63 
	@RequestMapping(value = "/getHygieneData", method = RequestMethod.GET)
 64 
    @RequestMapping(value = "/getHygieneData", method = RequestMethod.GET)
64 
	public String getHygieneData(HttpServletRequest request,
 65 
    public String getHygieneData(HttpServletRequest request, @RequestParam(name = "fofoId", required = false, defaultValue = "0") int fofoId, @RequestParam(name = "date", required = false, defaultValue = "") LocalDateTime date, @RequestParam(name = "mobileNumber", required = false, defaultValue = "") String mobileNumber, Model model) throws ProfitMandiBusinessException {
65 
			@RequestParam(name = "fofoId", required = false, defaultValue = "0") int fofoId,
 66 
        List<HygieneData> hygieneData = new ArrayList<HygieneData>();
66 
			@RequestParam(name = "date", required = false, defaultValue = "") LocalDateTime date, Model model)
 67 
        List<Integer> orderIds = new ArrayList<Integer>();
67 
			throws ProfitMandiBusinessException {
 68 
        if (!StringUtils.isEmpty(mobileNumber)) {
68 
		List<HygieneData> hygieneData = null;
 69 
            orderIds = hygieneDataRepository.selectHygieneByMobile(mobileNumber);
69 
		if (fofoId != 0 && date != null) {
 70 
            hygieneData = hygieneDataRepository.selectByOrderIds(orderIds);
70 
			hygieneData = hygieneDataRepository.selectAllByFofoIdDate(fofoId, date.toLocalDate());
 71 
 
71 
 
 72 
        } else if (fofoId != 0 && date != null) {
72 
		} else if (fofoId != 0) {
 73 
            hygieneData = hygieneDataRepository.selectAllByFofoIdDate(fofoId, date.toLocalDate());
73 
			hygieneData = hygieneDataRepository.selectAllByFofoIdDisposedTimestamp(fofoId);
 74 
            model.addAttribute("date", date);
74 
 
 75 
 
75 
		} else if (date != null) {
 76 
        } else if (fofoId != 0) {
76 
			hygieneData = hygieneDataRepository.selectAllByDate(date.toLocalDate());
 77 
            hygieneData = hygieneDataRepository.selectAllByFofoIdDisposedTimestamp(fofoId);
77 
 
 78 
 
78 
		}
 79 
        } else if (date != null) {
79 
 
 80 
            hygieneData = hygieneDataRepository.selectAllByDate(date.toLocalDate());
80 
		else {
 81 
            model.addAttribute("date", date);
81 
			hygieneData = hygieneDataRepository.selectByDisposedTimestamp();
 82 
 
82 
		}
 83 
        }
83 
 
 84 
 
84 
		LOGGER.info("hygineeDate {}", hygieneData);
 85 
        else {
85 
		if (!hygieneData.isEmpty()) {
 86 
            hygieneData = hygieneDataRepository.selectByDisposedTimestamp();
86 
			List<Integer> orderIds = hygieneData.stream().map(x -> x.getOrderId()).collect(Collectors.toList());
 87 
        }
87 
			Map<Integer, FofoOrder> fofoOrdersMap = this.getfofoOrderByOrderId(orderIds);
 88 
 
88 
			Set<Integer> fofoIds = fofoOrdersMap.values().stream().map(x -> x.getFofoId()).collect(Collectors.toSet());
 89 
        LOGGER.info("hygineeDate {}", hygieneData);
89 
			Map<Integer, CustomerAddress> customerAddress = this.getCustomerAddressByFofoOrder(fofoOrdersMap.values());
 90 
 
90 
			Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
 91 
        LOGGER.info("orderIds {}", orderIds);
91 
 
 92 
 
92 
			Map<Integer, CustomRetailer> partnerAddressMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
 93 
        if (!hygieneData.isEmpty()) {
93 
					.filter(x -> x != null).collect(Collectors.toList()).stream()
 94 
            if (StringUtils.isEmpty(mobileNumber)) {
94 
					.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
 95 
                orderIds = hygieneData.stream().map(x -> x.getOrderId()).collect(Collectors.toList());
95 
 
 96 
            }
96 
			List<HygieneData> filteredHygieneData = new ArrayList<>();
 97 
            Map<Integer, FofoOrder> fofoOrdersMap = new HashMap<Integer, FofoOrder>();
97 
			if (!hygieneData.isEmpty()) {
 98 
 
98 
				List<Integer> filteredOrderIds = fofoOrdersMap.values().stream().map(x -> x.getId())
 99 
            if (!orderIds.isEmpty()) {
99 
						.collect(Collectors.toList());
 100 
                fofoOrdersMap = this.getfofoOrderByOrderId(orderIds);
100 
 
 101 
            }
101 
				filteredHygieneData.addAll(hygieneData.stream().filter(x -> filteredOrderIds.contains(x.getOrderId()))
 102 
            Set<Integer> fofoIds = fofoOrdersMap.values().stream().map(x -> x.getFofoId()).collect(Collectors.toSet());
102 
						.collect(Collectors.toList()));
 103 
            Map<Integer, CustomerAddress> customerAddress = this.getCustomerAddressByFofoOrder(fofoOrdersMap.values());
103 
 
 104 
            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
104 
			}
 105 
 
105 
			model.addAttribute("hygieneData", filteredHygieneData).addAttribute("fofoOrder", fofoOrdersMap)
 106 
            Map<Integer, CustomRetailer> partnerAddressMap = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
106 
					.addAttribute("partnerAddress", partnerAddressMap).addAttribute("customerAddress", customerAddress);
 107 
 
107 
 
 108 
            List<HygieneData> filteredHygieneData = new ArrayList<>();
108 
		} else {
 109 
            if (!hygieneData.isEmpty()) {
109 
			model.addAttribute("hygieneData", hygieneData);
 110 
                List<Integer> filteredOrderIds = fofoOrdersMap.values().stream().map(x -> x.getId()).collect(Collectors.toList());
110 
		}
 111 
 
111 
 
 112 
                filteredHygieneData.addAll(hygieneData.stream().filter(x -> filteredOrderIds.contains(x.getOrderId())).collect(Collectors.toList()));
112 
		return "hygiene";
 113 
 
113 
	}
 114 
            }
114 
 
 115 
            model.addAttribute("hygieneData", filteredHygieneData).addAttribute("fofoOrder", fofoOrdersMap).addAttribute("partnerAddress", partnerAddressMap).addAttribute("customerAddress", customerAddress);
115 
	private Map<Integer, FofoOrder> getfofoOrderByOrderId(List<Integer> fofoOrderIds)
 116 
 
116 
			throws ProfitMandiBusinessException {
 117 
        } else {
117 
		Map<Integer, FofoOrder> fofoOrderMap = new HashMap<>();
 118 
            model.addAttribute("hygieneData", hygieneData);
118 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(fofoOrderIds);
 119 
        }
119 
 
 120 
 
120 
		for (FofoOrder fofoOrder : fofoOrders) {
 121 
        return "hygiene";
121 
			List<FofoOrderItem> fofoItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 122 
    }
122 
 
 123 
 
123 
			boolean smartPhone = false;
 124 
    private Map<Integer, FofoOrder> getfofoOrderByOrderId(List<Integer> fofoOrderIds) throws ProfitMandiBusinessException {
124 
			for (FofoOrderItem fofoItem : fofoItems) {
 125 
        Map<Integer, FofoOrder> fofoOrderMap = new HashMap<>();
125 
				Item orderItem = itemRepository.selectById(fofoItem.getItemId());
 126 
        List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(fofoOrderIds);
126 
				if (orderItem.isSmartPhone()) {
 127 
 
127 
					smartPhone = true;
 128 
        for (FofoOrder fofoOrder : fofoOrders) {
128 
				}
 129 
            List<FofoOrderItem> fofoItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
129 
 
 130 
 
130 
			}
 131 
            boolean smartPhone = false;
131 
 
 132 
            for (FofoOrderItem fofoItem : fofoItems) {
132 
			if (smartPhone) {
 133 
                Item orderItem = itemRepository.selectById(fofoItem.getItemId());
133 
				fofoOrderMap.put(fofoOrder.getId(), fofoOrder);
 134 
                if (orderItem.isSmartPhone()) {
134 
			}
 135 
                    smartPhone = true;
135 
 
 136 
                }
136 
		}
 137 
 
137 
		return fofoOrderMap;
 138 
            }
138 
	}
 139 
 
139 
 
 140 
            if (smartPhone) {
140 
	private Map<Integer, CustomerAddress> getCustomerAddressByFofoOrder(Collection<FofoOrder> fofoOrders)
 141 
                fofoOrderMap.put(fofoOrder.getId(), fofoOrder);
141 
			throws ProfitMandiBusinessException {
 142 
            }
142 
		Map<Integer, CustomerAddress> customerAddressMap = new HashMap<>();
 143 
 
143 
		for (FofoOrder fofoOrder : fofoOrders) {
 144 
        }
144 
			CustomerAddress ca = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 145 
        return fofoOrderMap;
145 
			customerAddressMap.put(fofoOrder.getCustomerAddressId(), ca);
 146 
    }
146 
		}
 147 
 
147 
		return customerAddressMap;
 148 
    private Map<Integer, CustomerAddress> getCustomerAddressByFofoOrder(Collection<FofoOrder> fofoOrders) throws ProfitMandiBusinessException {
148 
	}
 149 
        Map<Integer, CustomerAddress> customerAddressMap = new HashMap<>();
149 
 
 150 
        for (FofoOrder fofoOrder : fofoOrders) {
150 
	@RequestMapping(value = "/getFetchHygieneData", method = RequestMethod.GET)
 151 
            CustomerAddress ca = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
151 
	public String getFetchHygieneData(HttpServletRequest request, Model model) throws Exception {
 152 
            customerAddressMap.put(fofoOrder.getCustomerAddressId(), ca);
152 
 
 153 
        }
153 
		FofoOrder fofoOrder = null;
 154 
        return customerAddressMap;
154 
		CustomRetailer customRetailer = null;
 155 
    }
155 
		CustomerAddress customerAddress = null;
 156 
 
156 
		List<FofoOrderItem> fofoOrderItems = null;
 157 
    @RequestMapping(value = "/getFetchHygieneData", method = RequestMethod.GET)
157 
 
 158 
    public String getFetchHygieneData(HttpServletRequest request, Model model) throws Exception {
158 
		List<HygieneData> hygiene = hygieneDataRepository.selectAllByDisposedTimestamp();
 159 
 
159 
 
 160 
        FofoOrder fofoOrder = null;
160 
		hygiene = hygiene.stream().filter(x -> x.getNextTimestamp().isBefore(LocalDateTime.now()))
 161 
        CustomRetailer customRetailer = null;
161 
				.collect(Collectors.toList());
 162 
        CustomerAddress customerAddress = null;
162 
 
 163 
        List<FofoOrderItem> fofoOrderItems = null;
163 
		if (!hygiene.isEmpty()) {
 164 
 
164 
			fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.get(0).getOrderId());
 165 
        List<HygieneData> hygiene = hygieneDataRepository.selectAllByDisposedTimestamp();
165 
			customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
 166 
 
166 
			customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 167 
        hygiene = hygiene.stream().filter(x -> x.getNextTimestamp().isBefore(LocalDateTime.now())).collect(Collectors.toList());
167 
			fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 168 
 
168 
 
 169 
        if (!hygiene.isEmpty()) {
169 
		} else {
 170 
            fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.get(0).getOrderId());
170 
 
 171 
            customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
171 
			HygieneData hygieneData = hygieneDataRepository.selectFirstByDisposedTimestamp();
 172 
            customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
172 
			if (hygieneData != null) {
 173 
            fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
173 
				fofoOrder = fofoOrderRepository.selectByOrderId(hygieneData.getOrderId());
 174 
 
174 
				customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 175 
        } else {
175 
 
 176 
 
176 
				customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
 177 
            HygieneData hygieneData = hygieneDataRepository.selectFirstByDisposedTimestamp();
177 
 
 178 
            if (hygieneData != null) {
178 
				fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 179 
                fofoOrder = fofoOrderRepository.selectByOrderId(hygieneData.getOrderId());
179 
 
 180 
                customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
180 
				LOGGER.info("hygieneData" + hygieneData);
 181 
 
181 
				LOGGER.info("fofoOrder" + fofoOrder);
 182 
                customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
182 
				LOGGER.info("customRetailer" + customRetailer);
 183 
 
183 
				LOGGER.info("customerAddress" + customerAddress);
 184 
                fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
184 
 
 185 
 
185 
			}
 186 
                LOGGER.info("hygieneData" + hygieneData);
186 
 
 187 
                LOGGER.info("fofoOrder" + fofoOrder);
187 
		}
 188 
                LOGGER.info("customRetailer" + customRetailer);
188 
 
 189 
                LOGGER.info("customerAddress" + customerAddress);
189 
		model.addAttribute("fofoOrder", fofoOrder);
 190 
 
190 
		model.addAttribute("customRetailer", customRetailer);
 191 
            }
191 
		model.addAttribute("customerAddress", customerAddress);
 192 
 
192 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
 193 
        }
193 
 
 194 
 
194 
		return "hygiene-modal";
 195 
        model.addAttribute("fofoOrder", fofoOrder);
195 
	}
 196 
        model.addAttribute("customRetailer", customRetailer);
196 
 
 197 
        model.addAttribute("customerAddress", customerAddress);
197 
	@RequestMapping(value = "/getFetchHygieneDataByOrderId", method = RequestMethod.GET)
 198 
        model.addAttribute("fofoOrderItems", fofoOrderItems);
198 
	public String getFetchHygieneDataByOrderId(HttpServletRequest request, @RequestParam int orderId, Model model)
 199 
 
199 
			throws Exception {
 200 
        return "hygiene-modal";
200 
 
 201 
    }
201 
		FofoOrder fofoOrder = null;
 202 
 
202 
		CustomRetailer customRetailer = null;
 203 
    @RequestMapping(value = "/getFetchHygieneDataByOrderId", method = RequestMethod.GET)
203 
		CustomerAddress customerAddress = null;
 204 
    public String getFetchHygieneDataByOrderId(HttpServletRequest request, @RequestParam int orderId, Model model) throws Exception {
204 
		List<FofoOrderItem> fofoOrderItems = null;
 205 
 
205 
 
 206 
        FofoOrder fofoOrder = null;
206 
		HygieneData hygiene = hygieneDataRepository.selectById(orderId);
 207 
        CustomRetailer customRetailer = null;
207 
 
 208 
        CustomerAddress customerAddress = null;
208 
		fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.getOrderId());
 209 
        List<FofoOrderItem> fofoOrderItems = null;
209 
		customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 210 
 
210 
 
 211 
        HygieneData hygiene = hygieneDataRepository.selectById(orderId);
211 
		customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
 212 
 
212 
 
 213 
        fofoOrder = fofoOrderRepository.selectByOrderId(hygiene.getOrderId());
213 
		fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 214 
        customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
214 
 
 215 
 
215 
		LOGGER.info("hygieneData" + hygiene);
 216 
        customRetailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
216 
		LOGGER.info("fofoOrder" + fofoOrder);
 217 
 
217 
		LOGGER.info("customRetailer" + customRetailer);
 218 
        fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
218 
		LOGGER.info("customerAddress" + customerAddress);
 219 
 
219 
 
 220 
        LOGGER.info("hygieneData" + hygiene);
220 
		model.addAttribute("fofoOrder", fofoOrder);
 221 
        LOGGER.info("fofoOrder" + fofoOrder);
221 
		model.addAttribute("customRetailer", customRetailer);
 222 
        LOGGER.info("customRetailer" + customRetailer);
222 
		model.addAttribute("customerAddress", customerAddress);
 223 
        LOGGER.info("customerAddress" + customerAddress);
223 
		model.addAttribute("fofoOrderItems", fofoOrderItems);
 224 
 
224 
 
 225 
        model.addAttribute("fofoOrder", fofoOrder);
225 
		return "hygiene-modal";
 226 
        model.addAttribute("customRetailer", customRetailer);
226 
	}
 227 
        model.addAttribute("customerAddress", customerAddress);
227 
 
 228 
        model.addAttribute("fofoOrderItems", fofoOrderItems);
228 
	@RequestMapping(value = "/hygieneData", method = RequestMethod.POST)
 229 
 
229 
	public String HygieneData(HttpServletRequest request, @RequestBody HygieneDataModel hygieneDataModel, Model model)
 230 
        return "hygiene-modal";
230 
			throws Exception {
 231 
    }
231 
		HygieneData hygieneData = hygieneDataRepository.selectById(hygieneDataModel.getOrderId());
 232 
 
232 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(hygieneDataModel.getOrderId());
 233 
    @RequestMapping(value = "/hygieneData", method = RequestMethod.POST)
233 
		LocalDateTime hygieneDateTime = hygieneData.getCreatedTimestamp().toLocalDate().atStartOfDay();
 234 
    public String HygieneData(HttpServletRequest request, @RequestBody HygieneDataModel hygieneDataModel, Model model) throws Exception {
234 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 235 
        HygieneData hygieneData = hygieneDataRepository.selectById(hygieneDataModel.getOrderId());
235 
		List<CustomerAddress> customerAddresses = customerAddressRepository
 236 
        FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(hygieneDataModel.getOrderId());
236 
				.selectByMobileNumber(customerAddress.getPhoneNumber());
 237 
        LocalDateTime hygieneDateTime = hygieneData.getCreatedTimestamp().toLocalDate().atStartOfDay();
237 
		LOGGER.info("Fofo id {}, Date Range = {}, Customer Address Ids  {}", fofoOrder.getFofoId(),
 238 
        CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
238 
				DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)),
 239 
        List<CustomerAddress> customerAddresses = customerAddressRepository.selectByMobileNumber(customerAddress.getPhoneNumber());
239 
				customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));
 240 
        LOGGER.info("Fofo id {}, Date Range = {}, Customer Address Ids  {}", fofoOrder.getFofoId(), DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)), customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));
240 
		List<FofoOrder> fofoOrders = fofoOrderRepository.selectByCustomerAddressIds(fofoOrder.getFofoId(),
 241 
        List<FofoOrder> fofoOrders = fofoOrderRepository.selectByCustomerAddressIds(fofoOrder.getFofoId(), DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)), customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));
241 
				DateRangeModel.of(hygieneDateTime, hygieneDateTime.plusDays(1)),
 242 
        LOGGER.info("Order Size - {}", fofoOrders.size());
242 
				customerAddresses.stream().map(x -> x.getId()).collect(Collectors.toList()));
 243 
        for (FofoOrder fo : fofoOrders) {
243 
		LOGGER.info("Order Size - {}", fofoOrders.size());
 244 
            int count = 0;
244 
		for (FofoOrder fo : fofoOrders) {
 245 
            LOGGER.info("Order Id - {}", fo.getId());
245 
			LOGGER.info("Order Id - {}", fo.getId());
 246 
            hygieneData = hygieneDataRepository.selectById(fo.getId());
246 
			hygieneData = hygieneDataRepository.selectById(fo.getId());
 247 
            if (hygieneData == null)
247 
			if (hygieneData == null)
 248 
                continue;
248 
				continue;
 249 
            if (hygieneDataModel.getScheduleTime() != null) {
249 
			if (hygieneDataModel.getScheduleTime() != null) {
 250 
                hygieneData.setStatus(hygieneDataModel.getStatus());
250 
				hygieneData.setStatus(hygieneDataModel.getStatus());
 251 
                hygieneData.setRemark(hygieneDataModel.getRemark());
251 
				hygieneData.setRemark(hygieneDataModel.getRemark());
 252 
                hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());
252 
				hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());
 253 
                hygieneData.setNextTimestamp(hygieneDataModel.getScheduleTime());
253 
				hygieneData.setNextTimestamp(hygieneDataModel.getScheduleTime());
 254 
                hygieneDataRepository.persist(hygieneData);
254 
				hygieneDataRepository.persist(hygieneData);
 255 
            } else {
255 
			} else {
 256 
                hygieneData.setStatus(hygieneDataModel.getStatus());
256 
				hygieneData.setStatus(hygieneDataModel.getStatus());
 257 
                hygieneData.setRemark(hygieneDataModel.getRemark());
257 
				hygieneData.setRemark(hygieneDataModel.getRemark());
 258 
                hygieneData.setRating(hygieneDataModel.getRating());
258 
				hygieneData.setRating(hygieneDataModel.getRating());
 259 
                hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());
259 
				hygieneData.setHygieneRating(hygieneDataModel.getHygieneRating());
 260 
                hygieneData.setDOP(hygieneDataModel.getDOP());
260 
				hygieneData.setDOP(hygieneDataModel.getDOP());
 261 
                hygieneData.setFeedback(hygieneDataModel.getFeedback());
261 
				hygieneData.setFeedback(hygieneDataModel.getFeedback());
 262 
                hygieneData.setQuesPhone(hygieneDataModel.getQuesPhone());
262 
				hygieneData.setQuesPhone(hygieneDataModel.getQuesPhone());
 263 
                hygieneData.setQuesInformation(hygieneDataModel.getQuesInformation());
263 
				hygieneData.setQuesInformation(hygieneDataModel.getQuesInformation());
 264 
                hygieneData.setQuesInvoice(hygieneDataModel.getQuesInvoice());
264 
				hygieneData.setQuesInvoice(hygieneDataModel.getQuesInvoice());
 265 
                hygieneData.setDisposedTimestamp(LocalDateTime.now());
265 
				hygieneData.setDisposedTimestamp(LocalDateTime.now());
 266 
                hygieneData.setNextTimestamp(null);
266 
				hygieneData.setNextTimestamp(null);
 267 
                hygieneDataRepository.persist(hygieneData);
267 
				hygieneDataRepository.persist(hygieneData);
 268 
            }
268 
			}
 269 
 
269 
		}
 270 
            count = hygieneData.getCallCount();
- 
 
 271 
            count = count + 1;
- 
 
 272 
            hygieneData.setCallCount(count);
- 
 
 273 
        }
270 
 
 274 
 
271 
		model.addAttribute("response1", mvcResponseSender.createResponseString(true));
 275 
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
272 
 
 276 
 
273 
		return "response";
 277 
        return "response";
274 
	}
 278 
    }
275 
 
 279 
 
276 
}
 280 
}