Subversion Repositories SmartDukaan

Rev

Rev 3719 | Rev 5106 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2651 rajveer 1 
package in.shop2020.util;
2 
 
3 
import in.shop2020.metamodel.core.Entity;
4 
import in.shop2020.metamodel.core.Slide;
4802 amit.gupta 5 
import in.shop2020.metamodel.definitions.Catalog;
6 
import in.shop2020.metamodel.definitions.Category;
7 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
2651 rajveer 8 
import in.shop2020.metamodel.util.CreationUtils;
9 
import in.shop2020.metamodel.util.ExpandedBullet;
10 
import in.shop2020.metamodel.util.ExpandedEntity;
11 
import in.shop2020.metamodel.util.ExpandedFeature;
12 
import in.shop2020.metamodel.util.ExpandedSlide;
13 
 
14 
import java.util.ArrayList;
15 
import java.util.Arrays;
16 
import java.util.Collection;
17 
import java.util.HashMap;
18 
import java.util.List;
19 
import java.util.Map;
20 
import java.util.Map.Entry;
2726 rajveer 21 
import java.util.Set;
2651 rajveer 22 
 
23 
import org.apache.commons.lang.StringUtils;
24 
 
25 
 
26 
public class AccessoriesFinder {
4802 amit.gupta 27 
	DefinitionsContainer defContainer = Catalog.getInstance().getDefinitionsContainer();
2726 rajveer 28 
	Set<Long> entityIds;
2651 rajveer 29 
 
30 
	public static void main(String[] args) throws Exception {
2726 rajveer 31 
//		AccessoriesFinder af = new AccessoriesFinder();
32 
//		Map<Long, Map<Long, List<Long>>> relatedAccessories = af.findAccessories();
33 
//		CreationUtils.storeRelatedAccessories(relatedAccessories);
2651 rajveer 34 
	}
35 
 
36 
 
37 
 
2726 rajveer 38 
	public AccessoriesFinder(Set<Long> entityIds){
39 
		this.entityIds = entityIds;
2651 rajveer 40 
	}
41 
 
42 
 
2656 rajveer 43 
	public Map<Long, Map<Long, List<Long>>> findAccessories() throws Exception {
2651 rajveer 44 
		Map<Long, Map<Long, List<Long>>> entityAccessories = new HashMap<Long, Map<Long, List<Long>>>();
45 
 
2726 rajveer 46 
		//List<Long> categoryIDs = catm.getCategory(Utils.MOBILE_ACCESSORIES_CATEGORY).getChildren_category_ids();
2651 rajveer 47 
		Map<Long, Map<Long, Object>> categoryParameterMap = new HashMap<Long, Map<Long,Object>>();
2726 rajveer 48 
//		for(Long categoryID: categoryIDs){
49 
//			categoryParameterMap.put(categoryID, populateParameters(categoryID));
50 
//		}
2651 rajveer 51 
 
2726 rajveer 52 
		populateParameters(categoryParameterMap);
53 
 
54 
 
55 
		for(Long entityID: entityIds){
56 
			Entity entity = CreationUtils.getEntity(entityID);
2651 rajveer 57 
			Map<Long, Object> entityCategoryParameters = getEntityCategoryParameters(entity);
4802 amit.gupta 58 
			Category cat = defContainer.getCategory(entity.getCategoryID()).getParentCategory();
59 
			if(cat.isHasAccessories()){
2651 rajveer 60 
				entityAccessories.put(entity.getID(), getRelatedAccessories(entityCategoryParameters, categoryParameterMap));
61 
			}
62 
		}
63 
		return entityAccessories;
64 
	}
65 
 
66 
	private Map<Long, Object> getEntityCategoryParameters(Entity entity) throws Exception {
67 
		Map<Long, Object> entityCategoryParameters = new HashMap<Long, Object>();
4802 amit.gupta 68 
		List<Category> categories = defContainer.getCategory(Utils.MOBILE_ACCESSORIES_CATEGORY).getChildrenCategory();
69 
		for(Category category : categories){
70 
			Object obj = populateEntityParameters(category.getID(), entity);
2651 rajveer 71 
			if(obj != null){
4802 amit.gupta 72 
				entityCategoryParameters.put(category.getID(), obj);
2651 rajveer 73 
			}
74 
		}
75 
		return entityCategoryParameters;
76 
	}
77 
 
78 
 
79 
 
80 
	private Object populateEntityParameters(Long categoryID,	Entity entity) throws Exception {
81 
		ExpandedEntity expEntity = new ExpandedEntity(entity);
82 
		ExpandedSlide batterySlide = expEntity.getExpandedSlide(130043);
83 
		Map<String, String> params = new HashMap<String, String>();
84 
 
85 
		switch (categoryID.intValue()) {
86 
		//Battery
87 
		case (int) Utils.BATTERY:
88 
			if(expEntity.getBrand() == null)
89 
				return null;
90 
			if(expEntity.getBrand().trim().compareToIgnoreCase("nokia")!=0){
91 
				return null;
92 
			}
93 
			if(batterySlide == null)
94 
				return null;
95 
			List<ExpandedFeature> expFeatures = batterySlide.getExpandedFeatures();
96 
			for(ExpandedFeature expFeature: expFeatures){
97 
				if(expFeature.getFeatureDefinitionID() == 120072){
98 
					ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
99 
					String type = expBullet.displayText();
100 
					//Li-Ion 1020 mAh battery BL-5C;
101 
					String[] parts =  type.split("battery");
102 
					if(parts.length >= 2){
103 
						params.put("BATTERY_MODEL", parts[1]);
104 
					}
105 
					String last = "";
106 
					parts = type.split(" ");
107 
					for(String part: parts){
108 
						if(part.contains("mAh")){
109 
							params.put("BATTERY_CAPACITY", last);
110 
						}
111 
						last = part;
112 
					}
113 
					return params;
114 
				}
115 
			}
116 
			break;
117 
 
118 
		//Carrying Case
119 
		case (int) Utils.CARRYING_CASE:
120 
 
121 
		//Screen Guard
122 
		case (int) Utils.SCREEN_GUARD:
123 
			if(expEntity.getBrand() == null){
124 
				return null;
125 
			}
126 
			else{
127 
				params.put("BRAND", expEntity.getBrand().trim());
128 
				params.put("MODEL_NUMBER", expEntity.getModelNumber().trim());
129 
				return params;
130 
			}
131 
 
132 
		//Memory Card
133 
		case (int) Utils.MEMORY_CARD:
134 
			if(expEntity.getBrand() == null)
135 
				return null;
136 
			ExpandedSlide memorySlide = expEntity.getExpandedSlide(130011);
137 
			if(memorySlide == null)
138 
				return null;
139 
			List<ExpandedFeature> memoryExpandedFeatures = memorySlide.getExpandedFeatures();
140 
			for(ExpandedFeature expFeature: memoryExpandedFeatures){
141 
				if(expFeature.getFeatureDefinitionID() == 120032){
142 
					ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
143 
					params.put("MEMORY_TYPE", expBullet.getValue().split(" ")[0]);
144 
				}
145 
 
146 
				if(expFeature.getFeatureDefinitionID() == 120033){
147 
					ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
148 
					long memory = Long.parseLong(expBullet.getValue());
149 
					long unitId = expBullet.getUnitID();
150 
					if(unitId == 50008){
151 
						memory = 1024 * memory;
152 
					}
153 
					params.put("MEMORY", memory+"");
154 
					return params;
155 
				}
156 
			}
157 
			break;
2726 rajveer 158 
 
2651 rajveer 159 
			//Bluetooth headset
160 
			case (int) Utils.BLUETOOTH_HEADSET:
161 
				if(expEntity.getBrand() == null){
162 
					return null;
163 
				}
164 
				ExpandedSlide dataConnectivitySlide = expEntity.getExpandedSlide(130007);
165 
				if(dataConnectivitySlide == null)
166 
					return null;
167 
				List<ExpandedFeature> dataConnectivityFeatures = dataConnectivitySlide.getExpandedFeatures();
168 
				for(ExpandedFeature expFeature: dataConnectivityFeatures){
169 
					if(expFeature.getFeatureDefinitionID() == 120018){
170 
						return "TRUE";
171 
					}
172 
				}
173 
				break;
174 
			//Headset
175 
			case (int) Utils.HEADSET:
176 
				if(expEntity.getBrand() == null){
177 
					return null;
178 
				}
179 
				ExpandedSlide musicSlide = expEntity.getExpandedSlide(130029);
180 
				if(musicSlide == null)
181 
					return null;
182 
				List<ExpandedFeature> musicFeatures = musicSlide.getExpandedFeatures();
183 
				for(ExpandedFeature expFeature: musicFeatures){
184 
					if(expFeature.getFeatureDefinitionID() == 120023){
185 
						List<ExpandedBullet> bullets = expFeature.getExpandedBullets();
186 
						if(bullets!=null){
187 
							return expFeature.getExpandedBullets().get(0).getValue();
188 
						}
189 
					}
190 
				}
191 
				break;
192 
 
193 
			//Charger
194 
			case (int) Utils.CHARGER:
195 
				if(expEntity.getBrand() == null)
196 
					return null;
197 
				if(batterySlide == null)
198 
					return null;
199 
				Map<String, String> chargerparams = new HashMap<String, String>();
200 
				List<ExpandedFeature> batteryFeatures = batterySlide.getExpandedFeatures();
201 
				for(ExpandedFeature expFeature: batteryFeatures){
202 
					if(expFeature.getFeatureDefinitionID() == 120073){
203 
						ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
204 
						chargerparams.put("POWER_ADAPTOR", expBullet.getValue());
205 
						chargerparams.put("BRAND", expEntity.getBrand().trim());
206 
						return chargerparams;
207 
					}
208 
				}
209 
				return null;
210 
 
211 
		default:
212 
			break;
213 
		}
214 
 
215 
		return null;
216 
	}
217 
 
218 
 
219 
 
220 
	@SuppressWarnings("unchecked")
221 
	private Map<Long, List<Long>> getRelatedAccessories(Map<Long, Object> entityCategoryParameters, Map<Long, Map<Long, Object>> categoryParameterMap){
222 
		Map<Long, List<Long>> relatedAccessories = new HashMap<Long, List<Long>>();
223 
		for(Entry<Long, Map<Long, Object>> entry: categoryParameterMap.entrySet()){
224 
			Map<Long, Object> entityParameterMap = entry.getValue();
225 
			long categoryID = entry.getKey().intValue();
226 
			switch ((int)categoryID) {
227 
 
228 
			//Battery
229 
			case (int) Utils.BATTERY:
230 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
231 
					long entityID = entry1.getKey();
232 
					Map<String, String> accessoryParameter = (Map<String, String>)  entry1.getValue();
233 
					Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
234 
					if(accessoryParameter == null || mobileParameter == null){
235 
						continue;
236 
					}
237 
					String batteryCapacity = accessoryParameter.get("BATTERY_CAPACITY").trim();
238 
					String batteryModel = accessoryParameter.get("BATTERY_MODEL").trim();
239 
					String mobileBatteryCapacity = mobileParameter.get("BATTERY_CAPACITY").trim();
240 
					String mobileBatteryModel  = mobileParameter.get("BATTERY_MODEL").trim();
241 
					if(batteryCapacity.equalsIgnoreCase(mobileBatteryCapacity) && batteryModel.equalsIgnoreCase(mobileBatteryModel)){
242 
						List<Long> accessories = relatedAccessories.get(categoryID);
243 
						if(accessories == null){
244 
							accessories = new ArrayList<Long>();
245 
							relatedAccessories.put(categoryID, accessories);
246 
						}
247 
						accessories.add(entityID);
248 
					}
249 
				}
250 
				break;
251 
 
252 
			//Carrying Case
253 
			case (int) Utils.CARRYING_CASE:
254 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
255 
					long entityID = entry1.getKey();
256 
					String accessoryParameter = (String) entry1.getValue();
257 
					Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
258 
					if(accessoryParameter != null){
259 
						accessoryParameter = accessoryParameter.trim();
260 
					}
261 
					if(mobileParameter.isEmpty()){
262 
						break;
263 
					}
264 
					String mobileBrand = mobileParameter.get("BRAND");
265 
					String mobileModel = mobileParameter.get("MODEL_NUMBER");
266 
					String[] lines = accessoryParameter.split("\n");
267 
					for(String line: lines){
268 
						boolean isRelated = false;
269 
						if(line.contains(mobileBrand)){
270 
							String[] parts = line.split(" ");
271 
							List<String> partsList = Arrays.asList(parts);
272 
							if(partsList.contains(mobileModel)){
273 
								isRelated = true;
274 
							}
275 
						}
276 
						if(isRelated){
277 
							List<Long> accessories = relatedAccessories.get(categoryID);
278 
							if(accessories == null){
279 
								accessories = new ArrayList<Long>();
280 
								relatedAccessories.put(categoryID, accessories);
281 
							}
282 
							accessories.add(entityID);
283 
						}
284 
					}
285 
 
286 
 
287 
				}
288 
 
289 
				break;
290 
 
291 
			//Screen Guard
292 
			case (int) Utils.SCREEN_GUARD:
293 
				StringBuffer sb1 = new StringBuffer();
294 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
295 
					long entityID = entry1.getKey();
296 
					String accessoryParameter = (String) entry1.getValue();
297 
					Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
298 
					if(accessoryParameter != null){
299 
						accessoryParameter = accessoryParameter.trim();
300 
					}
301 
					if(mobileParameter.isEmpty()){
302 
						break;
303 
					}
304 
					sb1.append(accessoryParameter + " = "+ mobileParameter + "\t");
305 
 
306 
					String mobileBrand = mobileParameter.get("BRAND");
307 
					String mobileModel = mobileParameter.get("MODEL_NUMBER");
308 
					boolean isRelated = false;
309 
					if(accessoryParameter.contains(mobileBrand)){
310 
						String[] parts = accessoryParameter.split(" ");
311 
						List<String> partsList = Arrays.asList(parts);
312 
						if(partsList.contains(mobileModel)){
313 
							isRelated = true;
314 
						}
315 
					}
316 
					if(isRelated){
317 
						List<Long> accessories = relatedAccessories.get(categoryID);
318 
						if(accessories == null){
319 
							accessories = new ArrayList<Long>();
320 
							relatedAccessories.put(categoryID, accessories);
321 
						}
322 
						accessories.add(entityID);
323 
					}
324 
				}
325 
 
326 
				break;
327 
 
328 
 
329 
			//Memory Card
330 
			case (int) Utils.MEMORY_CARD:
331 
			default:
332 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
333 
					long entityID = entry1.getKey();
334 
					String accessoryParameter = (String) entry1.getValue();
335 
					if(entityCategoryParameters.get(entry.getKey()) == null){
336 
						continue;
337 
					}
338 
					if(entityCategoryParameters.get(entry.getKey()) == null){
339 
						continue;
340 
					}
341 
					Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
342 
					if(accessoryParameter != null){
343 
						accessoryParameter = accessoryParameter.trim();
344 
					}
345 
					if(mobileParameter==null){
346 
						continue;
347 
					}
348 
					String parts[] = accessoryParameter.split(" |-");
349 
					long cardMemory = 1024*Long.parseLong(parts[parts.length - 1].replaceAll("GB", "").replaceAll("MB", ""));
350 
					String memoryCapacity = mobileParameter.get("MEMORY");
351 
					String memoryType = mobileParameter.get("MEMORY_TYPE");
352 
					if(memoryCapacity == null || memoryType == null ){
353 
						continue;
354 
					}
355 
					if(Long.parseLong(memoryCapacity.trim()) < cardMemory){
356 
						continue;
357 
					}
358 
 
359 
 
360 
					if(StringUtils.containsIgnoreCase(accessoryParameter, memoryType)){
361 
						List<Long> accessories = relatedAccessories.get(categoryID);
362 
						if(accessories == null){
363 
							accessories = new ArrayList<Long>();
364 
							relatedAccessories.put(categoryID, accessories);
365 
						}
366 
						accessories.add(entityID);
367 
					}
368 
				}
