Subversion Repositories SmartDukaan

Rev

Rev 23883 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 23883 Rev 23984
Line 39... Line 39...
39 
import com.spice.profitmandi.dao.entity.nonbillable.PartnerCurrentInventorySnapshot;
 39 
import com.spice.profitmandi.dao.entity.nonbillable.PartnerCurrentInventorySnapshot;
40 
import com.spice.profitmandi.dao.entity.nonbillable.ScanOutPartnerItem;
 40 
import com.spice.profitmandi.dao.entity.nonbillable.ScanOutPartnerItem;
41 
import com.spice.profitmandi.dao.entity.nonbillable.Vendor;
 41 
import com.spice.profitmandi.dao.entity.nonbillable.Vendor;
42 
import com.spice.profitmandi.dao.entity.nonbillable.Warehouse;
 42 
import com.spice.profitmandi.dao.entity.nonbillable.Warehouse;
43 
import com.spice.profitmandi.dao.entity.user.Address;
 43 
import com.spice.profitmandi.dao.entity.user.Address;
- 
 
 44 
import com.spice.profitmandi.dao.enumuration.dtr.RoleType;
44 
import com.spice.profitmandi.dao.enumuration.nonbillable.InstructionItemStatus;
 45 
import com.spice.profitmandi.dao.enumuration.nonbillable.InstructionItemStatus;
45 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
 46 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
- 
 
 47 
import com.spice.profitmandi.dao.repository.dtr.RoleRepository;
46 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
 48 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
- 
 
 49 
import com.spice.profitmandi.dao.repository.dtr.UserRoleRepository;
47 
import com.spice.profitmandi.dao.repository.nonbillable.AdminCurrentInventorySnapshotRepository;
 50 
import com.spice.profitmandi.dao.repository.nonbillable.AdminCurrentInventorySnapshotRepository;
48 
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteDetailRepository;
 51 
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteDetailRepository;
49 
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteRepository;
 52 
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteRepository;
50 
import com.spice.profitmandi.dao.repository.nonbillable.AdminInventoryItemRepository;
 53 
import com.spice.profitmandi.dao.repository.nonbillable.AdminInventoryItemRepository;
51 
import com.spice.profitmandi.dao.repository.nonbillable.InstructionItemDetailRepository;
 54 
import com.spice.profitmandi.dao.repository.nonbillable.InstructionItemDetailRepository;
Line 58... Line 61...
58 
import com.spice.profitmandi.dao.repository.nonbillable.VendorRepository;
 61 
import com.spice.profitmandi.dao.repository.nonbillable.VendorRepository;
59 
import com.spice.profitmandi.dao.repository.nonbillable.WarehouseRepository;
 62 
import com.spice.profitmandi.dao.repository.nonbillable.WarehouseRepository;
60 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
 63 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
61 
import com.spice.profitmandi.service.nonbillable.InventoryService;
 64 
import com.spice.profitmandi.service.nonbillable.InventoryService;
62 
import com.spice.profitmandi.service.user.RetailerService;
 65 
import com.spice.profitmandi.service.user.RetailerService;
- 
 
 66 
import com.spice.profitmandi.service.user.UserService;
63 
import com.spice.profitmandi.web.model.LoginDetails;
 67 
import com.spice.profitmandi.web.model.LoginDetails;
64 
import com.spice.profitmandi.web.util.CookiesProcessor;
 68 
import com.spice.profitmandi.web.util.CookiesProcessor;
65 
 
 69 
 
66 
@Controller
 70 
@Controller
67 
@Transactional
 71 
@Transactional
68 
public class ItemController {
 72 
public class ItemController {
69
73 
 
70 
	private static final Logger LOGGER = LogManager.getLogger(ItemController.class);
 74 
	private static final Logger LOGGER = LogManager.getLogger(ItemController.class);
71
75 
 
72 
	@Autowired
 76 
	@Autowired
73 
	@Qualifier("nonbillableItemRepository")
 77 
	@Qualifier("nonbillableItemRepository")
74 
	private ItemRepository itemRepository;
 78 
	private ItemRepository itemRepository;
75
79 
 
76 
	@Autowired
 80 
	@Autowired
77 
	@Qualifier("nonbillableInventoryService")
 81 
	@Qualifier("nonbillableInventoryService")
78 
	private InventoryService inventoryService;
 82 
	private InventoryService inventoryService;
- 
 
 83 
	@Autowired
- 
 
 84 
	private RoleRepository roleRepository;
79
85 
	@Autowired
- 
 
 86 
	private UserService userService;
80 
	@Autowired
 87 
	@Autowired
81 
	private AdminCurrentInventorySnapshotRepository adminCurrentInventorySnapshotRepository;
 88 
	private AdminCurrentInventorySnapshotRepository adminCurrentInventorySnapshotRepository;
82
89 
 
83 
	@Autowired
 90 
	@Autowired
84 
	private AdminInventoryItemRepository adminInventoryItemRepository;
 91 
	private AdminInventoryItemRepository adminInventoryItemRepository;
85
92 
 
86 
	@Autowired
 93 
	@Autowired
87 
	private PartnerCurrentInventorySnapshotRepository partnerCurrentInventorySnapshotRepository;
 94 
	private PartnerCurrentInventorySnapshotRepository partnerCurrentInventorySnapshotRepository;
88
95 
 
89 
	@Autowired
 96 
	@Autowired
90 
	private VendorRepository vendorRepository;
 97 
	private VendorRepository vendorRepository;
91
98 
 
92 
	@Autowired
 99 
	@Autowired
93 
	private WarehouseRepository warehouseRepository;
 100 
	private WarehouseRepository warehouseRepository;
94
101 
 
95 
	@Autowired
 102 
	@Autowired
96 
	private RetailerService retailerService;
 103 
	private RetailerService retailerService;
97
104 
 
98 
	@Autowired
 105 
	@Autowired
99 
	@Qualifier(value = "userRepository")
 106 
	@Qualifier(value = "userRepository")
100 
	private UserRepository userRepository;
 107 
	private UserRepository userRepository;
101
108 
	@Autowired
- 
 
 109 
	private UserRoleRepository userRoleRepository;
102 
	@Autowired
 110 
	@Autowired
103 
	private UserWarehouseRepository userWarehouseRepository;
 111 
	private UserWarehouseRepository userWarehouseRepository;
104
112 
 
105 
	@Autowired
 113 
	@Autowired
106 
	private AdminDeliveryNoteRepository adminDeliveryNoteRepository;
 114 
	private AdminDeliveryNoteRepository adminDeliveryNoteRepository;
107 
 
 115 
 
108 
	@Autowired
 116 
	@Autowired
109 
    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
 117 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
110 
 
 118 
 
111 
	@Autowired
 119 
	@Autowired
112 
    private AddressRepository addressRepository;
 120 
	private AddressRepository addressRepository;
113 
 
 121 
 
114 
	@Autowired
 122 
	@Autowired
115 
    private PartnerInventoryItemRepository partnerInventoryItemRepository;
 123 
	private PartnerInventoryItemRepository partnerInventoryItemRepository;
116 
 
