Subversion Repositories SmartDukaan

Rev

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

Rev 23443 Rev 23444
Line 52... Line 52...
52 
 
 52 
 
53 
@Component
 53 
@Component
54 
public class SchemeServiceImpl implements SchemeService {
 54 
public class SchemeServiceImpl implements SchemeService {
55 
 
 55 
 
56 
	private static final Logger LOGGER = LoggerFactory.getLogger(SchemeServiceImpl.class);
 56 
	private static final Logger LOGGER = LoggerFactory.getLogger(SchemeServiceImpl.class);
57
57 
 
58 
	@Autowired
 58 
	@Autowired
59 
	private InventoryItemRepository inventoryItemRepository;
 59 
	private InventoryItemRepository inventoryItemRepository;
60
60 
 
61 
	@Autowired
 61 
	@Autowired
62 
	private OrderService orderService;
 62 
	private OrderService orderService;
63
63 
 
64 
	@Autowired
 64 
	@Autowired
65 
	private SchemeRepository schemeRepository;
 65 
	private SchemeRepository schemeRepository;
66
66 
 
67 
	@Autowired
 67 
	@Autowired
68 
	private RetailerRepository retailerRepository;
 68 
	private RetailerRepository retailerRepository;
69
69 
 
70 
	@Autowired
 70 
	@Autowired
71 
	private RetailerSchemeRepository retailerSchemeRepository;
 71 
	private RetailerSchemeRepository retailerSchemeRepository;
72
72 
 
73 
	@Autowired
 73 
	@Autowired
74 
	private SchemeInOutRepository schemeInOutRepository;
 74 
	private SchemeInOutRepository schemeInOutRepository;
75
75 
 
76 
	@Autowired
 76 
	@Autowired
77 
	private ItemRepository itemRepository;
 77 
	private ItemRepository itemRepository;
78
78 
 
79 
	@Autowired
 79 
	@Autowired
80 
	private SchemeItemRepository schemeItemRepository;
 80 
	private SchemeItemRepository schemeItemRepository;
81
81 
 
82 
	@Autowired
 82 
	@Autowired
83 
	private WalletService walletService;
 83 
	private WalletService walletService;
84
84 
 
85 
	@Autowired
 85 
	@Autowired
86 
	private FofoOrderItemRepository fofoOrderItemRepository;
 86 
	private FofoOrderItemRepository fofoOrderItemRepository;
87
87 
 
88 
	@Autowired
 88 
	@Autowired
89 
	private FofoLineItemRepository fofoLineItemRepository;
 89 
	private FofoLineItemRepository fofoLineItemRepository;
90
90 
 
91 
	@Autowired
 91 
	@Autowired
92 
	private PurchaseRepository purchaseRepository;
 92 
	private PurchaseRepository purchaseRepository;
93
93 
 
94 
	@Autowired
 94 
	@Autowired
95 
	private OrderRepository orderRepository;
 95 
	private OrderRepository orderRepository;
96
96 
 
97 
	@Autowired
 97 
	@Autowired
98 
	private FofoOrderRepository fofoOrderRepository;
 98 
	private FofoOrderRepository fofoOrderRepository;
99
99 
 
100 
	@Override
 100 
	@Override
101 
	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
 101 
	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
102
102 
 
103 
		this.validateCreateSchemeRequest(createSchemeRequest);
 103 
		this.validateCreateSchemeRequest(createSchemeRequest);
104
104 
 
105 
		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
 105 
		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
106
106 
 
107 
		if(scheme.getStartDateTime().isAfter(scheme.getEndDateTime())){
 107 
		if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {
- 
 
 108 
			throw new ProfitMandiBusinessException(
- 
 
 109 
					ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,
108 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE, scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
 110 
					scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
109 
		}
 111 
		}
110
112 
 
111 
		this.validateItemIds(createSchemeRequest);
 113 
		this.validateItemIds(createSchemeRequest);
112 
		schemeRepository.persist(scheme);
 114 
		schemeRepository.persist(scheme);
113 
		if(!createSchemeRequest.isRetailerAll()){
 115 
		if (!createSchemeRequest.isRetailerAll()) {
114 
			this.validateRetailerIds(createSchemeRequest);
 116 
			this.validateRetailerIds(createSchemeRequest);
115 
			for(int retailerId : createSchemeRequest.getRetailerIds()){
 117 
			for (int retailerId : createSchemeRequest.getRetailerIds()) {
116 
				RetailerScheme retailerScheme = new RetailerScheme();
 118 
				RetailerScheme retailerScheme = new RetailerScheme();
117 
				retailerScheme.setRetailerId(retailerId);
 119 
				retailerScheme.setRetailerId(retailerId);
118 
				retailerScheme.setSchemeId(scheme.getId());
 120 
				retailerScheme.setSchemeId(scheme.getId());
119 
				retailerSchemeRepository.persist(retailerScheme);
 121 
				retailerSchemeRepository.persist(retailerScheme);
120 
			}
 122 
			}
121 
		}
 123 
		}
122 
		for(int itemId : createSchemeRequest.getItemIds()){
 124 
		for (int itemId : createSchemeRequest.getItemIds()) {
123 
			SchemeItem schemeItem = new SchemeItem();
 125 
			SchemeItem schemeItem = new SchemeItem();
124 
			schemeItem.setSchemeId(scheme.getId());
 126 
			schemeItem.setSchemeId(scheme.getId());
125 
			schemeItem.setItemId(itemId);
 127 
			schemeItem.setItemId(itemId);
126 
			schemeItemRepository.persist(schemeItem);
 128 
			schemeItemRepository.persist(schemeItem);
127 
		}
 129 
		}
128
130 
 
129 
	}
 131 
	}
130
132 
 
131 
	private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
 133 
	private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)
- 
 
 134 
			throws ProfitMandiBusinessException {
132 
		if(createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()){
 135 
		if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {
133 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(), "SCHM_VE_1000");
 136 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),
- 
 
 137 
					"SCHM_VE_1000");
134 
		}
 138 
		}
135 
		if(createSchemeRequest.getAmount() <= 0){
 139 
		if (createSchemeRequest.getAmount() <= 0) {
136 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "SCHM_VE_1001");
 140 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
- 
 
 141 
					"SCHM_VE_1001");
137 
		}
 142 
		}
138
143 
 
139 
		if(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()) == SchemeAmountType.PERCENTAGE && createSchemeRequest.getAmount() > 100){
 144 
		if (SchemeAmountType.valueOf(createSchemeRequest.getAmountType()) == SchemeAmountType.PERCENTAGE
- 
 
 145 
				&& createSchemeRequest.getAmount() > 100) {
140 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "SCHM_VE_1002");
 146 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
- 
 
 147 
					"SCHM_VE_1002");
141 
		}
 148 
		}
142
149 
 