369 
				break;
370 
 
371 
			//Bluetooth Headset
372 
			case (int) Utils.BLUETOOTH_HEADSET:
373 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
374 
					long entityID = entry1.getKey();
375 
					String mobileParameter = (String)entityCategoryParameters.get(entry.getKey());
2668 rajveer 376 
 
377 
					if(mobileParameter == null){
378 
						break;
2651 rajveer 379 
					}
380 
 
2668 rajveer 381 
					if(mobileParameter.equals("TRUE")){
2651 rajveer 382 
						List<Long> accessories = relatedAccessories.get(categoryID);
383 
						if(accessories == null){
384 
							accessories = new ArrayList<Long>();
385 
							relatedAccessories.put(categoryID, accessories);
386 
						}
387 
						accessories.add(entityID);
388 
					}
389 
				}
390 
				break;
391 
 
392 
			//Headset
393 
			case (int) Utils.HEADSET:
394 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
395 
					long entityID = entry1.getKey();
396 
					String mobileParameter = (String)entityCategoryParameters.get(entry.getKey());
2667 rajveer 397 
					String accessoryParameter = (String) entry1.getValue();
398 
					if(mobileParameter!=null && accessoryParameter != null){
2651 rajveer 399 
						mobileParameter = mobileParameter.trim();
2667 rajveer 400 
						accessoryParameter = accessoryParameter.trim();
401 
						if(StringUtils.containsIgnoreCase(mobileParameter, accessoryParameter)){
402 
							List<Long> accessories = relatedAccessories.get(categoryID);
403 
							if(accessories == null){
404 
								accessories = new ArrayList<Long>();
405 
								relatedAccessories.put(categoryID, accessories);
406 
							}
407 
							accessories.add(entityID);
2651 rajveer 408 
						}
409 
					}