 124 
 
117 
	@Autowired
 125 
	@Autowired
118 
    private ScanOutPartnerItemRepository scanOutPartnerItemRepository;
 126 
	private ScanOutPartnerItemRepository scanOutPartnerItemRepository;
119
127 
 
120 
	@Autowired
 128 
	@Autowired
121 
	private InstructionItemRepository instructionItemRepository;
 129 
	private InstructionItemRepository instructionItemRepository;
122
130 
 
123 
	@Autowired
 131 
	@Autowired
124 
	private InstructionItemDetailRepository instructionItemDetailRepository;
 132 
	private InstructionItemDetailRepository instructionItemDetailRepository;
125
133 
 
126 
	@Autowired
 134 
	@Autowired
127 
	private AdminDeliveryNoteDetailRepository adminDeliveryNoteDetailRepository;
 135 
	private AdminDeliveryNoteDetailRepository adminDeliveryNoteDetailRepository;
128
136 
 
129 
	@Autowired
 137 
	@Autowired
130 
	private CookiesProcessor cookiesProcessor;
 138 
	private CookiesProcessor cookiesProcessor;
131
139 
 
132 
	private Map<Integer, String> itemsToVendorIdNameMap(List<Item> items){
 140 
	private Map<Integer, String> itemsToVendorIdNameMap(List<Item> items) {
133 
		Map<Integer, String> vendorIdNameMap = new HashMap<>();
 141 
		Map<Integer, String> vendorIdNameMap = new HashMap<>();
134 
		if(items.isEmpty()) {
 142 
		if (items.isEmpty()) {
135 
			return vendorIdNameMap;
 143 
			return vendorIdNameMap;
136 
		}
 144 
		}
137 
		Set<Integer> vendorIds = new HashSet<>();
 145 
		Set<Integer> vendorIds = new HashSet<>();
138 
		for(Item item : items) {
 146 
		for (Item item : items) {
139 
			vendorIds.add(item.getVendorId());
 147 
			vendorIds.add(item.getVendorId());
140 
		}
 148 
		}
141
149 
 
142 
		List<Vendor> vendors = vendorRepository.selectByIds(vendorIds);
 150 
		List<Vendor> vendors = vendorRepository.selectByIds(vendorIds);
143 
		for(Vendor vendor : vendors) {
 151 
		for (Vendor vendor : vendors) {
144 
			vendorIdNameMap.put(vendor.getId(), vendor.getName());
 152 
			vendorIdNameMap.put(vendor.getId(), vendor.getName());
145 
		}
 153 
		}
146 
		return vendorIdNameMap;
 154 
		return vendorIdNameMap;
147 
	}
 155 
	}
148
156 
 
149 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdDescriptionMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
 157 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdDescriptionMap(
- 
 
 158 
			List<AdminCurrentInventorySnapshot> currentInventorySnapshots) {
150 
		if(currentInventorySnapshots.isEmpty()) {
 159 
		if (currentInventorySnapshots.isEmpty()) {
151 
			return new HashMap<>();
 160 
			return new HashMap<>();
152 
		}
 161 
		}
153 
		Set<Integer> itemIds = new HashSet<>();
 162 
		Set<Integer> itemIds = new HashSet<>();
154 
		for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
 163 
		for (AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
155 
			itemIds.add(currentInventorySnapshot.getItemId());
 164 
			itemIds.add(currentInventorySnapshot.getItemId());
156 
		}
 165 
		}
157 
		return itemIdDescriptionMap(itemIds);
 166 
		return itemIdDescriptionMap(itemIds);
158 
	}
 167 
	}
159
168 
 
160 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdTypeMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
 169 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdTypeMap(
- 
 
 170 
			List<AdminCurrentInventorySnapshot> currentInventorySnapshots) {
161 
		if(currentInventorySnapshots.isEmpty()) {
 171 
		if (currentInventorySnapshots.isEmpty()) {
162 
			return new HashMap<>();
 172 
			return new HashMap<>();
163 
		}
 173 
		}
164 
		Set<Integer> itemIds = new HashSet<>();
 174 
		Set<Integer> itemIds = new HashSet<>();
165 
		for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
 175 
		for (AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
166 
			itemIds.add(currentInventorySnapshot.getItemId());
 176 
			itemIds.add(currentInventorySnapshot.getItemId());
167 
		}
 177 
		}
168 
		return itemIdTypeMap(itemIds);
 178 
		return itemIdTypeMap(itemIds);
169 
	}
 179 
	}
170
180 
 
171 
	private Map<Integer, String> partnerCurrentInventorySnapshotsToItemIdDescriptionMap(List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots){
 181 
	private Map<Integer, String> partnerCurrentInventorySnapshotsToItemIdDescriptionMap(
- 
 
 182 
			List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots) {
172 
		if(partnerCurrentInventorySnapshots.isEmpty()) {
 183 
		if (partnerCurrentInventorySnapshots.isEmpty()) {
173 
			return new HashMap<>();
 184 
			return new HashMap<>();
174 
		}
 185 
		}
175 
		Set<Integer> itemIds = new HashSet<>();
 186 
		Set<Integer> itemIds = new HashSet<>();
176 
		for(PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
 187 
		for (PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
177 
			itemIds.add(partnerCurrentInventorySnapshot.getItemId());
 188 
			itemIds.add(partnerCurrentInventorySnapshot.getItemId());
178 
		}
 189 
		}
179 
		return itemIdDescriptionMap(itemIds);
 190 
		return itemIdDescriptionMap(itemIds);
180 
	}
 191 
	}
181
192 
 
- 
 
 193 
	/*
- 
 
 194 
	 * private Map<Integer, String>
182 
	/*private Map<Integer, String> adminDeliveryNotesToItemIdDescriptionMap(List<AdminDeliveryNote> adminDeliveryNotes){
 195 
	 * adminDeliveryNotesToItemIdDescriptionMap(List<AdminDeliveryNote>
- 
 
 196 
	 * adminDeliveryNotes){ if(adminDeliveryNotes.isEmpty()) { return new
- 
 
 197 
	 * HashMap<>(); } Set<Integer> itemIds = new HashSet<>(); for(AdminDeliveryNote
- 
 
 198 
	 * adminDeliveryNote : adminDeliveryNotes) {
- 
 
 199 
	 * itemIds.add(adminDeliveryNote.getItemId()); } return
- 
 
 200 
	 * itemIdDescriptionMap(itemIds); }
- 
 
 201 
	 */
- 
 
 202 
 
- 
 
 203 
	private Map<Integer, String> scanOutPartnerItemsToItemIdDescriptionMap(
- 
 
 204 
			List<ScanOutPartnerItem> scanOutPartnerItems) {
183 
		if(adminDeliveryNotes.isEmpty()) {
 205 
		if (scanOutPartnerItems.isEmpty()) {
184 
			return new HashMap<>();
 206 
			return new HashMap<>();
185 
		}
 207 
		}
186 
		Set<Integer> itemIds = new HashSet<>();
 208 
		Set<Integer> itemIds = new HashSet<>();
187 
		for(AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
 209 
		for (ScanOutPartnerItem scanOutPartnerItem : scanOutPartnerItems) {
188 
			itemIds.add(adminDeliveryNote.getItemId());
 210 
			itemIds.add(scanOutPartnerItem.getItemId());
189 
		}
 211 
		}
190 
		return itemIdDescriptionMap(itemIds);
 212 
		return itemIdDescriptionMap(itemIds);
191 
	}*/
 213 
	}
192 
 
 214 
 
193 
    private Map<Integer, String> scanOutPartnerItemsToItemIdDescriptionMap(List<ScanOutPartnerItem> scanOutPartnerItems){
 - 
 
194 
        if(scanOutPartnerItems.isEmpty()) {
 - 
 
195 
            return new HashMap<>();
 - 
 
196 
        }
 - 
 
197 
        Set<Integer> itemIds = new HashSet<>();
 - 
 
198 
        for(ScanOutPartnerItem scanOutPartnerItem : scanOutPartnerItems) {
 - 
 
199 
            itemIds.add(scanOutPartnerItem.getItemId());
 - 
 
200 
        }
 - 
 
201 
        return itemIdDescriptionMap(itemIds);
 - 
 
202 
    }
 - 
 
203
- 
 
204 
	private Map<Integer, String> itemIdDescriptionMap(Set<Integer> itemIds){
 215 
	private Map<Integer, String> itemIdDescriptionMap(Set<Integer> itemIds) {
205 
		Map<Integer, String> itemIdDescriptionMap = new HashMap<>();
 216 
		Map<Integer, String> itemIdDescriptionMap = new HashMap<>();
206 
		List<Item> items = itemRepository.selectByIds(itemIds);
 217 
		List<Item> items = itemRepository.selectByIds(itemIds);
207 
		for(Item item : items) {
 218 
		for (Item item : items) {
208 
			itemIdDescriptionMap.put(item.getId(), item.getBrand() + " " + item.getDescription());
 219 
			itemIdDescriptionMap.put(item.getId(), item.getBrand() + " " + item.getDescription());
209 
		}
 220 
		}
210 
		return itemIdDescriptionMap;
 221 
		return itemIdDescriptionMap;
211 
	}
 222 
	}
212
223 
 
213 
	private Map<Integer, String> itemIdTypeMap(Set<Integer> itemIds){
 224 
	private Map<Integer, String> itemIdTypeMap(Set<Integer> itemIds) {
214 
		Map<Integer, String> itemIdTypeMap = new HashMap<>();
 225 
		Map<Integer, String> itemIdTypeMap = new HashMap<>();
215 
		List<Item> items = itemRepository.selectByIds(itemIds);
 226 
		List<Item> items = itemRepository.selectByIds(itemIds);
216 
		for(Item item : items) {
 227 
		for (Item item : items) {
217 
			itemIdTypeMap.put(item.getId(), item.getType().toString());
 228 
			itemIdTypeMap.put(item.getId(), item.getType().toString());
218 
		}
 229 
		}
219 
		return itemIdTypeMap;
 230 
		return itemIdTypeMap;
220 
	}
 231 
	}
221
232 
 
222 
	private Map<Integer, String> warehouseIdNameMap(List<Warehouse> warehouses){
 233 
	private Map<Integer, String> warehouseIdNameMap(List<Warehouse> warehouses) {
223 
		Map<Integer, String> warehouseIdNameMap = new HashMap<>();
 234 
		Map<Integer, String> warehouseIdNameMap = new HashMap<>();
224 
		for(Warehouse warehouse : warehouses) {
 235 
		for (Warehouse warehouse : warehouses) {
225 
			warehouseIdNameMap.put(warehouse.getId(), warehouse.getName());
 236 
			warehouseIdNameMap.put(warehouse.getId(), warehouse.getName());
226 
		}
 237 
		}
227 
		return warehouseIdNameMap;
 238 
		return warehouseIdNameMap;
228 
	}
 239 
	}