- 
 
 150 
		if (createSchemeRequest.getStartDateTimeString() == null
143 
		if(createSchemeRequest.getStartDateTimeString() == null || createSchemeRequest.getStartDateTimeString().isEmpty()){
 151 
				|| createSchemeRequest.getStartDateTimeString().isEmpty()) {
144 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDateTimeString(), "SCHM_VE_1003");
 152 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE,
- 
 
 153 
					createSchemeRequest.getStartDateTimeString(), "SCHM_VE_1003");
145 
		}
 154 
		}
146
155 
 
- 
 
 156 
		if (createSchemeRequest.getEndDateTimeString() == null
147 
		if(createSchemeRequest.getEndDateTimeString() == null || createSchemeRequest.getStartDateTimeString().isEmpty()){
 157 
				|| createSchemeRequest.getStartDateTimeString().isEmpty()) {
148 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDateTimeString(), "SCHM_VE_1004");
 158 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE,
- 
 
 159 
					createSchemeRequest.getEndDateTimeString(), "SCHM_VE_1004");
149 
		}
 160 
		}
150 
	}
 161 
	}
151
162 
 
152 
	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest){
 163 
	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {
153 
		Scheme scheme = new Scheme();
 164 
		Scheme scheme = new Scheme();
154 
		scheme.setName(createSchemeRequest.getName());
 165 
		scheme.setName(createSchemeRequest.getName());
155 
		scheme.setDescription(createSchemeRequest.getDescription());
 166 
		scheme.setDescription(createSchemeRequest.getDescription());
156 
		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));
 167 
		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));
157 
		scheme.setAmountType(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()));
 168 
		scheme.setAmountType(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()));
158 
		scheme.setAmount(createSchemeRequest.getAmount());
 169 
		scheme.setAmount(createSchemeRequest.getAmount());
159 
		scheme.setStartDateTime(StringUtils.toDateTime(createSchemeRequest.getStartDateTimeString(), DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
 170 
		scheme.setStartDateTime(StringUtils.toDateTime(createSchemeRequest.getStartDateTimeString(),
- 
 
 171 
				DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
160 
		scheme.setEndDateTime(StringUtils.toDateTime(createSchemeRequest.getEndDateTimeString(), DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
 172 
		scheme.setEndDateTime(StringUtils.toDateTime(createSchemeRequest.getEndDateTimeString(),
- 
 
 173 
				DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
161 
		scheme.setCreatedBy(creatorId);
 174 
		scheme.setCreatedBy(creatorId);
162 
		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());
 175 
		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());
163 
		return scheme;
 176 
		return scheme;
164 
	}
 177 
	}
165
178 
 
166 
	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
 179 
	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
167 
		if(createSchemeRequest.getRetailerIds() == null || createSchemeRequest.getRetailerIds().isEmpty()){
 180 
		if (createSchemeRequest.getRetailerIds() == null || createSchemeRequest.getRetailerIds().isEmpty()) {
168 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "SCHM_1001");
 181 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,
- 
 
 182 
					createSchemeRequest.getRetailerIds(), "SCHM_1001");
169 
		}
 183 
		}
170 
		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(createSchemeRequest.getRetailerIds());
 184 
		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(createSchemeRequest.getRetailerIds());
171 
		if(foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()){
 185 
		if (foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()) {
172 
			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);
 186 
			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);
173 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "SCHM_1002");
 187 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,
- 
 
 188 
					createSchemeRequest.getRetailerIds(), "SCHM_1002");
174 
		}
 189 
		}
175 
	}
 190 
	}
176
191 
 
177 
	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
 192 
	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
178 
		if(createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()){
 193 
		if (createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()) {
179 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "SCHM_1003");
 194 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
- 
 
 195 
					"SCHM_1003");
180 
		}
 196 
		}
181 
		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(), ItemType.SERIALIZED);
 197 
		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(),
- 
 
 198 
				ItemType.SERIALIZED);
182 
		if(foundItemIds.size() != createSchemeRequest.getItemIds().size()){
 199 
		if (foundItemIds.size() != createSchemeRequest.getItemIds().size()) {
183 
			createSchemeRequest.getItemIds().removeAll(foundItemIds);
 200 
			createSchemeRequest.getItemIds().removeAll(foundItemIds);
184 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "SCHM_1004");
 201 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
- 
 
 202 
					"SCHM_1004");
185 
		}
 203 
		}
186 
	}
 204 
	}
187
205 
 
188 
	@Override
 206 
	@Override
189 
	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
 207 
	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
190 
		Scheme scheme = schemeRepository.selectById(schemeId);
 208 
		Scheme scheme = schemeRepository.selectById(schemeId);
191 
		if(!scheme.isRetailerAll()){
 209 
		if (!scheme.isRetailerAll()) {
192 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
 210 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
193 
			scheme.getRetailerIds().addAll(retailerIds);
 211 
			scheme.getRetailerIds().addAll(retailerIds);
194 
		}
 212 
		}
195 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
 213 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
196 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
 214 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
197 
		scheme.setItemStringMap(this.toItemStringMap(items));
 215 
		scheme.setItemStringMap(this.toItemStringMap(items));
198 
		return scheme;
 216 
		return scheme;
199 
	}
 217 
	}
200
218 
 
201 
	public Map<Integer, String> toItemStringMap(List<Item> items){
 219 
	public Map<Integer, String> toItemStringMap(List<Item> items) {
202 
		Map<Integer, String> itemMap = new HashMap<>();
 220 
		Map<Integer, String> itemMap = new HashMap<>();
203 
		for(Item item : items){
 221 
		for (Item item : items) {
204 
			itemMap.put(item.getId(), this.getItemString(item));
 222 
			itemMap.put(item.getId(), this.getItemString(item));
205 
		}
 223 
		}
206 
		return itemMap;
 224 
		return itemMap;
207 
	}
 225 
	}
208
226 
 
209 
	public String getItemString(Item item){
 227 
	public String getItemString(Item item) {
210 
		StringBuilder itemString = new StringBuilder();
 228 
		StringBuilder itemString = new StringBuilder();
211 
		if(item.getBrand() != null && !item.getBrand().isEmpty()){
 229 
		if (item.getBrand() != null && !item.getBrand().isEmpty()) {
212 
			itemString.append(item.getBrand().trim());
 230 
			itemString.append(item.getBrand().trim());
213 
		}
 231 
		}
214 
		itemString.append(" ");
 232 
		itemString.append(" ");
215 
		if(item.getModelName() != null && !item.getModelName().isEmpty()){
 233 
		if (item.getModelName() != null && !item.getModelName().isEmpty()) {
216 
			itemString.append(item.getModelName().trim());
 234 
			itemString.append(item.getModelName().trim());
217 
		}
 235 
		}
218 
		itemString.append(" ");
 236 
		itemString.append(" ");
219 
		if(item.getModelNumber() != null && !item.getModelNumber().isEmpty()){
 237 
		if (item.getModelNumber() != null && !item.getModelNumber().isEmpty()) {
220 
			itemString.append(item.getModelNumber().trim());
 238 
			itemString.append(item.getModelNumber().trim());
221 
		}
 239 
		}
222 
		itemString.append(" ");
 240 
		itemString.append(" ");
223 
		if(item.getColor() != null && !item.getColor().isEmpty()){
 241 
		if (item.getColor() != null && !item.getColor().isEmpty()) {
224 
			itemString.append(item.getColor().trim());
 242 
			itemString.append(item.getColor().trim());
225 
		}
 243 
		}
226 
		return itemString.toString();
 244 
		return itemString.toString();
227 
	}
 245 
	}