410 
				}
411 
				break;
412 
 
413 
			//Charger
414 
			case (int) Utils.CHARGER:
415 
				for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
416 
					long entityID = entry1.getKey();
417 
					Map<String, String>  accessoryParameter = (Map<String, String>) entry1.getValue();
418 
					if(entityCategoryParameters.get(entry.getKey()) == null){
419 
						continue;
420 
					}
421 
					Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
422 
					if(accessoryParameter == null || mobileParameter==null){
423 
						continue;
424 
					}
425 
					String accBrand = accessoryParameter.get("BRAND");
426 
					String mobileBrand = mobileParameter.get("BRAND");
427 
 
428 
					String accConnectorPin = accessoryParameter.get("CONNECTOR_PIN");
429 
					String mobilePowerAdaptor = mobileParameter.get("POWER_ADAPTOR");
430 
 
431 
					String accModel = accessoryParameter.get("MODEL");
432 
 
433 
					if(accBrand.trim().equalsIgnoreCase(mobileBrand.trim())){
434 
						if(StringUtils.containsIgnoreCase(mobilePowerAdaptor, accConnectorPin)){
435 
							if(StringUtils.containsIgnoreCase(mobilePowerAdaptor, accModel)){
436 
								List<Long> accessories = relatedAccessories.get(categoryID);
437 
								if(accessories == null){
438 
									accessories = new ArrayList<Long>();
439 
									relatedAccessories.put(categoryID, accessories);
440 
								}
441 
								accessories.add(entityID);
442 
							}
443 
						}
444 
					}