229
240 
 
230 
	private Set<Integer> instructionItemsToWarehouseIds(List<InstructionItem> instructionItems){
 241 
	private Set<Integer> instructionItemsToWarehouseIds(List<InstructionItem> instructionItems) {
231 
		Set<Integer> warehouseIds = new HashSet<>();
 242 
		Set<Integer> warehouseIds = new HashSet<>();
232 
		for(InstructionItem instructionItem : instructionItems) {
 243 
		for (InstructionItem instructionItem : instructionItems) {
233 
			warehouseIds.add(instructionItem.getWarehouseId());
 244 
			warehouseIds.add(instructionItem.getWarehouseId());
234 
		}
 245 
		}
235 
		return warehouseIds;
 246 
		return warehouseIds;
236 
	}
 247 
	}
237
248 
 
238 
	private Set<Integer> instructionItemsToFofoIds(List<InstructionItem> instructionItems){
 249 
	private Set<Integer> instructionItemsToFofoIds(List<InstructionItem> instructionItems) {
239 
		Set<Integer> fofoIds = new HashSet<>();
 250 
		Set<Integer> fofoIds = new HashSet<>();
240 
		for(InstructionItem instructionItem : instructionItems) {
 251 
		for (InstructionItem instructionItem : instructionItems) {
241 
			fofoIds.add(instructionItem.getFofoId());
 252 
			fofoIds.add(instructionItem.getFofoId());
242 
		}
 253 
		}
243 
		return fofoIds;
 254 
		return fofoIds;
244 
	}
 255 
	}
245
256 
 
246 
	private Set<Integer> instructionItemsToInstructionItemIds(List<InstructionItem> instructionItems){
 257 
	private Set<Integer> instructionItemsToInstructionItemIds(List<InstructionItem> instructionItems) {
247 
		Set<Integer> instructionItemIds = new HashSet<>();
 258 
		Set<Integer> instructionItemIds = new HashSet<>();
248 
		for(InstructionItem instructionItem : instructionItems) {
 259 
		for (InstructionItem instructionItem : instructionItems) {
249 
			instructionItemIds.add(instructionItem.getId());
 260 
			instructionItemIds.add(instructionItem.getId());
250 
		}
 261 
		}
251 
		return instructionItemIds;
 262 
		return instructionItemIds;
252 
	}
 263 
	}
253
- 
 
254
264 
 
255 
	private Map<Integer, Integer> instructionItemDetailsToItemIdQuantityMap(List<InstructionItemDetail> instructionItemDetails) {
 265 
	private Map<Integer, Integer> instructionItemDetailsToItemIdQuantityMap(
- 
 
 266 
			List<InstructionItemDetail> instructionItemDetails) {
256 
		Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
 267 
		Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
257 
		for(InstructionItemDetail instructionItemDetail : instructionItemDetails) {
 268 
		for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
258 
			if(!itemIdQuantityMap.containsKey(instructionItemDetail.getItemId())) {
 269 
			if (!itemIdQuantityMap.containsKey(instructionItemDetail.getItemId())) {
259 
				itemIdQuantityMap.put(instructionItemDetail.getItemId(), instructionItemDetail.getQuantity());
 270 
				itemIdQuantityMap.put(instructionItemDetail.getItemId(), instructionItemDetail.getQuantity());
260 
			}else {
 271 
			} else {
- 
 
 272 
				itemIdQuantityMap.put(instructionItemDetail.getItemId(),
261 
				itemIdQuantityMap.put(instructionItemDetail.getItemId(), itemIdQuantityMap.get(instructionItemDetail.getItemId()) + instructionItemDetail.getQuantity());
 273 
						itemIdQuantityMap.get(instructionItemDetail.getItemId()) + instructionItemDetail.getQuantity());
262 
			}
 274 
			}
263 
		}
 275 
		}
264 
		return itemIdQuantityMap;
 276 
		return itemIdQuantityMap;
265 
	}
 277 
	}
266
278 
 
267 
	private Map<Integer, List<InstructionItemDetail>> instructionItemsToInstructionItemIdInstructionItemDetailsMap(List<InstructionItemDetail> instructionItemDetails){
 279 
	private Map<Integer, List<InstructionItemDetail>> instructionItemsToInstructionItemIdInstructionItemDetailsMap(
- 
 
 280 
			List<InstructionItemDetail> instructionItemDetails) {
- 
 
 281 
		// Set<Integer> instructionItemIds =
268 
		//Set<Integer> instructionItemIds = this.instructionItemsToInstructionItemIds(instructionItems);
 282 
		// this.instructionItemsToInstructionItemIds(instructionItems);
- 
 
 283 
		// List<InstructionItemDetail> instructionItemDetails =
269 
		//List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository.selectByInstructionItemIds(instructionItemIds);
 284 
		// instructionItemDetailRepository.selectByInstructionItemIds(instructionItemIds);
270 
		Map<Integer, List<InstructionItemDetail>> instructionIdInstructionItemDetailMap = new HashMap<>();
 285 
		Map<Integer, List<InstructionItemDetail>> instructionIdInstructionItemDetailMap = new HashMap<>();
271 
		for(InstructionItemDetail instructionItemDetail : instructionItemDetails) {
 286 
		for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
272 
			if(!instructionIdInstructionItemDetailMap.containsKey(instructionItemDetail.getInstructionItemId())) {
 287 
			if (!instructionIdInstructionItemDetailMap.containsKey(instructionItemDetail.getInstructionItemId())) {
273 
				List<InstructionItemDetail> instructionItemDetailsList = new ArrayList<>();
 288 
				List<InstructionItemDetail> instructionItemDetailsList = new ArrayList<>();
274 
				instructionItemDetailsList.add(instructionItemDetail);
 289 
				instructionItemDetailsList.add(instructionItemDetail);
275 
				instructionIdInstructionItemDetailMap.put(instructionItemDetail.getInstructionItemId(), instructionItemDetailsList);
 290 
				instructionIdInstructionItemDetailMap.put(instructionItemDetail.getInstructionItemId(),
- 
 
 291 
						instructionItemDetailsList);
276 
			}else {
 292 
			} else {
277 
				instructionIdInstructionItemDetailMap.get(instructionItemDetail.getInstructionItemId()).add(instructionItemDetail);
 293 
				instructionIdInstructionItemDetailMap.get(instructionItemDetail.getInstructionItemId())
- 
 
 294 
						.add(instructionItemDetail);
278 
			}
 295 
			}
279 
		}
 296 
		}
280 
		return instructionIdInstructionItemDetailMap;
 297 
		return instructionIdInstructionItemDetailMap;
281 
	}
 298 
	}
282
299 
 
283 
	private Set<Integer> instructionItemDetailsToItemIds(List<InstructionItemDetail> instructionItemDetails){
 300 
	private Set<Integer> instructionItemDetailsToItemIds(List<InstructionItemDetail> instructionItemDetails) {
284 
		Set<Integer> itemIds = new HashSet<>();
 301 
		Set<Integer> itemIds = new HashSet<>();
285 
		for(InstructionItemDetail instructionItemDetail : instructionItemDetails) {
 302 
		for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
286 
			itemIds.add(instructionItemDetail.getItemId());
 303 
			itemIds.add(instructionItemDetail.getItemId());
287 
		}
 304 
		}
288 
		return itemIds;
 305 
		return itemIds;
289 
	}
 306 
	}
290
307 
 
291 
	private Set<Integer> adminDeliveryNotesToWarehouseIds(List<AdminDeliveryNote> adminDeliveryNotes){
 308 
	private Set<Integer> adminDeliveryNotesToWarehouseIds(List<AdminDeliveryNote> adminDeliveryNotes) {
292 
		Set<Integer> warehouseIds = new HashSet<>();
 309 
		Set<Integer> warehouseIds = new HashSet<>();
293 
		for(AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
 310 
		for (AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
294 
			warehouseIds.add(adminDeliveryNote.getWarehouseId());
 311 
			warehouseIds.add(adminDeliveryNote.getWarehouseId());
295 
		}
 312 
		}
296 
		return warehouseIds;
 313 
		return warehouseIds;
297 
	}
 314 
	}
298
315 
 