228
246 
 
229 
	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems){
 247 
	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems) {
230 
		Set<Integer> itemIds = new HashSet<>();
 248 
		Set<Integer> itemIds = new HashSet<>();
231 
		for(SchemeItem schemeItem : schemeItems){
 249 
		for (SchemeItem schemeItem : schemeItems) {
232 
			itemIds.add(schemeItem.getItemId());
 250 
			itemIds.add(schemeItem.getItemId());
233 
		}
 251 
		}
234 
		return itemIds;
 252 
		return itemIds;
235 
	}
 253 
	}
236
254 
 
237 
	@Override
 255 
	@Override
238 
	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
 256 
	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
239 
		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
 257 
		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
240 
		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
 258 
		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
241 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
 259 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
Line 245... Line 263...
245 
		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
 263 
		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
246 
		List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
 264 
		List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
247 
		this.addRetailerIdsToSchemes(retailerSchemes, schemeIdSchemeMap);
 265 
		this.addRetailerIdsToSchemes(retailerSchemes, schemeIdSchemeMap);
248 
		return this.toSchemeModels(schemeIdSchemeMap);
 266 
		return this.toSchemeModels(schemeIdSchemeMap);
249 
	}
 267 
	}
250
268 
 
251 
	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap, Map<Integer, String> itemStringMap){
 269 
	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
- 
 
 270 
			Map<Integer, String> itemStringMap) {
252 
		for(SchemeItem schemeItem : schemeItems){
 271 
		for (SchemeItem schemeItem : schemeItems) {
253 
			schemeIdSchemeMap.get(schemeItem.getSchemeId())
 272 
			schemeIdSchemeMap.get(schemeItem.getSchemeId()).getItemStringMap().put(schemeItem.getItemId(),
254 
			.getItemStringMap()
 - 
 
255 
			.put(schemeItem.getItemId(), itemStringMap.get(schemeItem.getItemId()));
 273 
					itemStringMap.get(schemeItem.getItemId()));
256 
		}
 274 
		}
257 
	}
 275 
	}
258
276 
 
259 
	private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap){
 277 
	private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap) {
260 
		for(RetailerScheme retailerScheme : retailerSchemes){
 278 
		for (RetailerScheme retailerScheme : retailerSchemes) {
261 
			schemeIdSchemeMap.get(retailerScheme.getSchemeId())
 279 
			schemeIdSchemeMap.get(retailerScheme.getSchemeId()).getRetailerIds().add(retailerScheme.getRetailerId());
262 
			.getRetailerIds()
 - 
 
263 
			.add(retailerScheme.getRetailerId());
 - 
 
264 
		}
 280 
		}
265 
	}
 281 
	}
266
282 
 
267 
	private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap){
 283 
	private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {
268 
		List<SchemeModel> schemeModels = new ArrayList<>();
 284 
		List<SchemeModel> schemeModels = new ArrayList<>();
269 
		for(Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()){
 285 
		for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {
270 
			schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
 286 
			schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
271 
		}
 287 
		}
272 
		return schemeModels;
 288 
		return schemeModels;
273 
	}
 289 
	}
274
290 
 
275 
	private SchemeModel toSchemeModel(Scheme scheme){
 291 
	private SchemeModel toSchemeModel(Scheme scheme) {
276 
		SchemeModel schemeModel = new SchemeModel();
 292 
		SchemeModel schemeModel = new SchemeModel();
277 
		schemeModel.setSchemeId(scheme.getId());
 293 
		schemeModel.setSchemeId(scheme.getId());
278 
		schemeModel.setName(scheme.getName());
 294 
		schemeModel.setName(scheme.getName());
279 
		schemeModel.setDescription(scheme.getDescription());
 295 
		schemeModel.setDescription(scheme.getDescription());
280 
		schemeModel.setSchemeType(scheme.getType().toString());
 296 
		schemeModel.setSchemeType(scheme.getType().toString());
Line 292... Line 308...
292 
	}
 308 
	}
293 
 
 309 
 
294 
	@Override
 310 
	@Override
295 
	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
 311 
	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
296 
		Scheme scheme = schemeRepository.selectById(schemeId);
 312 
		Scheme scheme = schemeRepository.selectById(schemeId);
297 
		if(scheme.getActiveTimestamp() != null){
 313 
		if (scheme.getActiveTimestamp() != null) {
298 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "SCHM_1005");
 314 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
- 
 
 315 
					"SCHM_1005");
299 
		}
 316 
		}
300 
		if(scheme.getExpireTimestamp() != null){
 317 
		if (scheme.getExpireTimestamp() != null) {
301 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "SCHM_1006");
 318 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
- 
 
 319 
					"SCHM_1006");
302 
		}
 320 
		}
303 
		scheme.setActiveTimestamp(LocalDateTime.now());
 321 
		scheme.setActiveTimestamp(LocalDateTime.now());
304 
		schemeRepository.persist(scheme);
 322 
		schemeRepository.persist(scheme);
305 
		if(scheme.getType() == SchemeType.IN){
 323 
		if (scheme.getType() == SchemeType.IN) {
306 
			this.processPreviousPurchases(scheme);
 324 
			this.processPreviousPurchases(scheme);
307 
		}else if(scheme.getType() == SchemeType.OUT){
 325 
		} else if (scheme.getType() == SchemeType.OUT) {
308 
			this.processPreviousSales(scheme);
 326 
			this.processPreviousSales(scheme);
309 
		}
 327 
		}
310 
	}
 328 
	}
311
329 
 
312 
	private void processPreviousPurchases(Scheme scheme) throws ProfitMandiBusinessException{
 330 
	private void processPreviousPurchases(Scheme scheme) throws ProfitMandiBusinessException {
313 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectBetweenDates(scheme.getStartDateTime(), scheme.getEndDateTime());
 331 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectBetweenDates(scheme.getStartDateTime(),
- 
 
 332 
				scheme.getEndDateTime());
314 
		if(inventoryItems.isEmpty()) {
 333 
		if (inventoryItems.isEmpty()) {
315 
			return;
 334 
			return;
316 
		}
 335 
		}
317 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
 336 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
318 
		if(itemIds.isEmpty()) {
 337 
		if (itemIds.isEmpty()) {
319 
			return;
 338 
			return;
320 
		}
 339 
		}
321 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
 340 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
322 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
 341 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
323 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems, itemIds, true);
 342 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,
- 
 
 343 
				itemIds, true);