445 
				}
446 
				break;
447 
 
448 
 
449 
			}
450 
 
451 
		}
452 
		return relatedAccessories;
453 
	}
454 
 
455 
 
2726 rajveer 456 
	private void populateParameters(Map<Long, Map<Long, Object>> categoryParameterMap) throws Exception {
457 
		for(Long entityID: entityIds){
458 
			Entity entity = CreationUtils.getEntity(entityID);
459 
			ExpandedEntity expEntity = new ExpandedEntity(entity);
460 
			Long categoryID = entity.getCategoryID();
461 
			switch (categoryID.intValue()) {
462 
			//Battery
463 
			case (int) Utils.BATTERY:
464 
				ExpandedSlide expCompatibilitySlide = expEntity.getExpandedSlide(130066);
465 
				if(expCompatibilitySlide != null){
466 
					List<ExpandedFeature> compatibilityFeatures = expCompatibilitySlide.getExpandedFeatures();
467 
					for(ExpandedFeature feature: compatibilityFeatures){
468 
						if(feature.getFeatureDefinitionID() == 120104){
469 
							ExpandedBullet bullet = feature.getExpandedBullets().get(0);
470 
							Map<String, String> params = new HashMap<String, String>();
471 
							String capacity = bullet.getValue();
472 
							capacity = capacity.split(" ")[0];
473 
							params.put("BATTERY_CAPACITY", capacity);
474 
							params.put("BATTERY_MODEL", entity.getModelNumber().trim());
475 
							putParameterIntoMap(categoryID, entityID, params, categoryParameterMap);
476 
						}
477 
					}
478 
				}
479 
				break;
480 
 
481 
			//Screen Guard
482 
			case (int) Utils.SCREEN_GUARD:
483 
				Slide compatibilitySlide = entity.getSlide(130073);
484 
				if(compatibilitySlide != null){
485 
					String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
486 
					if(fft != null && !fft.trim().isEmpty()){
487 
						putParameterIntoMap(categoryID, entityID, fft, categoryParameterMap);
488 
					}
489 
				}
490 
				break;
491 
 
492 
			//Carrying Case
493 
			case (int) Utils.CARRYING_CASE:
494 
				Slide ccCompatibilitySlide = entity.getSlide(130073);
495 
				if(ccCompatibilitySlide != null){
496 
					String fft =  ccCompatibilitySlide.getFreeformContent().getFreeformText();
497 
					if(fft != null && !fft.trim().isEmpty()){
498 
						putParameterIntoMap(categoryID, entityID, fft, categoryParameterMap);
499 
					}
500 
				}
501 
				break;
502 
 
503 
				//Memory Card
504 
				case (int) Utils.MEMORY_CARD:
505 
					putParameterIntoMap(categoryID, entityID, entity.getBrand() + " " + entity.getModelName() + " " + entity.getModelNumber(), categoryParameterMap);
506 
					/*
507 
					ExpandedEntity expEntity = new ExpandedEntity(entity);
508 
					ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130065);
509 
					List<ExpandedFeature> compatibilityExpandedFeatures = compatibilitySlide.getExpandedFeatures();
510 
					for(ExpandedFeature expFeature: compatibilityExpandedFeatures){
511 
						if(expFeature.getFeatureDefinitionID() == 120099){
512 
							ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
513 
							if(expBullet.displayText() == null || expBullet.displayText().trim().equals("")){
514 
								continue;
515 
							}
516 
							long memory = Long.parseLong(expBullet.getValue());
517 
							long unitId = expBullet.getUnitID();
518 
							if(unitId == 50008){
519 
								memory = 1024 * memory;
520 
							}
521 
							entityParameterMap.put(entity.getID(), memory+"");
522 
						}
523 
					}
524 
					*/
525 
					break;
526 
 
527 
				//Bluetooth Headset
528 
				case (int) Utils.BLUETOOTH_HEADSET:
529 
					putParameterIntoMap(categoryID, entityID, entity.getModelNumber().trim(), categoryParameterMap);
530 
					break;
531 
 
532 
				//Headset
533 
				case (int) Utils.HEADSET:
534 
					ExpandedSlide headsetCompatibilitySlide = expEntity.getExpandedSlide(130068);
535 
					if(headsetCompatibilitySlide != null){
536 
						List<ExpandedFeature> compatibilityFeatures = headsetCompatibilitySlide.getExpandedFeatures();
537 
						for(ExpandedFeature feature: compatibilityFeatures){
538 
							if(feature.getFeatureDefinitionID() == 120105){
539 
								ExpandedBullet bullet = feature.getExpandedBullets().get(0);
540 
								putParameterIntoMap(categoryID, entityID, bullet.getValue(), categoryParameterMap);
541 
							}
542 
						}
543 
					}
544 
					break;
545 
 
546 
				//Charger
547 
				case (int) Utils.CHARGER:
548 
					ExpandedSlide chargerCompatibilitySlide = expEntity.getExpandedSlide(130069);
549 
					if(chargerCompatibilitySlide != null){
550 
						List<ExpandedFeature> compatibilityFeatures = chargerCompatibilitySlide.getExpandedFeatures();
551 
						for(ExpandedFeature feature: compatibilityFeatures){
552 
							if(feature.getFeatureDefinitionID() == 120107){
553 
								ExpandedBullet bullet = feature.getExpandedBullets().get(0);
554 
								Map<String, String> params = new HashMap<String, String>();
555 
								String model = entity.getModelName() + " " + entity.getModelNumber();
556 
								model = model.replaceAll("Charger", "").trim();
557 
								params.put("BRAND", entity.getBrand());
558 
								params.put("CONNECTOR_PIN", bullet.getValue());
559 
								params.put("MODEL", model);
560 
								putParameterIntoMap(categoryID, entityID, params, categoryParameterMap);
561 
							}
562 
						}
563 
					}
564 
					break;
565 
 
566 
			default:
567 
				break;
568 
			}
569 
		}
570 
	}