299 
	private Set<Integer> adminDeliveryNotesToFofoIds(List<AdminDeliveryNote> adminDeliveryNotes){
 316 
	private Set<Integer> adminDeliveryNotesToFofoIds(List<AdminDeliveryNote> adminDeliveryNotes) {
300 
		Set<Integer> fofoIds = new HashSet<>();
 317 
		Set<Integer> fofoIds = new HashSet<>();
301 
		for(AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
 318 
		for (AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
302 
			fofoIds.add(adminDeliveryNote.getFofoId());
 319 
			fofoIds.add(adminDeliveryNote.getFofoId());
303 
		}
 320 
		}
304 
		return fofoIds;
 321 
		return fofoIds;
305 
	}
 322 
	}
306
- 
 
307
323 
 
308 
	@RequestMapping(value = "/createItem", method = RequestMethod.GET)
 324 
	@RequestMapping(value = "/createItem", method = RequestMethod.GET)
309 
	public String createItem(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 325 
	public String createItem(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,
- 
 
 326 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 327 
			throws ProfitMandiBusinessException {
310 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 328 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
311 
		List<Item> items = itemRepository.selectAll(offset, limit);
 329 
		List<Item> items = itemRepository.selectAll(offset, limit);
312 
		long size = itemRepository.selectAllCount();
 330 
		long size = itemRepository.selectAllCount();
313 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
 331 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
314 
		List<Vendor> vendors = vendorRepository.selectAll();
 332 
		List<Vendor> vendors = vendorRepository.selectAll();
Line 316... Line 334...
316 
		model.addAttribute("items", items);
 334 
		model.addAttribute("items", items);
317 
		model.addAttribute("types", ItemType.values());
 335 
		model.addAttribute("types", ItemType.values());
318 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
 336 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
319 
		model.addAttribute("start", offset + 1);
 337 
		model.addAttribute("start", offset + 1);
320 
		model.addAttribute("size", size);
 338 
		model.addAttribute("size", size);
321 
		if (items.size() < limit){
 339 
		if (items.size() < limit) {
322 
			model.addAttribute("end", offset + items.size());
 340 
			model.addAttribute("end", offset + items.size());
323 
		}else{
 341 
		} else {
324 
			model.addAttribute("end", offset + limit);
 342 
			model.addAttribute("end", offset + limit);
325 
		}
 343 
		}
326 
		return "items";
 344 
		return "items";
327 
	}
 345 
	}
328
346 
 
329 
	@RequestMapping(value = "/createItem", method = RequestMethod.POST)
 347 
	@RequestMapping(value = "/createItem", method = RequestMethod.POST)
330 
	public String createItem(HttpServletRequest request, @RequestBody CreateItemRequest createItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 348 
	public String createItem(HttpServletRequest request, @RequestBody CreateItemRequest createItemRequest,
- 
 
 349 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
- 
 
 350 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 351 
			throws ProfitMandiBusinessException {
331 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), createItemRequest);
 352 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), createItemRequest);
332 
		inventoryService.createItem(createItemRequest);
 353 
		inventoryService.createItem(createItemRequest);
333 
		List<Item> items = itemRepository.selectAll(offset, limit);
 354 
		List<Item> items = itemRepository.selectAll(offset, limit);
334 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
 355 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
335 
		long size = itemRepository.selectAllCount();
 356 
		long size = itemRepository.selectAllCount();
Line 338... Line 359...
338 
		model.addAttribute("items", items);
 359 
		model.addAttribute("items", items);
339 
		model.addAttribute("types", ItemType.values());
 360 
		model.addAttribute("types", ItemType.values());
340 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
 361 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
341 
		model.addAttribute("start", offset + 1);
 362 
		model.addAttribute("start", offset + 1);
342 
		model.addAttribute("size", size);
 363 
		model.addAttribute("size", size);
343 
		if (items.size() < limit){
 364 
		if (items.size() < limit) {
344 
			model.addAttribute("end", offset + items.size());
 365 
			model.addAttribute("end", offset + items.size());
345 
		}else{
 366 
		} else {
346 
			model.addAttribute("end", offset + limit);
 367 
			model.addAttribute("end", offset + limit);
347 
		}
 368 
		}
348 
		return "items";
 369 
		return "items";
349 
	}
 370 
	}
350
371 
 
351 
	@RequestMapping(value = "/getPaginatedItems", method = RequestMethod.GET)
 372 
	@RequestMapping(value = "/getPaginatedItems", method = RequestMethod.GET)
- 
 
 373 
	public String getPaginatedItems(HttpServletRequest request,
- 
 
 374 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
352 
	public String getPaginatedItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 375 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 376 
			throws ProfitMandiBusinessException {
353 
		List<Item> items  = itemRepository.selectAll(offset, limit);
 377 
		List<Item> items = itemRepository.selectAll(offset, limit);
354 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
 378 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
355 
		List<Vendor> vendors = vendorRepository.selectAll();
 379 
		List<Vendor> vendors = vendorRepository.selectAll();
356 
		model.addAttribute("vendors", vendors);
 380 
		model.addAttribute("vendors", vendors);
357 
		model.addAttribute("items", items);
 381 
		model.addAttribute("items", items);
358 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
 382 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
359 
		return "items-paginated";
 383 
		return "items-paginated";
360 
	}
 384 
	}
361
385 
 
362 
	@RequestMapping(value = "/scanInItems", method = RequestMethod.POST)
 386 
	@RequestMapping(value = "/scanInItems", method = RequestMethod.POST)
363 
	public String scanInItems(HttpServletRequest request, @RequestBody ScanInItemRequest scanInItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 387 
	public String scanInItems(HttpServletRequest request, @RequestBody ScanInItemRequest scanInItemRequest,
- 
 
 388 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
- 
 
 389 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 390 
			throws ProfitMandiBusinessException {
364 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanInItemRequest);
 391 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanInItemRequest);
365 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 392 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
366 
		List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
 393 
		List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
367 
		List<Item> items = itemRepository.selectAll();
 394 
		List<Item> items = itemRepository.selectAll();
368 
		inventoryService.scanInItem(scanInItemRequest, loginDetails.getFofoId());
 395 
		inventoryService.scanInItem(scanInItemRequest, loginDetails.getFofoId());
369 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
 396 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository
- 
 
 397 
				.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
- 
 
 398 
		Map<Integer, String> itemIdDescriptionMap = this
370 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
 399 
				.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
371 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
 400 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
372 
		if(!warehouseIds.isEmpty()) {
 401 
		if (!warehouseIds.isEmpty()) {
373 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
 402 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
374 
		}
 403 
		}
375 
		model.addAttribute("items", items);
 404 
		model.addAttribute("items", items);
376 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
 405 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
377 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 406 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
378 
		model.addAttribute("start", offset + 1);
 407 
		model.addAttribute("start", offset + 1);
379 
		model.addAttribute("size", size);
 408 
		model.addAttribute("size", size);
380 
		if (adminCurrentInventorySnapshots.size() < limit){
 409 
		if (adminCurrentInventorySnapshots.size() < limit) {
381 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
 410 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
382 
		}else{
 411 
		} else {
383 
			model.addAttribute("end", offset + limit);
 412 
			model.addAttribute("end", offset + limit);
384 
		}
 413 
		}
385 
		return "scan-in-items";
 414 
		return "scan-in-items";
386 
	}
 415 
	}
387
416 
 
388 
	@RequestMapping(value = "/getScanInItems", method = RequestMethod.GET)
 417 
	@RequestMapping(value = "/getScanInItems", method = RequestMethod.GET)
- 
 
 418 
	public String getScanInItems(HttpServletRequest request,
- 
 
 419 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
389 
	public String getScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 420 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 421 
			throws ProfitMandiBusinessException {
390 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 422 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
391 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 423 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
392 
		List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
 424 
		List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
393 
		List<Item> items = itemRepository.selectAll();
 425 
		List<Item> items = itemRepository.selectAll();
394 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
 426 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository
- 
 
 427 
				.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
- 
 
 428 
		Map<Integer, String> itemIdDescriptionMap = this
395 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
 429 
				.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
396 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
 430 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
397 
		if(!warehouseIds.isEmpty()) {
 431 
		if (!warehouseIds.isEmpty()) {
398 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
 432 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
399 
		}
 433 
		}
400 
		model.addAttribute("items", items);
 434 
		model.addAttribute("items", items);
401 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
 435 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
402 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 436 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
403 
		model.addAttribute("start", offset + 1);
 437 
		model.addAttribute("start", offset + 1);
404 
		model.addAttribute("size", size);
 438 
		model.addAttribute("size", size);
405 
		if (adminCurrentInventorySnapshots.size() < limit){
 439 
		if (adminCurrentInventorySnapshots.size() < limit) {
406 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
 440 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
407 
		}else{
 441 
		} else {
408 
			model.addAttribute("end", offset + limit);
 442 
			model.addAttribute("end", offset + limit);
409 
		}
 443 
		}
410 
		return "scan-in-items";
 444 
		return "scan-in-items";
411 
	}
 445 
	}
412
446 
 