324 
		if(completedInventoryItems.isEmpty()) {
 344 
		if (completedInventoryItems.isEmpty()) {
325 
			return;
 345 
			return;
326 
		}
 346 
		}
327 
		if(scheme.isRetailerAll()){
 347 
		if (scheme.isRetailerAll()) {
328 
			for(InventoryItem inventoryItem : completedInventoryItems){
 348 
			for (InventoryItem inventoryItem : completedInventoryItems) {
329 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
 349 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
330 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_IN, "Added SCHEME_IN for item "+itemStringMap.get(inventoryItem.getItemId())+" against invoiceNumber ["+inventoryItem.getPurchase().getPurchaseReference() +"]", cashback);
 350 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
- 
 
 351 
						WalletReferenceType.SCHEME_IN,
- 
 
 352 
						"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())
- 
 
 353 
								+ " against invoiceNumber [" + inventoryItem.getPurchase().getPurchaseReference() + "]",
- 
 
 354 
						cashback);
331 
			}
 355 
			}
332 
		}else{
 356 
		} else {
333 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
 357 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
334 
			for(InventoryItem inventoryItem : completedInventoryItems){
 358 
			for (InventoryItem inventoryItem : completedInventoryItems) {
335 
				if(retailerIds.contains(inventoryItem.getFofoId())){
 359 
				if (retailerIds.contains(inventoryItem.getFofoId())) {
336 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
 360 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
337 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_IN, "Added SCHEME_IN for item "+itemStringMap.get(inventoryItem.getItemId())+" against invoiceNumber ["+inventoryItem.getPurchase().getPurchaseReference() +"]", cashback);
 361 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
- 
 
 362 
							WalletReferenceType.SCHEME_IN,
- 
 
 363 
							"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())
- 
 
 364 
									+ " against invoiceNumber [" + inventoryItem.getPurchase().getPurchaseReference()
- 
 
 365 
									+ "]",
- 
 
 366 
							cashback);
338 
				}
 367 
				}
339 
			}
 368 
			}
340 
		}
 369 
		}
341
370 
 
342 
	}
 371 
	}
343
- 
 
344
- 
 
345
372 
 
346 
	private Map<Integer, Integer> toInventoryItemIdFofoOrderIdMap(List<FofoLineItem> fofoLineItems, Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap){
 373 
	private Map<Integer, Integer> toInventoryItemIdFofoOrderIdMap(List<FofoLineItem> fofoLineItems,
- 
 
 374 
			Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap) {
347 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = new HashMap<>();
 375 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = new HashMap<>();
348
376 
 
349 
		for(FofoLineItem fofoLineItem : fofoLineItems){
 377 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
350 
			inventoryItemIdFofoOrderIdMap.put(
 - 
 
351 
					fofoLineItem.getInventoryItemId(),
 378 
			inventoryItemIdFofoOrderIdMap.put(fofoLineItem.getInventoryItemId(),
352 
					fofoOrderItemIdFofoOrderItemMap.get(fofoLineItem.getFofoOrderItemId()).getOrderId());
 379 
					fofoOrderItemIdFofoOrderItemMap.get(fofoLineItem.getFofoOrderItemId()).getOrderId());
353 
		}
 380 
		}
354 
		return inventoryItemIdFofoOrderIdMap;
 381 
		return inventoryItemIdFofoOrderIdMap;
355 
	}
 382 
	}
356
383 
 
357 
	private void processPreviousSales(Scheme scheme) throws ProfitMandiBusinessException{
 384 
	private void processPreviousSales(Scheme scheme) throws ProfitMandiBusinessException {
358 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectBetweenDates(scheme.getStartDateTime(), scheme.getEndDateTime());
 385 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectBetweenDates(scheme.getStartDateTime(),
- 
 
 386 
				scheme.getEndDateTime());
359
387 
 
360 
		if(fofoOrderItems.isEmpty()){
 388 
		if (fofoOrderItems.isEmpty()) {
361 
			return;
 389 
			return;
362 
		}
 390 
		}
363
- 
 
364 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = this.toFofoOrderItemIdFofoOrderItemMap(fofoOrderItems);
 - 
 
365 
 
 391 
 
- 
 
 392 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = this
- 
 
 393 
				.toFofoOrderItemIdFofoOrderItemMap(fofoOrderItems);
- 
 
 394 
 
- 
 
 395 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository
366 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIdFofoOrderItemMap.keySet());
 396 
				.selectByFofoOrderItemIds(fofoOrderItemIdFofoOrderItemMap.keySet());
367
397 
 
368 
		if(fofoLineItems.isEmpty()) {
 398 
		if (fofoLineItems.isEmpty()) {
369 
			return;
 399 
			return;
370 
		}
 400 
		}
371
401 
 
372 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = this.toInventoryItemIdFofoOrderIdMap(fofoLineItems, fofoOrderItemIdFofoOrderItemMap);
 402 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = this.toInventoryItemIdFofoOrderIdMap(fofoLineItems,
- 
 
 403 
				fofoOrderItemIdFofoOrderItemMap);
373
404 
 
374 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdFofoOrderIdMap.keySet());
 405 
		List<InventoryItem> inventoryItems = inventoryItemRepository
- 
 
 406 
				.selectByIds(inventoryItemIdFofoOrderIdMap.keySet());
375
407 
 
376 
		if(inventoryItems.isEmpty()) {
 408 
		if (inventoryItems.isEmpty()) {
377 
			return;
 409 
			return;
378 
		}
 410 
		}
379
411 
 
380 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
 412 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
381
413 
 
382 
		if(itemIds.isEmpty()) {
 414 
		if (itemIds.isEmpty()) {
383 
			return;
 415 
			return;
384 
		}
 416 
		}
385
417 
 
386 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems, itemIds, false);
 418 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,
387
419 
				itemIds, false);
388
420 
 