571 
 
572 
 
573 
	void putParameterIntoMap(Long categoryID, Long entityID, Object params, Map<Long, Map<Long, Object>> categoryParameterMap){
574 
		Map<Long, Object> entityParameterMap = categoryParameterMap.get(categoryID);
575 
		if(entityParameterMap == null){
576 
			entityParameterMap = new HashMap<Long, Object>();
577 
			categoryParameterMap.put(categoryID, entityParameterMap);
578 
		}
579 
		entityParameterMap.put(entityID, params);
580 
	}
581 
 
582 
 
583 
 
584 
 
2651 rajveer 585 
	private Map<Long, Object> populateParameters(long categoryID) throws Exception {
586 
		Map<Long, Object> entityParameterMap = new HashMap<Long, Object>();
587 
		Collection<Entity> entities = CreationUtils.getEntities(categoryID);
2726 rajveer 588 
 
2651 rajveer 589 
		switch ((int)categoryID) {
590 
 
591 
		//Battery
592 
		case (int) Utils.BATTERY:
593 
			for(Entity entity: entities){
594 
				ExpandedEntity expEntity = new ExpandedEntity(entity);
595 
				ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130066);
596 
				if(compatibilitySlide != null){
597 
					List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
598 
					for(ExpandedFeature feature: compatibilityFeatures){
599 
						if(feature.getFeatureDefinitionID() == 120104){
600 
							ExpandedBullet bullet = feature.getExpandedBullets().get(0);
601 
							Map<String, String> params = new HashMap<String, String>();
602 
							String capacity = bullet.getValue();
603 
							capacity = capacity.split(" ")[0];
604 
							params.put("BATTERY_CAPACITY", capacity);
605 
							params.put("BATTERY_MODEL", entity.getModelNumber().trim());
606 
							entityParameterMap.put(entity.getID(), params);
607 
						}
608 
					}
609 
				}
610 
			}
611 
			break;
612 
 
613 
		//Screen Guard
614 
		case (int) Utils.SCREEN_GUARD:
615 
			for(Entity entity: entities){
616 
				Slide compatibilitySlide = entity.getSlide(130073);
617 
				if(compatibilitySlide != null){
618 
					String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
619 
					if(fft != null && !fft.trim().isEmpty()){
620 
						entityParameterMap.put(entity.getID(), fft);
621 
					}
622 
				}
623 
			}
624 
			break;
625 
 
626 
		//Carrying Case
627 
		case (int) Utils.CARRYING_CASE:
628 
			for(Entity entity: entities){
629 
				Slide compatibilitySlide = entity.getSlide(130073);
630 
				if(compatibilitySlide != null){
631 
					String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
632 
					if(fft != null && !fft.trim().isEmpty()){
633 
						entityParameterMap.put(entity.getID(), fft);
634 
					}
635 
				}
636 
			}
637 
			break;
638 
 
639 
		//Memory Card
640 
		case (int) Utils.MEMORY_CARD:
641 
			for(Entity entity: entities){
642 
				entityParameterMap.put(entity.getID(), entity.getBrand() + " " + entity.getModelName() + " " + entity.getModelNumber());
643 
				/*
644 
				ExpandedEntity expEntity = new ExpandedEntity(entity);
645 
				ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130065);
646 
				List<ExpandedFeature> compatibilityExpandedFeatures = compatibilitySlide.getExpandedFeatures();
647 
				for(ExpandedFeature expFeature: compatibilityExpandedFeatures){
648 
					if(expFeature.getFeatureDefinitionID() == 120099){
649 
						ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
650 
						if(expBullet.displayText() == null || expBullet.displayText().trim().equals("")){
651 
							continue;
652 
						}
653 
						long memory = Long.parseLong(expBullet.getValue());
654 
						long unitId = expBullet.getUnitID();
655 
						if(unitId == 50008){
656 
							memory = 1024 * memory;
657 
						}
658 
						entityParameterMap.put(entity.getID(), memory+"");
659 
					}
660 
				}
661 
				*/
662 
			}
663 
			break;
664 
 
665 
		//Bluetooth Headset
666 
		case (int) Utils.BLUETOOTH_HEADSET:
667 
			for(Entity entity: entities){
668 
				entityParameterMap.put(entity.getID(), entity.getModelNumber().trim());
669 
			}
670 
			break;
671 
 
672 
		//Headset
673 
		case (int) Utils.HEADSET:
674 
			for(Entity entity: entities){
675 
				ExpandedEntity expEntity = new ExpandedEntity(entity);
676 
				ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130068);
677 
				if(compatibilitySlide != null){
678 
					List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
679 
					for(ExpandedFeature feature: compatibilityFeatures){
680 
						if(feature.getFeatureDefinitionID() == 120105){
681 
							ExpandedBullet bullet = feature.getExpandedBullets().get(0);
682 
							entityParameterMap.put(entity.getID(), bullet.getValue());
683 
						}
684 
					}
685 
				}
686 
			}
687 
			break;
688 
 
689 
		//Charger
690 
		case (int) Utils.CHARGER:
691 
			for(Entity entity: entities){
692 
				ExpandedEntity expEntity = new ExpandedEntity(entity);
693 
				ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130069);
694 
				if(compatibilitySlide != null){
695 
					List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
696 
					for(ExpandedFeature feature: compatibilityFeatures){
697 
						if(feature.getFeatureDefinitionID() == 120107){
698 
							ExpandedBullet bullet = feature.getExpandedBullets().get(0);
699 
							Map<String, String> params = new HashMap<String, String>();
700 
							String model = entity.getModelName() + " " + entity.getModelNumber();
701 
							model = model.replaceAll("Charger", "").trim();
702 
							params.put("BRAND", entity.getBrand());
703 
							params.put("CONNECTOR_PIN", bullet.getValue());
704 
							params.put("MODEL", model);
705 
							entityParameterMap.put(entity.getID(), params);
706 
						}
707 
					}
708 
				}
709 
			}
710 
			break;
711 
 
712 
		default:
713 
			break;
714 
		}
715 
		return entityParameterMap;
716 
	}
717 
 
2726 rajveer 718 
}