413 
	@RequestMapping(value = "/getPaginatedScanInItems", method = RequestMethod.GET)
 447 
	@RequestMapping(value = "/getPaginatedScanInItems", method = RequestMethod.GET)
- 
 
 448 
	public String getPaginatedScanInItems(HttpServletRequest request,
- 
 
 449 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
414 
	public String getPaginatedScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 450 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 451 
			throws ProfitMandiBusinessException {
415 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 452 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
416 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
 453 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository
- 
 
 454 
				.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
- 
 
 455 
		Map<Integer, String> itemIdDescriptionMap = this
417 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
 456 
				.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
418 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
 457 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
419 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 458 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
420 
		return "scan-in-items-paginated";
 459 
		return "scan-in-items-paginated";
421 
	}
 460 
	}
422
461 
 
423 
	@RequestMapping(value = "/getScanInPartnerItems", method = RequestMethod.GET)
 462 
	@RequestMapping(value = "/getScanInPartnerItems", method = RequestMethod.GET)
- 
 
 463 
	public String getScanInPartnerItems(HttpServletRequest request,
- 
 
 464 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
424 
	public String getScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 465 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 466 
			throws ProfitMandiBusinessException {
425 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 467 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
426 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 468 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
427
469 
 
428 
		//List<Item> items = itemRepository.selectAll();
 470 
		// List<Item> items = itemRepository.selectAll();
429 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
 471 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository
- 
 
 472 
				.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
- 
 
 473 
		Map<Integer, String> itemIdDescriptionMap = this
430 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
 474 
				.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
431 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
 475 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
432 
		//model.addAttribute("items", items);
 476 
		// model.addAttribute("items", items);
433 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
 477 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
434 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 478 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
435 
		model.addAttribute("start", offset + 1);
 479 
		model.addAttribute("start", offset + 1);
436 
		model.addAttribute("size", size);
 480 
		model.addAttribute("size", size);
437 
		if (partnerCurrentInventorySnapshots.size() < limit){
 481 
		if (partnerCurrentInventorySnapshots.size() < limit) {
438 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
 482 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
439 
		}else{
 483 
		} else {
440 
			model.addAttribute("end", offset + limit);
 484 
			model.addAttribute("end", offset + limit);
441 
		}
 485 
		}
442 
		return "scan-in-partner-items";
 486 
		return "scan-in-partner-items";
443 
	}
 487 
	}
444
488 
 
445 
	@RequestMapping(value = "/scanInPartnerItems", method = RequestMethod.POST)
 489 
	@RequestMapping(value = "/scanInPartnerItems", method = RequestMethod.POST)
- 
 
 490 
	public String getScanInPartnerItems(HttpServletRequest request,
- 
 
 491 
			@RequestBody ScanInPartnerItemRequest scanInPartnerItemRequest,
- 
 
 492 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
446 
	public String getScanInPartnerItems(HttpServletRequest request, @RequestBody ScanInPartnerItemRequest scanInPartnerItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 493 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 494 
			throws ProfitMandiBusinessException {
447 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 495 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
448 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 496 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
449 
		inventoryService.scanInPartnerItem(scanInPartnerItemRequest, loginDetails.getFofoId());
 497 
		inventoryService.scanInPartnerItem(scanInPartnerItemRequest, loginDetails.getFofoId());
450 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
 498 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository
- 
 
 499 
				.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
- 
 
 500 
		Map<Integer, String> itemIdDescriptionMap = this
451 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
 501 
				.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
452 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
 502 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
453 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
 503 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
454 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 504 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
455 
		model.addAttribute("start", offset + 1);
 505 
		model.addAttribute("start", offset + 1);
456 
		model.addAttribute("size", size);
 506 
		model.addAttribute("size", size);
457 
		if (partnerCurrentInventorySnapshots.size() < limit){
 507 
		if (partnerCurrentInventorySnapshots.size() < limit) {
458 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
 508 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
459 
		}else{
 509 
		} else {
460 
			model.addAttribute("end", offset + limit);
 510 
			model.addAttribute("end", offset + limit);
461 
		}
 511 
		}
462 
		return "scan-in-partner-items";
 512 
		return "scan-in-partner-items";
463 
	}
 513 
	}
464
514 
 
465 
	@RequestMapping(value = "/getPaginatedScanInPartnerItems", method = RequestMethod.GET)
 515 
	@RequestMapping(value = "/getPaginatedScanInPartnerItems", method = RequestMethod.GET)
- 
 
 516 
	public String getPaginatedScanInPartnerItems(HttpServletRequest request,
- 
 
 517 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
466 
	public String getPaginatedScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 518 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 519 
			throws ProfitMandiBusinessException {
467 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 520 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
468 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
 521 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository
- 
 
 522 
				.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
- 
 
 523 
		Map<Integer, String> itemIdDescriptionMap = this
469 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
 524 
				.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
470 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
 525 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
471 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 526 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
472 
		return "scan-in-partner-items-paginated";
 527 
		return "scan-in-partner-items-paginated";
473 
	}
 528 
	}
474
529 
 
475 
	private Map<Integer, Integer> partnerCurrentInventorySnapshotsItemIdQuantityMap(List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots){
 530 
	private Map<Integer, Integer> partnerCurrentInventorySnapshotsItemIdQuantityMap(
- 
 
 531 
			List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots) {
476 
		Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
 532 
		Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
477 
		for(PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
 533 
		for (PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
478 
			itemIdQuantityMap.put(partnerCurrentInventorySnapshot.getItemId(), partnerCurrentInventorySnapshot.getAvailability());
 534 
			itemIdQuantityMap.put(partnerCurrentInventorySnapshot.getItemId(),
- 
 
 535 
					partnerCurrentInventorySnapshot.getAvailability());
479 
		}
 536 
		}
480 
		return itemIdQuantityMap;
 537 
		return itemIdQuantityMap;
481 
	}
 538 
	}
482 
 
 539 
 
483 
    @RequestMapping(value = "/getScanOutPartnerItems", method = RequestMethod.GET)
 540 
	@RequestMapping(value = "/getScanOutPartnerItems", method = RequestMethod.GET)
- 
 
 541 
	public String getScanOutPartnerItems(HttpServletRequest request,
- 
 
 542 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
484 
    public String getScanOutPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 543 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 544 
			throws ProfitMandiBusinessException {
485 
        LOGGER.info("Request Received at url {}", request.getRequestURI());
 545 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
486 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 546 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
487 
 
 547 
 
488 
        int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
 548 
		int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
489 
        Address address = addressRepository.selectById(addressId);
 549 
		Address address = addressRepository.selectById(addressId);
490
550 
 
491 
        List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectByFofoId(loginDetails.getFofoId());
 551 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository
- 
 
 552 
				.selectByFofoId(loginDetails.getFofoId());
- 
 
 553 
		Map<Integer, Integer> itemIdQuantityMap = this
492 
        Map<Integer, Integer> itemIdQuantityMap = this.partnerCurrentInventorySnapshotsItemIdQuantityMap(partnerCurrentInventorySnapshots);
 554 
				.partnerCurrentInventorySnapshotsItemIdQuantityMap(partnerCurrentInventorySnapshots);
493 
        List<Item> items = itemRepository.selectByIds(itemIdQuantityMap.keySet());
 555 
		List<Item> items = itemRepository.selectByIds(itemIdQuantityMap.keySet());
494 
 
 556 
 
495 
        List<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
 557 
		List<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository
- 
 
 558 
				.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
496 
        Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
 559 
		Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
497 
        long size = scanOutPartnerItemRepository.selectCountByFofoId(loginDetails.getFofoId());
 560 
		long size = scanOutPartnerItemRepository.selectCountByFofoId(loginDetails.getFofoId());
498 
        model.addAttribute("items", items);
 561 
		model.addAttribute("items", items);
499 
        //model.addAttribute("stateNames", Utils.getAllStateNames());
 562 
		// model.addAttribute("stateNames", Utils.getAllStateNames());
500 
        model.addAttribute("retailerStateName", address.getState());
 563 
		model.addAttribute("retailerStateName", address.getState());
501 
        model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
 564 
		model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
502 
        model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 565 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
503 
        model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
 566 
		model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
504 
        model.addAttribute("start", offset + 1);
 567 
		model.addAttribute("start", offset + 1);
505 
        model.addAttribute("size", size);
 568 
		model.addAttribute("size", size);
506 
        if (scanOutPartnerItems.size() < limit){
 569 
		if (scanOutPartnerItems.size() < limit) {
507 
            model.addAttribute("end", offset + scanOutPartnerItems.size());
 570 
			model.addAttribute("end", offset + scanOutPartnerItems.size());
508 
        }else{
 571 
		} else {
509 
            model.addAttribute("end", offset + limit);
 572 
			model.addAttribute("end", offset + limit);
510 
        }
 573 
		}
511 
        return "scan-out-partner-items";
 574 
		return "scan-out-partner-items";
512 
    }
 575 
	}
513
576 
 
514 
    @RequestMapping(value = "/instructionItem", method = RequestMethod.POST)
 577 
	@RequestMapping(value = "/instructionItem", method = RequestMethod.POST)
- 
 
 578 
	public String instructionItems(HttpServletRequest request,
- 
 
 579 
			@RequestBody InstructionItemRequest instructionItemRequest,
- 
 
 580 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
515 
    public String instructionItems(HttpServletRequest request, @RequestBody InstructionItemRequest instructionItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 581 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 582 
			throws ProfitMandiBusinessException {
516 
        LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), instructionItemRequest);
 583 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), instructionItemRequest);