389 
		if(scheme.isRetailerAll()){
 421 
		if (scheme.isRetailerAll()) {
390 
			for(InventoryItem inventoryItem : completedInventoryItems){
 422 
			for (InventoryItem inventoryItem : completedInventoryItems) {
391 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
 423 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
392 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
 424 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
- 
 
 425 
						WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
393 
			}
 426 
			}
394 
		}else{
 427 
		} else {
395 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
 428 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
396 
			for(InventoryItem inventoryItem : completedInventoryItems){
 429 
			for (InventoryItem inventoryItem : completedInventoryItems) {
397 
				if(retailerIds.contains(inventoryItem.getFofoId())){
 430 
				if (retailerIds.contains(inventoryItem.getFofoId())) {
398 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
 431 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
- 
 
 432 
					walletService.addAmountToWallet(inventoryItem.getFofoId(),
399 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItemIdFofoOrderIdMap.get(inventoryItem.getId()), WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
 433 
							inventoryItemIdFofoOrderIdMap.get(inventoryItem.getId()), WalletReferenceType.SCHEME_OUT,
- 
 
 434 
							"Added for SCHEME_OUT", cashback);
400 
				}
 435 
				}
401 
			}
 436 
			}
402 
		}
 437 
		}
403 
	}
 438 
	}
404
439 
 
405 
	private Map<Integer, FofoOrderItem> toFofoOrderItemIdFofoOrderItemMap(List<FofoOrderItem> fofoOrderItems){
 440 
	private Map<Integer, FofoOrderItem> toFofoOrderItemIdFofoOrderItemMap(List<FofoOrderItem> fofoOrderItems) {
406 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = new HashMap<>();
 441 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = new HashMap<>();
407 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
 442 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
408 
			fofoOrderItemIdFofoOrderItemMap.put(fofoOrderItem.getId(), fofoOrderItem);
 443 
			fofoOrderItemIdFofoOrderItemMap.put(fofoOrderItem.getId(), fofoOrderItem);
409 
		}
 444 
		}
410 
		return fofoOrderItemIdFofoOrderItemMap;
 445 
		return fofoOrderItemIdFofoOrderItemMap;
411 
	}
 446 
	}
412
447 
 
413 
	private List<InventoryItem> toFilteredPurchaseCompletedInventoryItems(List<InventoryItem> inventoryItems, List<Integer> itemIds, boolean purchase){
 448 
	private List<InventoryItem> toFilteredPurchaseCompletedInventoryItems(List<InventoryItem> inventoryItems,
- 
 
 449 
			List<Integer> itemIds, boolean purchase) {
414 
		List<InventoryItem> completedInventoryItems = new ArrayList<>();
 450 
		List<InventoryItem> completedInventoryItems = new ArrayList<>();
415 
		for(InventoryItem inventoryItem : inventoryItems){
 451 
		for (InventoryItem inventoryItem : inventoryItems) {
416 
			if(purchase && inventoryItem.getPurchase().getCompleteTimestamp() != null && itemIds.contains(inventoryItem.getItemId())){
 452 
			if (purchase && inventoryItem.getPurchase().getCompleteTimestamp() != null
- 
 
 453 
					&& itemIds.contains(inventoryItem.getItemId())) {
417 
				completedInventoryItems.add(inventoryItem);
 454 
				completedInventoryItems.add(inventoryItem);
418 
			}else if(!purchase && itemIds.contains(inventoryItem.getItemId())){
 455 
			} else if (!purchase && itemIds.contains(inventoryItem.getItemId())) {
419 
				completedInventoryItems.add(inventoryItem);
 456 
				completedInventoryItems.add(inventoryItem);
420 
			}
 457 
			}
421 
		}
 458 
		}
422 
		return completedInventoryItems;
 459 
		return completedInventoryItems;
423 
	}
 460 
	}
424
461 
 
425 
	@Override
 462 
	@Override
426 
	public void expireSchemeById(int schemeId) throws ProfitMandiBusinessException {
 463 
	public void expireSchemeById(int schemeId) throws ProfitMandiBusinessException {
427 
		Scheme scheme = schemeRepository.selectById(schemeId);
 464 
		Scheme scheme = schemeRepository.selectById(schemeId);
428 
		if(scheme.getActiveTimestamp() == null){
 465 
		if (scheme.getActiveTimestamp() == null) {
429 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "SCHM_1007");
 466 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
- 
 
 467 
					"SCHM_1007");
430 
		}
 468 
		}
431 
		if(scheme.getExpireTimestamp() != null){
 469 
		if (scheme.getExpireTimestamp() != null) {
432 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "SCHM_1008");
 470 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
- 
 
 471 
					"SCHM_1008");
433 
		}
 472 
		}
434 
		scheme.setExpireTimestamp(LocalDateTime.now());
 473 
		scheme.setExpireTimestamp(LocalDateTime.now());
435 
		schemeRepository.persist(scheme);
 474 
		schemeRepository.persist(scheme);
436 
	}
 475 
	}
437
476 
 
438 
	private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes){
 477 
	private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {
439 
		Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
 478 
		Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
440 
		for(Scheme scheme : schemes){
 479 
		for (Scheme scheme : schemes) {
441 
			schemeIdSchemeMap.put(scheme.getId(), scheme);
 480 
			schemeIdSchemeMap.put(scheme.getId(), scheme);
442 
		}
 481 
		}
443 
		return schemeIdSchemeMap;
 482 
		return schemeIdSchemeMap;
444 
	}
 483 
	}
445
484 
 
446 
	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap){
 485 
	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap) {
447 
		Set<Integer> schemeIds = new HashSet<>();
 486 
		Set<Integer> schemeIds = new HashSet<>();
448 
		for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
 487 
		for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
449 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
 488 
			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
450 
				schemeIds.add(scheme.getId());
 489 
				schemeIds.add(scheme.getId());
451 
			}
 490 
			}
452 
		}
 491 
		}
453 
		return schemeIds;
 492 
		return schemeIds;
454 
	}
 493 
	}
455
494 
 
456 
	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap){
 495 
	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap) {
457 
		Set<Integer> schemeIds = new HashSet<>();
 496 
		Set<Integer> schemeIds = new HashSet<>();
458 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()){
 497 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()) {
459 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
 498 
			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
460 
				schemeIds.add(scheme.getId());
 499 
				schemeIds.add(scheme.getId());
461 
			}
 500 
			}
462 
		}
 501 
		}
463 
		return schemeIds;
 502 
		return schemeIds;
464 
	}
 503 
	}
465
504 
 
466 
	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems){
 505 
	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems) {
467 
		Set<Integer> itemIds = new HashSet<>();
 506 
		Set<Integer> itemIds = new HashSet<>();
468 
		for(InventoryItem inventoryItem : inventoryItems){
 507 
		for (InventoryItem inventoryItem : inventoryItems) {
469 
			itemIds.add(inventoryItem.getItemId());
 508 
			itemIds.add(inventoryItem.getItemId());
470 
		}
 509 
		}
471 
		return itemIds;
 510 
		return itemIds;
472 
	}
 511 
	}
473
512 
 
474 
	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems){
 513 
	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems) {
475 
		Set<Integer> itemIds = new HashSet<>();
 514 
		Set<Integer> itemIds = new HashSet<>();
476 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
 515 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
477 
			itemIds.add(fofoOrderItem.getItemId());
 516 
			itemIds.add(fofoOrderItem.getItemId());
478 
		}
 517 
		}
479 
		return itemIds;
 518 
		return itemIds;
480 
	}
 519 
	}
481
520 
 
482 
	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes){
 521 
	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
483 
		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
 522 
		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
484 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
 523 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
485 
		for(SchemeItem schemeItem : schemeItems){
 524 
		for (SchemeItem schemeItem : schemeItems) {
486 
			if(!itemIdSchemesMap.containsKey(schemeItem.getItemId())){
 525 
			if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {
487 
				Set<Scheme> schemesSet = new HashSet<>();
 526 
				Set<Scheme> schemesSet = new HashSet<>();
488 
				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
 527 
				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
489 
				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
 528 
				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
490 
			}else{
 529 
			} else {
491 
				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
 530 
				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
492 
			}
 531 
			}
493 
		}
 532 
		}
494 
		return itemIdSchemesMap;
 533 
		return itemIdSchemesMap;
495 
	}
 534 
	}
496 
 
 535 
 
497 
	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes, List<InventoryItem> inventoryItems){
 536 
	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,
- 
 
 537 
			List<InventoryItem> inventoryItems) {
498 
		Set<Integer> schemeIds = new HashSet<>();
 538 
		Set<Integer> schemeIds = new HashSet<>();
499 
		for(Scheme scheme : schemes){
 539 
		for (Scheme scheme : schemes) {
500 
			schemeIds.add(scheme.getId());
 540 
			schemeIds.add(scheme.getId());
501 
		}
 541 
		}
502 
		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
 542 
		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
503 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
 543 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
504
544 
 
505 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
 545 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
506 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
 546 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
507 
		for(InventoryItem inventoryItem : inventoryItems){
 547 
		for (InventoryItem inventoryItem : inventoryItems) {
508 
			if(itemIdSchemesMap.containsKey(inventoryItem.getItemId())){
 548 
			if (itemIdSchemesMap.containsKey(inventoryItem.getItemId())) {
509 
				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
 549 
				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
510 
			}
 550 
			}
511 
		}
 551 
		}
512 
		return inventoryItemSchemsMap;
 552 
		return inventoryItemSchemsMap;
513 
	}
 553 
	}
514
554 
 
515 
	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes, List<FofoOrderItem> fofoOrderItems){
 555 
	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes,
- 
 
 556 
			List<FofoOrderItem> fofoOrderItems) {
516 
		Set<Integer> schemeIds = new HashSet<>();
 557 
		Set<Integer> schemeIds = new HashSet<>();
517 
		for(Scheme scheme : schemes){
 558 
		for (Scheme scheme : schemes) {
518 
			schemeIds.add(scheme.getId());
 559 
			schemeIds.add(scheme.getId());
519 
		}
 560 
		}
520 
		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
 561 
		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
521 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
 562 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
522
563 
 
523 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
 564 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
524
565 
 
525 
		if(!schemeItems.isEmpty()){
 566 
		if (!schemeItems.isEmpty()) {
526 
			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
 567 
			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
527 
			for(FofoOrderItem fofoOrderItem : fofoOrderItems){
 568 
			for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
528 
				if(itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())){
 569 
				if (itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())) {
529 
					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
 570 
					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
530 
				}
 571 
				}
531 
			}
 572 
			}
532 
		}
 573 
		}
533 
		return fofoOrderItemSchemsMap;
 574 
		return fofoOrderItemSchemsMap;
534 
	}
 575 
	}
535
576 
 
536 
	@Override
 577 
	@Override
537 
	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
 578 
	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
538 
		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
 579 
		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
539 
		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
 580 
		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
540 
		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
 581 
		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
541 
		if(purchase.getCompleteTimestamp() != null) {
 582 
		if (purchase.getCompleteTimestamp() != null) {
542 
			List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(), retailerId);
 583 
			List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(),
- 
 
 584 
					retailerId);
543 
			LocalDateTime billingTimestamp = purchase.getCreateTimestamp();
 585 
			LocalDateTime billingTimestamp = purchase.getCreateTimestamp();
544 
			if(!orders.isEmpty()){
 586 
			if (!orders.isEmpty()) {
545 
				billingTimestamp = orders.get(0).getBillingTimestamp();
 587 
				billingTimestamp = orders.get(0).getBillingTimestamp();
546 
			}
 588 
			}
547 
			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, billingTimestamp);
 589 
			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, billingTimestamp);
548 
			float totalCashback = 0;
 590 
			float totalCashback = 0;
549 
			if(schemes.isEmpty()){
 591 
			if (schemes.isEmpty()) {
550 
				return;
 592 
				return;
551 
			}
 593 
			}
552 
			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
 594 
			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
553 
			LOGGER.info("SchemeIn filter inventoryItems {}", inventoryItems);
 595 
			LOGGER.info("SchemeIn filter inventoryItems {}", inventoryItems);
554
596 
 
555 
			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes, inventoryItems);
 597 
			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,
- 
 
 598 
					inventoryItems);
556
599 
 
557 
			if(inventoryItemSchemesMap.isEmpty()){
 600 
			if (inventoryItemSchemesMap.isEmpty()) {
558 
				return;
 601 
				return;
559 
			}
 602 
			}
560 
			Map<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesMap = new HashMap<>();
 603 
			Map<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesMap = new HashMap<>();
561 
			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
 604 
			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
562 
			Set<Integer> itemIds = new HashSet<>();
 605 
			Set<Integer> itemIds = new HashSet<>();
563
606 
 
564 
			for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
 607 
			for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
565 
				Set<Scheme> notAllSchemes = new HashSet<>();
 608 
				Set<Scheme> notAllSchemes = new HashSet<>();
566 
				Set<Scheme> allSchemes = new HashSet<>();
 609 
				Set<Scheme> allSchemes = new HashSet<>();
567 
				for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
 610 
				for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
568 
					if(!scheme.isRetailerAll()){
 611 
					if (!scheme.isRetailerAll()) {
569 
						notAllSchemes.add(scheme);
 612 
						notAllSchemes.add(scheme);
570 
					}else{
 613 
					} else {
571 
						allSchemes.add(scheme);
 614 
						allSchemes.add(scheme);
572 
					}
 615 
					}
573 
				}
 616 
				}
574 
				notAllInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), notAllSchemes);
 617 
				notAllInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), notAllSchemes);
575 
				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
 618 
				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
576 
				itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());
 619 
				itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());
577 
			}
 620 
			}
578
621 
 
579 
			List<Item> items = itemRepository.selectByIds(itemIds);
 622 
			List<Item> items = itemRepository.selectByIds(itemIds);
580 
			Map<Integer, String> itemStringMap = this.toItemStringMap(items);
 623 
			Map<Integer, String> itemStringMap = this.toItemStringMap(items);
581
624 
 