517 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 584 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
518 
        inventoryService.instructionItem(instructionItemRequest, loginDetails.getFofoId());
 585 
		inventoryService.instructionItem(instructionItemRequest, loginDetails.getFofoId());
519 
        return this.getInstructionItems(request, offset, limit, model);
 586 
		return this.getInstructionItems(request, offset, limit, model);
520 
    }
 587 
	}
521
588 
 
522 
    @RequestMapping(value = "/getInstructionItems", method = RequestMethod.GET)
 589 
	@RequestMapping(value = "/getInstructionItems", method = RequestMethod.GET)
- 
 
 590 
	public String getInstructionItems(HttpServletRequest request,
- 
 
 591 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
523 
    public String getInstructionItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 592 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 593 
			throws ProfitMandiBusinessException {
524 
        LOGGER.info("Request Received at url {}", request.getRequestURI());
 594 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
525 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 595 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
526
- 
 
527 
        List<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
 596 
		List<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(),
528
597 
				offset, limit);
- 
 
 598 
		LOGGER.info("instructionItems" + instructionItems);
529 
        Set<Integer> instructionItemWarehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
 599 
		Set<Integer> instructionItemWarehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
530
- 
 
- 
 
 600 
		LOGGER.info("instructionItemWarehouseIds" + instructionItemWarehouseIds);
531 
        List<Warehouse> warehouses = new ArrayList<>();
 601 
		List<Warehouse> warehouses = new ArrayList<>();
532 
        if(!instructionItemWarehouseIds.isEmpty()) {
 602 
		if (!instructionItemWarehouseIds.isEmpty()) {
- 
 
 603 
 
533 
        	 warehouses = warehouseRepository.selectByIds(instructionItemWarehouseIds);
 604 
			warehouses = warehouseRepository.selectByIds(instructionItemWarehouseIds);
- 
 
 605 
 
534 
        }
 606 
		}
535 
        Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
 607 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
536
608 
 
537 
        List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
 609 
		List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
538 
        if(!warehouseIds.isEmpty()) {
 610 
		if (!warehouseIds.isEmpty()) {
539 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
 611 
			model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
- 
 
 612 
			LOGGER.info(warehouseRepository.selectByIds(new HashSet<>(warehouseIds)) + "warehouseIdNameMap");
540 
		}
 613 
		}
- 
 
 614 
 
- 
 
 615 
		List<Integer> userIds = userRoleRepository
- 
 
 616 
				.selectUserIdsByRoleId(roleRepository.selectByName(RoleType.FOFO_ADMIN.toString()).getId());
541 
        Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
 617 
		Map<Integer, String> userIdEmailIdMap = userService.getAllUseUserIdEmailIdMap(userIds);
- 
 
 618 
 
542 
        model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
 619 
		model.addAttribute("fofoIdEmailIdMap", userIdEmailIdMap);
543
- 
 
544 
        long size = instructionItemRepository.selectCountByAdminId(loginDetails.getFofoId());
 620 
		long size = instructionItemRepository.selectCountByAdminId(loginDetails.getFofoId());
545 
        model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
 621 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
546 
        model.addAttribute("instructionItems", instructionItems);
 622 
		model.addAttribute("instructionItems", instructionItems);
547 
        model.addAttribute("start", offset + 1);
 623 
		model.addAttribute("start", offset + 1);
548 
        model.addAttribute("size", size);
 624 
		model.addAttribute("size", size);
549 
        if (instructionItems.size() < limit){
 625 
		if (instructionItems.size() < limit) {
550 
            model.addAttribute("end", offset + instructionItems.size());
 626 
			model.addAttribute("end", offset + instructionItems.size());
551 
        }else{
 627 
		} else {
552 
            model.addAttribute("end", offset + limit);
 628 
			model.addAttribute("end", offset + limit);
553 
        }
 629 
		}
554 
 
 630 
 
555 
        return "instruction-items";
 631 
		return "instruction-items";
556 
    }
 632 
	}
557
633 
 
558 
    @RequestMapping(value = "/getPaginatedInstructionItems", method = RequestMethod.GET)
 634 
	@RequestMapping(value = "/getPaginatedInstructionItems", method = RequestMethod.GET)
- 
 
 635 
	public String getPaginatedInstructionItems(HttpServletRequest request,
- 
 
 636 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
559 
    public String getPaginatedInstructionItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 637 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 638 
			throws ProfitMandiBusinessException {
560 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 639 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
561 
        List<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
 640 
		List<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(),
562
641 
				offset, limit);
- 
 
 642 
 
563 
        Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
 643 
		Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
564 
        List<Warehouse> warehouses = warehouseRepository.selectByIds(warehouseIds);
 644 
		List<Warehouse> warehouses = warehouseRepository.selectByIds(warehouseIds);
565 
        Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
 645 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
566
646 
 
567 
        model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
 647 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
568 
        model.addAttribute("instructionItems", instructionItems);
 648 
		model.addAttribute("instructionItems", instructionItems);
569 
        return "scan-out-partner-items-paginated";
 649 
		return "scan-out-partner-items-paginated";
570 
    }
 650 
	}
571 
 
 651 
 
572 
    @RequestMapping(value = "/scanOutPartnerItem", method = RequestMethod.POST)
 652 
	@RequestMapping(value = "/scanOutPartnerItem", method = RequestMethod.POST)
- 
 
 653 
	public String scanOutPartnerItems(HttpServletRequest request,
- 
 
 654 
			@RequestBody ScanOutPartnerItemRequest scanOutPartnerItemRequest,
- 
 
 655 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
573 
    public String scanOutPartnerItems(HttpServletRequest request, @RequestBody ScanOutPartnerItemRequest scanOutPartnerItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 656 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 657 
			throws ProfitMandiBusinessException {
574 
        LOGGER.info("Request Received at url {}", request.getRequestURI());
 658 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
575 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 659 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
576 
        inventoryService.scanOutPartnerItem(scanOutPartnerItemRequest, loginDetails.getFofoId());
 660 
		inventoryService.scanOutPartnerItem(scanOutPartnerItemRequest, loginDetails.getFofoId());
577 
        return this.scanOutPartnerItems(request, scanOutPartnerItemRequest, offset, limit, model);
 661 
		return this.scanOutPartnerItems(request, scanOutPartnerItemRequest, offset, limit, model);
578 
    }
 662 
	}
579 
 
 663 
 
580 
    @RequestMapping(value = "/getPaginatedScanOutPartnerItems", method = RequestMethod.GET)
 664 
	@RequestMapping(value = "/getPaginatedScanOutPartnerItems", method = RequestMethod.GET)
- 
 
 665 
	public String getPaginatedScanOutPartnerItems(HttpServletRequest request,
- 
 
 666 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
581 
    public String getPaginatedScanOutPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 667 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 668 
			throws ProfitMandiBusinessException {
582 
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 669 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
583 
        List<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
 670 
		List<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository
- 
 
 671 
				.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
584 
        Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
 672 
		Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
585 
        model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
 673 
		model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
586 
        model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 674 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
587 
        return "scan-out-partner-items-paginated";
 675 
		return "scan-out-partner-items-paginated";
588 
    }
 676 
	}
589
677 
 
590 
	@RequestMapping(value = "/deliveryNoteDetails", method = RequestMethod.GET)
 678 
	@RequestMapping(value = "/deliveryNoteDetails", method = RequestMethod.GET)
- 
 
 679 
	public String deliveryNoteDetails(HttpServletRequest request,
591 
	public String deliveryNoteDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId, Model model) throws ProfitMandiBusinessException{
 680 
			@RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId, Model model)
- 
 
 681 
			throws ProfitMandiBusinessException {
592 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 682 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
593 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 683 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
- 
 
 684 
		AdminDeliveryNote adminDeliveryNote = adminDeliveryNoteRepository
594 
		AdminDeliveryNote adminDeliveryNote = adminDeliveryNoteRepository.selectByDeliveryNoteIdAndFofoid(deliveryNoteId, loginDetails.getFofoId());
 685 
				.selectByDeliveryNoteIdAndFofoid(deliveryNoteId, loginDetails.getFofoId());
595 
		if(adminDeliveryNote.getCompleteTimestamp() != null) {
 686 
		if (adminDeliveryNote.getCompleteTimestamp() != null) {
- 
 
 687 
			throw new ProfitMandiBusinessException(
596 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.DELIVERY_NOTE_ID + ", " + ProfitMandiConstants.FOFO_ID, deliveryNoteId + ", " + loginDetails.getFofoId(), "NNBLBL_ITM_1002");
 688 
					ProfitMandiConstants.DELIVERY_NOTE_ID + ", " + ProfitMandiConstants.FOFO_ID,
- 
 
 689 
					deliveryNoteId + ", " + loginDetails.getFofoId(), "NNBLBL_ITM_1002");
597 
		}
 690 
		}
598 
		Warehouse warehouse = warehouseRepository.selectId(adminDeliveryNote.getWarehouseId());
 691 
		Warehouse warehouse = warehouseRepository.selectId(adminDeliveryNote.getWarehouseId());
599 
		List<Integer> instructionItemIds = adminDeliveryNoteDetailRepository.selectInstructionItemIdsByDeliveryNoteId(deliveryNoteId);
 692 
		List<Integer> instructionItemIds = adminDeliveryNoteDetailRepository
- 
 
 693 
				.selectInstructionItemIdsByDeliveryNoteId(deliveryNoteId);
600 
		List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository.selectByInstructionItemIds(new HashSet<>(instructionItemIds));
 694 
		List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository
- 
 
 695 
				.selectByInstructionItemIds(new HashSet<>(instructionItemIds));
- 
 
 696 
		Map<Integer, Integer> itemIdQuantityMap = this
601 
		Map<Integer, Integer> itemIdQuantityMap = this.instructionItemDetailsToItemIdQuantityMap(instructionItemDetails);
 697 
				.instructionItemDetailsToItemIdQuantityMap(instructionItemDetails);
602 
		Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIdQuantityMap.keySet());
 698 
		Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIdQuantityMap.keySet());
603 
		Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIdQuantityMap.keySet());
 699 
		Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIdQuantityMap.keySet());
604 
		model.addAttribute("deliveryNoteId", deliveryNoteId);
 700 
		model.addAttribute("deliveryNoteId", deliveryNoteId);
605 
		model.addAttribute("warehouseName", warehouse.getName());
 701 
		model.addAttribute("warehouseName", warehouse.getName());
606 
		model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
 702 
		model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
607 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 703 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
608 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
 704 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
609 
		return "delivery-note-details";
 705 
		return "delivery-note-details";
610 
	}
 706 
	}
611
707 
 
612 
	@RequestMapping(value = "/getItemsByWarehouseId", method = RequestMethod.GET)
 708 
	@RequestMapping(value = "/getItemsByWarehouseId", method = RequestMethod.GET)
- 
 
 709 
	public String getItemsByWarehouseId(HttpServletRequest request,
613 
	public String getItemsByWarehouseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
 710 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model)
- 
 
 711 
			throws ProfitMandiBusinessException {
614 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 712 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
615 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllAvailableByWarehouseId(warehouseId);
 713 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository
- 
 
 714 
				.selectAllAvailableByWarehouseId(warehouseId);
- 
 
 715 
		Map<Integer, String> itemIdDescriptionMap = this
616 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
 716 
				.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
- 
 
 717 
		Map<Integer, String> itemIdTypeMap = this
617 
		Map<Integer, String> itemIdTypeMap = this.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
 718 
				.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
618 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 719 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
619 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
 720 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
620 
		return "warehouse-items";
 721 
		return "warehouse-items";
621 
	}
 722 
	}
622
723 
 
623 
	@RequestMapping(value = "/getInstructionItemsByWarehouseId", method = RequestMethod.GET)
 724 
	@RequestMapping(value = "/getInstructionItemsByWarehouseId", method = RequestMethod.GET)
- 
 
 725 
	public String getInstructionItemsByWarehouseId(HttpServletRequest request,
624 
	public String getInstructionItemsByWarehouseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
 726 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model)
- 
 
 727 
			throws ProfitMandiBusinessException {
625 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 728 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
626 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllAvailableByWarehouseId(warehouseId);
 729 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository
- 
 
 730 
				.selectAllAvailableByWarehouseId(warehouseId);
- 
 
 731 
		Map<Integer, String> itemIdDescriptionMap = this
627 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
 732 
				.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
- 
 
 733 
		Map<Integer, String> itemIdTypeMap = this
628 
		Map<Integer, String> itemIdTypeMap = this.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
 734 
				.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
629 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 735 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
630 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
 736 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
631 
		return "warehouse-instruction-items";
 737 
		return "warehouse-instruction-items";
632 
	}
 738 
	}
633
739 
 
634 
	@RequestMapping(value = "/getPendingInstructionItems", method = RequestMethod.GET)
 740 
	@RequestMapping(value = "/getPendingInstructionItems", method = RequestMethod.GET)
- 
 
 741 
	public String getPendingInstructionItems(HttpServletRequest request,
- 
 
 742 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId,
635 
	public String getPendingInstructionItems(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, @RequestParam(name = ProfitMandiConstants.USER_ID) int userId, Model model) throws ProfitMandiBusinessException{
 743 
			@RequestParam(name = ProfitMandiConstants.USER_ID) int userId, Model model)
- 
 
 744 
			throws ProfitMandiBusinessException {
636 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 745 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
637 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 746 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
638 
		List<InstructionItem> instructionItems = instructionItemRepository.selectByAdminIdWarehouseIdUserIdStatus(loginDetails.getFofoId(), warehouseId, userId, InstructionItemStatus.PENDING);
 747 
		List<InstructionItem> instructionItems = instructionItemRepository.selectByAdminIdWarehouseIdUserIdStatus(
- 
 
 748 
				loginDetails.getFofoId(), warehouseId, userId, InstructionItemStatus.PENDING);
639 
		Set<Integer> instructionItemIds = this.instructionItemsToInstructionItemIds(instructionItems);
 749 
		Set<Integer> instructionItemIds = this.instructionItemsToInstructionItemIds(instructionItems);
640 
		List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository.selectByInstructionItemIds(instructionItemIds);
 750 
		List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository
- 
 
 751 
				.selectByInstructionItemIds(instructionItemIds);
641 
		Set<Integer> itemIds = this.instructionItemDetailsToItemIds(instructionItemDetails);
 752 
		Set<Integer> itemIds = this.instructionItemDetailsToItemIds(instructionItemDetails);
642 
		Map<Integer, List<InstructionItemDetail>> instructionItemIdInstructionItemDetailsMap = this.instructionItemsToInstructionItemIdInstructionItemDetailsMap(instructionItemDetails);
 753 
		Map<Integer, List<InstructionItemDetail>> instructionItemIdInstructionItemDetailsMap = this
- 
 
 754 
				.instructionItemsToInstructionItemIdInstructionItemDetailsMap(instructionItemDetails);
643 
		Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIds);
 755 
		Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIds);
644 
		Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIds);
 756 
		Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIds);
645 
		model.addAttribute("instructionItems", instructionItems);
 757 
		model.addAttribute("instructionItems", instructionItems);
646 
		model.addAttribute("instructionItemIdInstructionItemDetailsMap", instructionItemIdInstructionItemDetailsMap);
 758 
		model.addAttribute("instructionItemIdInstructionItemDetailsMap", instructionItemIdInstructionItemDetailsMap);
647 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
 759 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
648 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
 760 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
649 
		return "pending-instruction-items";
 761 
		return "pending-instruction-items";
650 
	}
 762 
	}
651
763 
 
652 
	@RequestMapping(value = "/getScanOutItems", method = RequestMethod.GET)
 764 
	@RequestMapping(value = "/getScanOutItems", method = RequestMethod.GET)