582 
			Map<Integer, Float> itemIdCashbackMap = new HashMap<>();
 - 
 
583 
			Map<Integer, Integer> itemIdCashbackCountMap = new HashMap<>();
 625 
			int itemsCount = 0;
584
- 
 
585 
			for(Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap.entrySet()){
 626 
			for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
- 
 
 627 
					.entrySet()) {
- 
 
 628 
				float inventoryItemCashback = 0;
586 
				for(Scheme scheme : allInventoryItemSchemesEntry.getValue()){
 629 
				for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
587 
					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
 630 
					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
588 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
 631 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
589 
					if(!itemIdCashbackMap.containsKey(inventoryItem.getItemId())){
 - 
 
590 
						itemIdCashbackMap.put(inventoryItem.getItemId(), cashback);
 632 
					inventoryItemCashback += cashback;
591 
						itemIdCashbackCountMap.put(inventoryItem.getItemId(), 1);
 - 
 
592 
					}else{
 633 
				}
593 
						itemIdCashbackMap.put(inventoryItem.getItemId(), itemIdCashbackMap.get(inventoryItem.getItemId()) + cashback);
 634 
				if (inventoryItemCashback > 0) {
594 
						itemIdCashbackCountMap.put(inventoryItem.getItemId(), itemIdCashbackCountMap.get(inventoryItem.getItemId()) + 1);
 635 
					totalCashback += inventoryItemCashback;
595 
					}
 636 
					itemsCount++;
596 
					totalCashback = totalCashback + cashback;
 - 
 
597 
				}
 637 
				}
598 
			}
 638 
			}
599
- 
 
600 
			//Map<Integer, Float> itemIdCashbackMap = new HashMap<>();
 - 
 
601
639 
 
602
- 
 
603 
			Set<Integer> schemeIds = this.inventoryItemSchemesMapToSchemeIds(notAllInventoryItemSchemesMap);
 640 
			Set<Integer> schemeIds = this.inventoryItemSchemesMapToSchemeIds(notAllInventoryItemSchemesMap);
604 
			if(!schemeIds.isEmpty()){
 641 
			if (!schemeIds.isEmpty()) {
605 
				List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
 642 
				List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
606 
				for(Map.Entry<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesEntry : notAllInventoryItemSchemesMap.entrySet()){
 643 
				for (Map.Entry<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesEntry : notAllInventoryItemSchemesMap
- 
 
 644 
						.entrySet()) {
- 
 
 645 
					float inventoryItemCashback = 0;
607 
					for(Scheme scheme : notAllInventoryItemSchemesEntry.getValue()){
 646 
					for (Scheme scheme : notAllInventoryItemSchemesEntry.getValue()) {
608 
						if(foundSchemeIds.contains(scheme.getId())){
 647 
						if (foundSchemeIds.contains(scheme.getId())) {
609 
							InventoryItem inventoryItem = notAllInventoryItemSchemesEntry.getKey();
 648 
							InventoryItem inventoryItem = notAllInventoryItemSchemesEntry.getKey();
610 
							float cashback = this.createSchemeInOut(scheme, inventoryItem);
 649 
							float cashback = this.createSchemeInOut(scheme, inventoryItem);
611 
							if(!itemIdCashbackMap.containsKey(inventoryItem.getItemId())){
 - 
 
612 
								itemIdCashbackMap.put(inventoryItem.getItemId(), cashback);
 - 
 
613 
								itemIdCashbackCountMap.put(inventoryItem.getItemId(), 1);
 - 
 
614 
							}else{
 - 
 
615 
								itemIdCashbackMap.put(inventoryItem.getItemId(), itemIdCashbackMap.get(inventoryItem.getItemId()) + cashback);
 - 
 
616 
								itemIdCashbackCountMap.put(inventoryItem.getItemId(), itemIdCashbackCountMap.get(inventoryItem.getItemId()) + 1);
 - 
 
617 
							}
 - 
 
618 
							totalCashback = totalCashback + cashback;
 650 
							inventoryItemCashback += cashback;
619 
						}
 651 
						}
620 
					}
 652 
					}
- 
 
 653 
					if (inventoryItemCashback > 0) {
- 
 
 654 
						totalCashback += inventoryItemCashback;
- 
 
 655 
						itemsCount++;
- 
 
 656 
					}
621 
				}
 657 
				}
622 
			}
 658 
			}
623 
			for(Map.Entry<Integer, Float> itemIdCashbackEntry : itemIdCashbackMap.entrySet()){
 - 
 
624 
				walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,
 659 
			walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,
625 
						itemIdCashbackCountMap.get(itemIdCashbackEntry.getKey())+"pcs of item "+
 - 
 
626 
						itemStringMap.get(itemIdCashbackEntry.getKey()) +
 - 
 
627 
				" Added for SCHEME_IN against invoiceNumber ["+purchase.getPurchaseReference()+"]", itemIdCashbackEntry.getValue());
 660 
					"Added for SCHEME IN against invoice " + purchase.getPurchaseReference() + " (total" + itemsCount + "pcs)", totalCashback);
628 
			}
 - 
 
629 
			purchase.setCashback(totalCashback);
 661 
			purchase.setCashback(totalCashback);
630 
			purchaseRepository.persist(purchase);
 662 
			purchaseRepository.persist(purchase);
631 
		}
 663 
		}
632 
	}
 664 
	}
633
665 
 
634 
	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem){
 666 
	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem) {
635 
		SchemeInOut schemeInOut = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
 667 
		SchemeInOut schemeInOut = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
636 
		float amount = 0;
 668 
		float amount = 0;
637 
		if(schemeInOut == null) {
 669 
		if (schemeInOut == null) {
638 
			schemeInOut = new SchemeInOut();
 670 
			schemeInOut = new SchemeInOut();
639 
			amount = this.getAmount(inventoryItem, scheme);
 671 
			amount = this.getAmount(inventoryItem, scheme);
640 
			schemeInOut.setSchemeId(scheme.getId());
 672 
			schemeInOut.setSchemeId(scheme.getId());
641 
			schemeInOut.setInventoryItemId(inventoryItem.getId());
 673 
			schemeInOut.setInventoryItemId(inventoryItem.getId());
642 
			schemeInOut.setAmount(amount);
 674 
			schemeInOut.setAmount(amount);
643 
			schemeInOutRepository.persist(schemeInOut);
 675 
			schemeInOutRepository.persist(schemeInOut);
644 
		}
 676 
		}
645 
		return amount;
 677 
		return amount;
646 
	}
 678 
	}
647
679 
 