- 
 
 765 
	public String getScanOutItems(HttpServletRequest request,
- 
 
 766 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
653 
	public String getScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 767 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 768 
			throws ProfitMandiBusinessException {
654 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 769 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
655 
		//List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAll();
 770 
		// List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots =
- 
 
 771 
		// adminCurrentInventorySnapshotRepository.selectAll();
656 
		//Set<Integer> adminIds = this.getAdminIds(adminCurrentInventorySnapshots);
 772 
		// Set<Integer> adminIds = this.getAdminIds(adminCurrentInventorySnapshots);
- 
 
 773 
		// Map<Integer, String> adminIdEmailIdMap =
657 
		//Map<Integer, String> adminIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap(adminIds);
 774 
		// retailerService.getAllFofoRetailerIdEmailIdMap(adminIds);
658 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 775 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
- 
 
 776 
		List<InstructionItem> instructionItems = instructionItemRepository
659 
		List<InstructionItem> instructionItems = instructionItemRepository.selectByAdminIdStatus(loginDetails.getFofoId(), InstructionItemStatus.PENDING);
 777 
				.selectByAdminIdStatus(loginDetails.getFofoId(), InstructionItemStatus.PENDING);
660
778 
 
661 
		List<Warehouse> warehouses = new ArrayList<>();
 779 
		List<Warehouse> warehouses = new ArrayList<>();
662 
		Map<Integer, String> fofoIdEmailIdMap = new HashMap<>();
 780 
		Map<Integer, String> fofoIdEmailIdMap = new HashMap<>();
663 
		if(!instructionItems.isEmpty()) {
 781 
		if (!instructionItems.isEmpty()) {
664 
			Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
 782 
			Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
665 
			warehouses = warehouseRepository.selectByIds(warehouseIds);
 783 
			warehouses = warehouseRepository.selectByIds(warehouseIds);
666 
			Set<Integer> fofoIds = this.instructionItemsToFofoIds(instructionItems);
 784 
			Set<Integer> fofoIds = this.instructionItemsToFofoIds(instructionItems);
667 
			fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap(fofoIds);
 785 
			fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap(fofoIds);
668 
		}
 786 
		}
669
787 
 
670 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
 788 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
671 
		Map<Integer, String> warehouseIdNameMap  = new HashMap<>();
 789 
		Map<Integer, String> warehouseIdNameMap = new HashMap<>();
672 
		if(!adminDeliveryNotes.isEmpty()) {
 790 
		if (!adminDeliveryNotes.isEmpty()) {
- 
 
 791 
			List<Warehouse> adminDeliveryNoteWarehouses = warehouseRepository
673 
			List<Warehouse> adminDeliveryNoteWarehouses = warehouseRepository.selectByIds(this.adminDeliveryNotesToWarehouseIds(adminDeliveryNotes));
 792 
					.selectByIds(this.adminDeliveryNotesToWarehouseIds(adminDeliveryNotes));
674 
			warehouseIdNameMap = this.warehouseIdNameMap(adminDeliveryNoteWarehouses);
 793 
			warehouseIdNameMap = this.warehouseIdNameMap(adminDeliveryNoteWarehouses);
- 
 
 794 
			fofoIdEmailIdMap = retailerService
675 
			fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap(this.adminDeliveryNotesToFofoIds(adminDeliveryNotes));
 795 
					.getAllFofoRetailerIdEmailIdMap(this.adminDeliveryNotesToFofoIds(adminDeliveryNotes));
676 
		}
 796 
		}
677 
		long size = adminDeliveryNoteRepository.selectAllCount();
 797 
		long size = adminDeliveryNoteRepository.selectAllCount();
678 
		//model.addAttribute("adminIdEmailIdMap", adminIdEmailIdMap);
 798 
		// model.addAttribute("adminIdEmailIdMap", adminIdEmailIdMap);
679 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
 799 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
680 
		model.addAttribute("warehouses", warehouses);
 800 
		model.addAttribute("warehouses", warehouses);
681 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
 801 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
682 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
 802 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
683 
		model.addAttribute("start", offset + 1);
 803 
		model.addAttribute("start", offset + 1);
684 
		model.addAttribute("size", size);
 804 
		model.addAttribute("size", size);
685 
		if (adminDeliveryNotes.size() < limit){
 805 
		if (adminDeliveryNotes.size() < limit) {
686 
			model.addAttribute("end", offset + adminDeliveryNotes.size());
 806 
			model.addAttribute("end", offset + adminDeliveryNotes.size());
687 
		}else{
 807 
		} else {
688 
			model.addAttribute("end", offset + limit);
 808 
			model.addAttribute("end", offset + limit);
689 
		}
 809 
		}
690 
		return "scan-out-items";
 810 
		return "scan-out-items";
691 
	}
 811 
	}
692
- 
 
693
- 
 
694
812 
 
695 
	@RequestMapping(value = "/scanOutItems", method = RequestMethod.POST)
 813 
	@RequestMapping(value = "/scanOutItems", method = RequestMethod.POST)
696 
	public String scanOutItems(HttpServletRequest request, @RequestBody ScanOutItemRequest scanOutItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 814 
	public String scanOutItems(HttpServletRequest request, @RequestBody ScanOutItemRequest scanOutItemRequest,
- 
 
 815 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
- 
 
 816 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 817 
			throws ProfitMandiBusinessException {
697 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanOutItemRequest);
 818 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanOutItemRequest);
698 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 819 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
699 
		inventoryService.scanOutItem(scanOutItemRequest, loginDetails.getFofoId());
 820 
		inventoryService.scanOutItem(scanOutItemRequest, loginDetails.getFofoId());
700 
		return this.getScanOutItems(request, offset, limit, model);
 821 
		return this.getScanOutItems(request, offset, limit, model);
701 
	}
 822 
	}
702
823 
 
703 
	@RequestMapping(value = "/getPaginatedScanOutItems", method = RequestMethod.GET)
 824 
	@RequestMapping(value = "/getPaginatedScanOutItems", method = RequestMethod.GET)
- 
 
 825 
	public String getPaginatedScanOutItems(HttpServletRequest request,
- 
 
 826 
			@RequestParam(name = "offset", defaultValue = "0") int offset,
704 
	public String getPaginatedScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
 827 
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
- 
 
 828 
			throws ProfitMandiBusinessException {
705 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 829 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
- 
 
 830 
		/*
706 
		/*List<Warehouse> warehouses = warehouseRepository.selectAll();
 831 
		 * List<Warehouse> warehouses = warehouseRepository.selectAll();
- 
 
 832 
		 * List<AdminDeliveryNote> adminDeliveryNotes =
707 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
 833 
		 * adminDeliveryNoteRepository.selectAll(offset, limit); Map<Integer, String>
- 
 
 834 
		 * itemIdDescriptionMap =
708 
		Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
 835 
		 * this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
709 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
 836 
		 * Map<Integer, String> warehouseIdNameMap =
- 
 
 837 
		 * this.warehouseIdNameMap(warehouses); Map<Integer, String> fofoIdEmailIdMap =
710 
		Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
 838 
		 * retailerService.getAllFofoRetailerIdEmailIdMap();
711 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
 839 
		 * model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
712 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
 840 
		 * model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
713 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
 841 
		 * model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
714 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);*/
 842 
		 * model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
- 
 
 843 
		 */
715 
		return "scan-out-items-paginated";
 844 
		return "scan-out-items-paginated";
716 
	}
 845 
	}
717
846 
 
718 
	@RequestMapping(value = "/getSerialNumbersByItemIdWarehouseId", method = RequestMethod.GET)
 847 
	@RequestMapping(value = "/getSerialNumbersByItemIdWarehouseId", method = RequestMethod.GET)
719 
	public String getSerialNumbersByItemIdWarehouseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId,
 848 
	public String getSerialNumbersByItemIdWarehouseId(HttpServletRequest request,
- 
 
 849 
			@RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId,
720 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
 850 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model)
- 
 
 851 
			throws ProfitMandiBusinessException {
- 
 
 852 
		List<String> itemSerialNumbers = adminInventoryItemRepository
721 
		List<String> itemSerialNumbers = adminInventoryItemRepository.selectSerialNumbersByWarehouseIdItemIdScanType(warehouseId, itemId, ScanType.IN);
 853 
				.selectSerialNumbersByWarehouseIdItemIdScanType(warehouseId, itemId, ScanType.IN);
722 
		model.addAttribute("itemSerialNumbers", itemSerialNumbers);
 854 
		model.addAttribute("itemSerialNumbers", itemSerialNumbers);
723 
		return "item-serial-numbers";
 855 
		return "item-serial-numbers";
724 
	}
 856 
	}
725 
 
 857 
 
726 
    @RequestMapping(value = "/getSerialNumbersByItemId", method = RequestMethod.GET)
 858 
	@RequestMapping(value = "/getSerialNumbersByItemId", method = RequestMethod.GET)
- 
 
 859 
	public String getSerialNumbersByItemId(HttpServletRequest request,
727 
    public String getSerialNumbersByItemId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, Model model) throws ProfitMandiBusinessException{
 860 
			@RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, Model model)
- 
 
 861 
			throws ProfitMandiBusinessException {
728 
        List<String> itemSerialNumbers = partnerInventoryItemRepository.selectSerialNumbersByItemIdScanType(itemId, ScanType.IN);
 862 
		List<String> itemSerialNumbers = partnerInventoryItemRepository.selectSerialNumbersByItemIdScanType(itemId,
- 
 
 863 
				ScanType.IN);
729 
        model.addAttribute("itemSerialNumbers", itemSerialNumbers);
 864 
		model.addAttribute("itemSerialNumbers", itemSerialNumbers);
730 
        return "item-serial-numbers-single";
 865 
		return "item-serial-numbers-single";
731 
    }
 - 
 
732
866 
	}
733
867 
 
734 
}
 868 
}