648 
	private float getAmount(InventoryItem inventoryItem, Scheme scheme){
 680 
	private float getAmount(InventoryItem inventoryItem, Scheme scheme) {
649 
		float amount = 0;
 681 
		float amount = 0;
650 
		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
 682 
		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
651 
		float taxableSellingPrice = inventoryItem.getUnitPrice() / (1 + totalTaxRate / 100);
 683 
		float taxableSellingPrice = inventoryItem.getUnitPrice() / (1 + totalTaxRate / 100);
652
684 
 
653 
		if(scheme.getAmountType() == SchemeAmountType.PERCENTAGE){
 685 
		if (scheme.getAmountType() == SchemeAmountType.PERCENTAGE) {
654 
			amount = taxableSellingPrice * scheme.getAmount() / 100;
 686 
			amount = taxableSellingPrice * scheme.getAmount() / 100;
655 
		}else{
 687 
		} else {
656 
			amount = scheme.getAmount();
 688 
			amount = scheme.getAmount();
657 
		}
 689 
		}
658 
		return amount;
 690 
		return amount;
659 
	}
 691 
	}
660
692 
 
661 
	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems){
 693 
	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems) {
662 
		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
 694 
		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
663 
		for(InventoryItem inventoryItem : inventoryItems){
 695 
		for (InventoryItem inventoryItem : inventoryItems) {
664 
			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
 696 
			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
665 
		}
 697 
		}
666 
		return itemIdInventoryItemMap;
 698 
		return itemIdInventoryItemMap;
667 
	}
 699 
	}
668
- 
 
669
700 
 
670 
	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems){
 701 
	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems) {
671 
		Set<Integer> inventoryItemIds = new HashSet<>();
 702 
		Set<Integer> inventoryItemIds = new HashSet<>();
672 
		//Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
 703 
		// Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap =
- 
 
 704 
		// this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
673 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
 705 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
674 
			for(FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()){
 706 
			for (FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()) {
675 
				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
 707 
				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
676 
			}
 708 
			}
677 
		}
 709 
		}
678 
		return inventoryItemIds;
 710 
		return inventoryItemIds;
679 
	}
 711 
	}
Line 682... Line 714...
682 
	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
 714 
	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
683 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
 715 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
684 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, LocalDateTime.now());
 716 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, LocalDateTime.now());
685 
		LOGGER.info("Active Schemes {}", schemes);
 717 
		LOGGER.info("Active Schemes {}", schemes);
686 
		float totalCashback = 0;
 718 
		float totalCashback = 0;
687 
		if(schemes.isEmpty()){
 719 
		if (schemes.isEmpty()) {
688 
			return;
 720 
			return;
689 
		}
 721 
		}
690
722 
 
691 
		List<FofoOrderItem> fofoOrderItems = orderService.getByOrderId(fofoOrderId);
 723 
		List<FofoOrderItem> fofoOrderItems = orderService.getByOrderId(fofoOrderId);
692 
		//LOGGER.info("fofoOrderItems {}", fofoOrderItems);
 724 
		// LOGGER.info("fofoOrderItems {}", fofoOrderItems);
693
725 
 
694 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes, fofoOrderItems);
 726 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes,
- 
 
 727 
				fofoOrderItems);
695
728 
 
696 
		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
 729 
		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
697
730 
 
698 
		if(fofoOrderItemSchemesMap.isEmpty()){
 731 
		if (fofoOrderItemSchemesMap.isEmpty()) {
699 
			return;
 732 
			return;
700 
		}
 733 
		}
701
734 
 
702 
		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
 735 
		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
703
736 
 
704 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
 737 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
705
738 
 
706 
		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this.toInventoryItemIdInventoryItemMap(inventoryItems);
 739 
		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this
- 
 
 740 
				.toInventoryItemIdInventoryItemMap(inventoryItems);
707
741 
 
708 
		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
 742 
		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
709 
		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
 743 
		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
710
744 
 
711 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()){
 745 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()) {
712 
			Set<Scheme> notAllSchemes = new HashSet<>();
 746 
			Set<Scheme> notAllSchemes = new HashSet<>();
713 
			Set<Scheme> allSchemes = new HashSet<>();
 747 
			Set<Scheme> allSchemes = new HashSet<>();
714 
			for(Scheme scheme : fofoOrderItemSchemesEntry.getValue()){
 748 
			for (Scheme scheme : fofoOrderItemSchemesEntry.getValue()) {
715 
				if(!scheme.isRetailerAll()){
 749 
				if (!scheme.isRetailerAll()) {
716 
					notAllSchemes.add(scheme);
 750 
					notAllSchemes.add(scheme);
717 
				}else{
 751 
				} else {
718 
					allSchemes.add(scheme);
 752 
					allSchemes.add(scheme);
719 
				}
 753 
				}
720 
			}
 754 
			}
721 
			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
 755 
			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
722 
			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
 756 
			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
723 
		}
 757 
		}
724
758 
 
725 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap.entrySet()){
 759 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap
- 
 
 760 
				.entrySet()) {
726 
			for(FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
 761 
			for (FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
727 
				for(Scheme scheme : allFofoOrderItemSchemesEntry.getValue()){
 762 
				for (Scheme scheme : allFofoOrderItemSchemesEntry.getValue()) {
- 
 
 763 
					float cashback = this.createSchemeInOut(scheme,
728 
					float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
 764 
							inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
729 
					totalCashback = totalCashback + cashback;
 765 
					totalCashback = totalCashback + cashback;
730 
				}
 766 
				}
731 
			}
 767 
			}
732 
		}
 768 
		}
733
769 
 
734 
		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
 770 
		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
735
771 
 
736 
		if(!schemeIds.isEmpty()){
 772 
		if (!schemeIds.isEmpty()) {
737 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
 773 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
738
774 
 
739 
			for(Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap.entrySet()){
 775 
			for (Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap
- 
 
 776 
					.entrySet()) {
740 
				for(FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
 777 
				for (FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
741 
					for(Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()){
 778 
					for (Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()) {
742 
						if(foundSchemeIds.contains(scheme.getId())){
 779 
						if (foundSchemeIds.contains(scheme.getId())) {
- 
 
 780 
							float cashback = this.createSchemeInOut(scheme,
743 
							float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
 781 
									inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
744 
							totalCashback = totalCashback + cashback;
 782 
							totalCashback = totalCashback + cashback;
745 
						}
 783 
						}
746 
					}
 784 
					}
747 
				}
 785 
				}
748 
			}
786 
			}
749 
		}
 787 
		}
750 
		if(totalCashback > 0){
 788 
		if (totalCashback > 0) {
751 
			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", totalCashback);
 789 
			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT,
- 
 
 790 
					"Added for SCHEME_OUT", totalCashback);
752 
			fofoOrder.setCashback(totalCashback);
 791 
			fofoOrder.setCashback(totalCashback);
753 
			fofoOrderRepository.persist(fofoOrder);
 792 
			fofoOrderRepository.persist(fofoOrder);
754 
		}
 793 
		}
755 
	}
 794 
	}
756
795 
 
757 
}
 796 
}