Subversion Repositories SmartDukaan

Rev

Rev 2668 | Rev 4802 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package in.shop2020.util;

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.util.CreationUtils;
import in.shop2020.metamodel.util.ExpandedBullet;
import in.shop2020.metamodel.util.ExpandedEntity;
import in.shop2020.metamodel.util.ExpandedFeature;
import in.shop2020.metamodel.util.ExpandedSlide;
import in.shop2020.utils.CategoryManager;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.lang.StringUtils;


public class AccessoriesFinder {
        CategoryManager catm = CategoryManager.getCategoryManager();
        Set<Long> entityIds;
        
        public static void main(String[] args) throws Exception {
//              AccessoriesFinder af = new AccessoriesFinder();
//              Map<Long, Map<Long, List<Long>>> relatedAccessories = af.findAccessories();
//              CreationUtils.storeRelatedAccessories(relatedAccessories);
        }


        
        public AccessoriesFinder(Set<Long> entityIds){
                this.entityIds = entityIds;     
        }
        
        
        public Map<Long, Map<Long, List<Long>>> findAccessories() throws Exception {
                Map<Long, Map<Long, List<Long>>> entityAccessories = new HashMap<Long, Map<Long, List<Long>>>();
                
                //List<Long> categoryIDs = catm.getCategory(Utils.MOBILE_ACCESSORIES_CATEGORY).getChildren_category_ids();
                Map<Long, Map<Long, Object>> categoryParameterMap = new HashMap<Long, Map<Long,Object>>();
//              for(Long categoryID: categoryIDs){
//                      categoryParameterMap.put(categoryID, populateParameters(categoryID));
//              }
                
                populateParameters(categoryParameterMap);
                
                
                for(Long entityID: entityIds){
                        Entity entity = CreationUtils.getEntity(entityID);
                        Map<Long, Object> entityCategoryParameters = getEntityCategoryParameters(entity);
                        if(catm.getCategory(entity.getCategoryID()).getParent_category_id() != Utils.MOBILE_ACCESSORIES_CATEGORY){
                                entityAccessories.put(entity.getID(), getRelatedAccessories(entityCategoryParameters, categoryParameterMap));
                        }
                }
                return entityAccessories;
        }

        private Map<Long, Object> getEntityCategoryParameters(Entity entity) throws Exception {
                Map<Long, Object> entityCategoryParameters = new HashMap<Long, Object>();
                List<Long> categoryIDs = catm.getCategory(Utils.MOBILE_ACCESSORIES_CATEGORY).getChildren_category_ids();
                for(Long categoryID: categoryIDs){
                        Object obj = populateEntityParameters(categoryID, entity);
                        if(obj != null){
                                entityCategoryParameters.put(categoryID, obj);  
                        }
                }
                return entityCategoryParameters;
        }



        private Object populateEntityParameters(Long categoryID,        Entity entity) throws Exception {
                ExpandedEntity expEntity = new ExpandedEntity(entity);
                ExpandedSlide batterySlide = expEntity.getExpandedSlide(130043);
                Map<String, String> params = new HashMap<String, String>();             
                
                switch (categoryID.intValue()) {
                //Battery
                case (int) Utils.BATTERY:
                        if(expEntity.getBrand() == null)
                                return null;
                        if(expEntity.getBrand().trim().compareToIgnoreCase("nokia")!=0){
                                return null;
                        }
                        if(batterySlide == null)
                                return null;
                        List<ExpandedFeature> expFeatures = batterySlide.getExpandedFeatures();
                        for(ExpandedFeature expFeature: expFeatures){
                                if(expFeature.getFeatureDefinitionID() == 120072){
                                        ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                        String type = expBullet.displayText();
                                        //Li-Ion 1020 mAh battery BL-5C;
                                        String[] parts =  type.split("battery");
                                        if(parts.length >= 2){
                                                params.put("BATTERY_MODEL", parts[1]);
                                        } 
                                        String last = "";
                                        parts = type.split(" ");
                                        for(String part: parts){
                                                if(part.contains("mAh")){
                                                        params.put("BATTERY_CAPACITY", last);
                                                }
                                                last = part;
                                        }
                                        return params;
                                }
                        }
                        break;

                //Carrying Case
                case (int) Utils.CARRYING_CASE:

                //Screen Guard
                case (int) Utils.SCREEN_GUARD:
                        if(expEntity.getBrand() == null){
                                return null;
                        }
                        else{
                                params.put("BRAND", expEntity.getBrand().trim());
                                params.put("MODEL_NUMBER", expEntity.getModelNumber().trim());
                                return params;
                        }
                        
                //Memory Card
                case (int) Utils.MEMORY_CARD:
                        if(expEntity.getBrand() == null)
                                return null;
                        ExpandedSlide memorySlide = expEntity.getExpandedSlide(130011);
                        if(memorySlide == null)
                                return null;
                        List<ExpandedFeature> memoryExpandedFeatures = memorySlide.getExpandedFeatures();
                        for(ExpandedFeature expFeature: memoryExpandedFeatures){
                                if(expFeature.getFeatureDefinitionID() == 120032){
                                        ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                        params.put("MEMORY_TYPE", expBullet.getValue().split(" ")[0]);
                                }
                                
                                if(expFeature.getFeatureDefinitionID() == 120033){
                                        ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                        long memory = Long.parseLong(expBullet.getValue());
                                        long unitId = expBullet.getUnitID();
                                        if(unitId == 50008){
                                                memory = 1024 * memory;
                                        }
                                        params.put("MEMORY", memory+"");
                                        return params;
                                }
                        }
                        break;

                        //Bluetooth headset
                        case (int) Utils.BLUETOOTH_HEADSET:
                                if(expEntity.getBrand() == null){
                                        return null;
                                }
                                ExpandedSlide dataConnectivitySlide = expEntity.getExpandedSlide(130007);
                                if(dataConnectivitySlide == null)
                                        return null;
                                List<ExpandedFeature> dataConnectivityFeatures = dataConnectivitySlide.getExpandedFeatures();
                                for(ExpandedFeature expFeature: dataConnectivityFeatures){
                                        if(expFeature.getFeatureDefinitionID() == 120018){
                                                return "TRUE";
                                        }
                                }
                                break;
                        //Headset
                        case (int) Utils.HEADSET:
                                if(expEntity.getBrand() == null){
                                        return null;
                                }
                                ExpandedSlide musicSlide = expEntity.getExpandedSlide(130029);
                                if(musicSlide == null)
                                        return null;
                                List<ExpandedFeature> musicFeatures = musicSlide.getExpandedFeatures();
                                for(ExpandedFeature expFeature: musicFeatures){
                                        if(expFeature.getFeatureDefinitionID() == 120023){
                                                List<ExpandedBullet> bullets = expFeature.getExpandedBullets();
                                                if(bullets!=null){
                                                        return expFeature.getExpandedBullets().get(0).getValue();
                                                }
                                        }
                                }
                                break;

                        //Charger
                        case (int) Utils.CHARGER:
                                if(expEntity.getBrand() == null)
                                        return null;
                                if(batterySlide == null)
                                        return null;
                                Map<String, String> chargerparams = new HashMap<String, String>();
                                List<ExpandedFeature> batteryFeatures = batterySlide.getExpandedFeatures();
                                for(ExpandedFeature expFeature: batteryFeatures){
                                        if(expFeature.getFeatureDefinitionID() == 120073){
                                                ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                                chargerparams.put("POWER_ADAPTOR", expBullet.getValue());
                                                chargerparams.put("BRAND", expEntity.getBrand().trim());
                                                return chargerparams;
                                        }
                                }
                                return null;                    
                        
                default:
                        break;
                }

                return null;
        }



        @SuppressWarnings("unchecked")
        private Map<Long, List<Long>> getRelatedAccessories(Map<Long, Object> entityCategoryParameters, Map<Long, Map<Long, Object>> categoryParameterMap){
                Map<Long, List<Long>> relatedAccessories = new HashMap<Long, List<Long>>();
                for(Entry<Long, Map<Long, Object>> entry: categoryParameterMap.entrySet()){
                        Map<Long, Object> entityParameterMap = entry.getValue();
                        long categoryID = entry.getKey().intValue();
                        switch ((int)categoryID) {
                        
                        //Battery
                        case (int) Utils.BATTERY:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        Map<String, String> accessoryParameter = (Map<String, String>)  entry1.getValue();
                                        Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
                                        if(accessoryParameter == null || mobileParameter == null){
                                                continue;
                                        }
                                        String batteryCapacity = accessoryParameter.get("BATTERY_CAPACITY").trim();
                                        String batteryModel = accessoryParameter.get("BATTERY_MODEL").trim();
                                        String mobileBatteryCapacity = mobileParameter.get("BATTERY_CAPACITY").trim();
                                        String mobileBatteryModel  = mobileParameter.get("BATTERY_MODEL").trim();
                                        if(batteryCapacity.equalsIgnoreCase(mobileBatteryCapacity) && batteryModel.equalsIgnoreCase(mobileBatteryModel)){
                                                List<Long> accessories = relatedAccessories.get(categoryID);
                                                if(accessories == null){
                                                        accessories = new ArrayList<Long>();
                                                        relatedAccessories.put(categoryID, accessories);
                                                }
                                                accessories.add(entityID);
                                        }
                                }
                                break;
                                
                        //Carrying Case
                        case (int) Utils.CARRYING_CASE:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        String accessoryParameter = (String) entry1.getValue();
                                        Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
                                        if(accessoryParameter != null){
                                                accessoryParameter = accessoryParameter.trim();
                                        }
                                        if(mobileParameter.isEmpty()){
                                                break;
                                        }
                                        String mobileBrand = mobileParameter.get("BRAND");
                                        String mobileModel = mobileParameter.get("MODEL_NUMBER");
                                        String[] lines = accessoryParameter.split("\n");
                                        for(String line: lines){
                                                boolean isRelated = false;
                                                if(line.contains(mobileBrand)){
                                                        String[] parts = line.split(" ");
                                                        List<String> partsList = Arrays.asList(parts);
                                                        if(partsList.contains(mobileModel)){
                                                                isRelated = true;
                                                        }
                                                }
                                                if(isRelated){
                                                        List<Long> accessories = relatedAccessories.get(categoryID);
                                                        if(accessories == null){
                                                                accessories = new ArrayList<Long>();
                                                                relatedAccessories.put(categoryID, accessories);
                                                        }
                                                        accessories.add(entityID);
                                                }
                                        }
                                        
                                        
                                }

                                break;

                        //Screen Guard
                        case (int) Utils.SCREEN_GUARD:
                                StringBuffer sb1 = new StringBuffer();
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        String accessoryParameter = (String) entry1.getValue();
                                        Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
                                        if(accessoryParameter != null){
                                                accessoryParameter = accessoryParameter.trim();
                                        }
                                        if(mobileParameter.isEmpty()){
                                                break;
                                        }
                                        sb1.append(accessoryParameter + " = "+ mobileParameter + "\t");
                                        
                                        String mobileBrand = mobileParameter.get("BRAND");
                                        String mobileModel = mobileParameter.get("MODEL_NUMBER");
                                        boolean isRelated = false;
                                        if(accessoryParameter.contains(mobileBrand)){
                                                String[] parts = accessoryParameter.split(" ");
                                                List<String> partsList = Arrays.asList(parts);
                                                if(partsList.contains(mobileModel)){
                                                        isRelated = true;
                                                }
                                        }
                                        if(isRelated){
                                                List<Long> accessories = relatedAccessories.get(categoryID);
                                                if(accessories == null){
                                                        accessories = new ArrayList<Long>();
                                                        relatedAccessories.put(categoryID, accessories);
                                                }
                                                accessories.add(entityID);
                                        }
                                }

                                break;

                        
                        //Memory Card
                        case (int) Utils.MEMORY_CARD:
                        default:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        String accessoryParameter = (String) entry1.getValue();
                                        if(entityCategoryParameters.get(entry.getKey()) == null){
                                                continue;
                                        }
                                        if(entityCategoryParameters.get(entry.getKey()) == null){
                                                continue;
                                        }
                                        Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
                                        if(accessoryParameter != null){
                                                accessoryParameter = accessoryParameter.trim();
                                        }
                                        if(mobileParameter==null){
                                                continue;
                                        }
                                        String parts[] = accessoryParameter.split(" |-");
                                        long cardMemory = 1024*Long.parseLong(parts[parts.length - 1].replaceAll("GB", "").replaceAll("MB", ""));
                                        String memoryCapacity = mobileParameter.get("MEMORY");
                                        String memoryType = mobileParameter.get("MEMORY_TYPE");
                                        if(memoryCapacity == null || memoryType == null ){
                                                continue;
                                        }
                                        if(Long.parseLong(memoryCapacity.trim()) < cardMemory){
                                                continue;
                                        }
                                        
                                        
                                        if(StringUtils.containsIgnoreCase(accessoryParameter, memoryType)){
                                                List<Long> accessories = relatedAccessories.get(categoryID);
                                                if(accessories == null){
                                                        accessories = new ArrayList<Long>();
                                                        relatedAccessories.put(categoryID, accessories);
                                                }
                                                accessories.add(entityID);
                                        }
                                }
                                break;
                                
                        //Bluetooth Headset
                        case (int) Utils.BLUETOOTH_HEADSET:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        String mobileParameter = (String)entityCategoryParameters.get(entry.getKey());
                                        
                                        if(mobileParameter == null){
                                                break;
                                        }
                                        
                                        if(mobileParameter.equals("TRUE")){
                                                List<Long> accessories = relatedAccessories.get(categoryID);
                                                if(accessories == null){
                                                        accessories = new ArrayList<Long>();
                                                        relatedAccessories.put(categoryID, accessories);
                                                }
                                                accessories.add(entityID);
                                        }
                                }
                                break;

                        //Headset
                        case (int) Utils.HEADSET:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        String mobileParameter = (String)entityCategoryParameters.get(entry.getKey());
                                        String accessoryParameter = (String) entry1.getValue();
                                        if(mobileParameter!=null && accessoryParameter != null){
                                                mobileParameter = mobileParameter.trim();
                                                accessoryParameter = accessoryParameter.trim();
                                                if(StringUtils.containsIgnoreCase(mobileParameter, accessoryParameter)){
                                                        List<Long> accessories = relatedAccessories.get(categoryID);
                                                        if(accessories == null){
                                                                accessories = new ArrayList<Long>();
                                                                relatedAccessories.put(categoryID, accessories);
                                                        }
                                                        accessories.add(entityID);
                                                }
                                        }
                                }
                                break;

                        //Charger
                        case (int) Utils.CHARGER:
                                for(Entry<Long, Object> entry1 : entityParameterMap.entrySet()){
                                        long entityID = entry1.getKey();
                                        Map<String, String>  accessoryParameter = (Map<String, String>) entry1.getValue();
                                        if(entityCategoryParameters.get(entry.getKey()) == null){
                                                continue;
                                        }
                                        Map<String, String> mobileParameter = (Map<String, String>)entityCategoryParameters.get(entry.getKey());
                                        if(accessoryParameter == null || mobileParameter==null){
                                                continue;
                                        }
                                        String accBrand = accessoryParameter.get("BRAND");
                                        String mobileBrand = mobileParameter.get("BRAND");
                                        
                                        String accConnectorPin = accessoryParameter.get("CONNECTOR_PIN");
                                        String mobilePowerAdaptor = mobileParameter.get("POWER_ADAPTOR");
                                        
                                        String accModel = accessoryParameter.get("MODEL");
                                        
                                        if(accBrand.trim().equalsIgnoreCase(mobileBrand.trim())){
                                                if(StringUtils.containsIgnoreCase(mobilePowerAdaptor, accConnectorPin)){
                                                        if(StringUtils.containsIgnoreCase(mobilePowerAdaptor, accModel)){
                                                                List<Long> accessories = relatedAccessories.get(categoryID);
                                                                if(accessories == null){
                                                                        accessories = new ArrayList<Long>();
                                                                        relatedAccessories.put(categoryID, accessories);
                                                                }
                                                                accessories.add(entityID);                      
                                                        }
                                                }
                                        }
                                }
                                break;

                                
                        }

                }
                return relatedAccessories;
        }

        
        private void populateParameters(Map<Long, Map<Long, Object>> categoryParameterMap) throws Exception {
                for(Long entityID: entityIds){
                        Entity entity = CreationUtils.getEntity(entityID);
                        ExpandedEntity expEntity = new ExpandedEntity(entity);
                        Long categoryID = entity.getCategoryID();
                        switch (categoryID.intValue()) {
                        //Battery
                        case (int) Utils.BATTERY:
                                ExpandedSlide expCompatibilitySlide = expEntity.getExpandedSlide(130066);
                                if(expCompatibilitySlide != null){
                                        List<ExpandedFeature> compatibilityFeatures = expCompatibilitySlide.getExpandedFeatures();
                                        for(ExpandedFeature feature: compatibilityFeatures){
                                                if(feature.getFeatureDefinitionID() == 120104){
                                                        ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                        Map<String, String> params = new HashMap<String, String>();
                                                        String capacity = bullet.getValue();
                                                        capacity = capacity.split(" ")[0];
                                                        params.put("BATTERY_CAPACITY", capacity);
                                                        params.put("BATTERY_MODEL", entity.getModelNumber().trim());
                                                        putParameterIntoMap(categoryID, entityID, params, categoryParameterMap);
                                                }
                                        }
                                }
                                break;
                                
                        //Screen Guard
                        case (int) Utils.SCREEN_GUARD:
                                Slide compatibilitySlide = entity.getSlide(130073);
                                if(compatibilitySlide != null){
                                        String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
                                        if(fft != null && !fft.trim().isEmpty()){
                                                putParameterIntoMap(categoryID, entityID, fft, categoryParameterMap);
                                        }
                                }
                                break;
        
                        //Carrying Case
                        case (int) Utils.CARRYING_CASE:
                                Slide ccCompatibilitySlide = entity.getSlide(130073);
                                if(ccCompatibilitySlide != null){
                                        String fft =  ccCompatibilitySlide.getFreeformContent().getFreeformText();
                                        if(fft != null && !fft.trim().isEmpty()){
                                                putParameterIntoMap(categoryID, entityID, fft, categoryParameterMap);
                                        }
                                }
                                break;

                                //Memory Card
                                case (int) Utils.MEMORY_CARD:
                                        putParameterIntoMap(categoryID, entityID, entity.getBrand() + " " + entity.getModelName() + " " + entity.getModelNumber(), categoryParameterMap);
                                        /*
                                        ExpandedEntity expEntity = new ExpandedEntity(entity);
                                        ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130065);
                                        List<ExpandedFeature> compatibilityExpandedFeatures = compatibilitySlide.getExpandedFeatures();
                                        for(ExpandedFeature expFeature: compatibilityExpandedFeatures){
                                                if(expFeature.getFeatureDefinitionID() == 120099){
                                                        ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                                        if(expBullet.displayText() == null || expBullet.displayText().trim().equals("")){
                                                                continue;
                                                        }
                                                        long memory = Long.parseLong(expBullet.getValue());
                                                        long unitId = expBullet.getUnitID();
                                                        if(unitId == 50008){
                                                                memory = 1024 * memory;
                                                        }
                                                        entityParameterMap.put(entity.getID(), memory+"");
                                                }
                                        }
                                        */
                                        break;

                                //Bluetooth Headset
                                case (int) Utils.BLUETOOTH_HEADSET:
                                        putParameterIntoMap(categoryID, entityID, entity.getModelNumber().trim(), categoryParameterMap);
                                        break;

                                //Headset
                                case (int) Utils.HEADSET:
                                        ExpandedSlide headsetCompatibilitySlide = expEntity.getExpandedSlide(130068);
                                        if(headsetCompatibilitySlide != null){
                                                List<ExpandedFeature> compatibilityFeatures = headsetCompatibilitySlide.getExpandedFeatures();
                                                for(ExpandedFeature feature: compatibilityFeatures){
                                                        if(feature.getFeatureDefinitionID() == 120105){
                                                                ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                                putParameterIntoMap(categoryID, entityID, bullet.getValue(), categoryParameterMap);
                                                        }
                                                }
                                        }
                                        break;

                                //Charger
                                case (int) Utils.CHARGER:
                                        ExpandedSlide chargerCompatibilitySlide = expEntity.getExpandedSlide(130069);
                                        if(chargerCompatibilitySlide != null){
                                                List<ExpandedFeature> compatibilityFeatures = chargerCompatibilitySlide.getExpandedFeatures();
                                                for(ExpandedFeature feature: compatibilityFeatures){
                                                        if(feature.getFeatureDefinitionID() == 120107){
                                                                ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                                Map<String, String> params = new HashMap<String, String>();
                                                                String model = entity.getModelName() + " " + entity.getModelNumber();
                                                                model = model.replaceAll("Charger", "").trim();
                                                                params.put("BRAND", entity.getBrand());
                                                                params.put("CONNECTOR_PIN", bullet.getValue());
                                                                params.put("MODEL", model);
                                                                putParameterIntoMap(categoryID, entityID, params, categoryParameterMap);
                                                        }
                                                }
                                        }
                                        break;

                        default:
                                break;
                        }
                }
        }
        
        
        void putParameterIntoMap(Long categoryID, Long entityID, Object params, Map<Long, Map<Long, Object>> categoryParameterMap){
                Map<Long, Object> entityParameterMap = categoryParameterMap.get(categoryID); 
                if(entityParameterMap == null){
                        entityParameterMap = new HashMap<Long, Object>();
                        categoryParameterMap.put(categoryID, entityParameterMap);
                }
                entityParameterMap.put(entityID, params);       
        }
        
        

        
        private Map<Long, Object> populateParameters(long categoryID) throws Exception {
                Map<Long, Object> entityParameterMap = new HashMap<Long, Object>();
                Collection<Entity> entities = CreationUtils.getEntities(categoryID);
                
                switch ((int)categoryID) {
                
                //Battery
                case (int) Utils.BATTERY:
                        for(Entity entity: entities){
                                ExpandedEntity expEntity = new ExpandedEntity(entity);
                                ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130066);
                                if(compatibilitySlide != null){
                                        List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
                                        for(ExpandedFeature feature: compatibilityFeatures){
                                                if(feature.getFeatureDefinitionID() == 120104){
                                                        ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                        Map<String, String> params = new HashMap<String, String>();
                                                        String capacity = bullet.getValue();
                                                        capacity = capacity.split(" ")[0];
                                                        params.put("BATTERY_CAPACITY", capacity);
                                                        params.put("BATTERY_MODEL", entity.getModelNumber().trim());
                                                        entityParameterMap.put(entity.getID(), params);
                                                }
                                        }
                                }
                        }
                        break;
                        
                //Screen Guard
                case (int) Utils.SCREEN_GUARD:
                        for(Entity entity: entities){
                                Slide compatibilitySlide = entity.getSlide(130073);
                                if(compatibilitySlide != null){
                                        String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
                                        if(fft != null && !fft.trim().isEmpty()){
                                                entityParameterMap.put(entity.getID(), fft);
                                        }
                                }
                        }
                        break;

                //Carrying Case
                case (int) Utils.CARRYING_CASE:
                        for(Entity entity: entities){
                                Slide compatibilitySlide = entity.getSlide(130073);
                                if(compatibilitySlide != null){
                                        String fft =  compatibilitySlide.getFreeformContent().getFreeformText();
                                        if(fft != null && !fft.trim().isEmpty()){
                                                entityParameterMap.put(entity.getID(), fft);
                                        }
                                }
                        }
                        break;

                //Memory Card
                case (int) Utils.MEMORY_CARD:
                        for(Entity entity: entities){
                                entityParameterMap.put(entity.getID(), entity.getBrand() + " " + entity.getModelName() + " " + entity.getModelNumber());
                                /*
                                ExpandedEntity expEntity = new ExpandedEntity(entity);
                                ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130065);
                                List<ExpandedFeature> compatibilityExpandedFeatures = compatibilitySlide.getExpandedFeatures();
                                for(ExpandedFeature expFeature: compatibilityExpandedFeatures){
                                        if(expFeature.getFeatureDefinitionID() == 120099){
                                                ExpandedBullet expBullet = expFeature.getExpandedBullets().get(0);
                                                if(expBullet.displayText() == null || expBullet.displayText().trim().equals("")){
                                                        continue;
                                                }
                                                long memory = Long.parseLong(expBullet.getValue());
                                                long unitId = expBullet.getUnitID();
                                                if(unitId == 50008){
                                                        memory = 1024 * memory;
                                                }
                                                entityParameterMap.put(entity.getID(), memory+"");
                                        }
                                }
                                */      
                        }
                        break;

                //Bluetooth Headset
                case (int) Utils.BLUETOOTH_HEADSET:
                        for(Entity entity: entities){
                                entityParameterMap.put(entity.getID(), entity.getModelNumber().trim());
                        }
                        break;

                //Headset
                case (int) Utils.HEADSET:
                        for(Entity entity: entities){
                                ExpandedEntity expEntity = new ExpandedEntity(entity);
                                ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130068);
                                if(compatibilitySlide != null){
                                        List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
                                        for(ExpandedFeature feature: compatibilityFeatures){
                                                if(feature.getFeatureDefinitionID() == 120105){
                                                        ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                        entityParameterMap.put(entity.getID(), bullet.getValue());
                                                }
                                        }
                                }
                        }
                        break;

                //Charger
                case (int) Utils.CHARGER:
                        for(Entity entity: entities){
                                ExpandedEntity expEntity = new ExpandedEntity(entity);
                                ExpandedSlide compatibilitySlide = expEntity.getExpandedSlide(130069);
                                if(compatibilitySlide != null){
                                        List<ExpandedFeature> compatibilityFeatures = compatibilitySlide.getExpandedFeatures();
                                        for(ExpandedFeature feature: compatibilityFeatures){
                                                if(feature.getFeatureDefinitionID() == 120107){
                                                        ExpandedBullet bullet = feature.getExpandedBullets().get(0);
                                                        Map<String, String> params = new HashMap<String, String>();
                                                        String model = entity.getModelName() + " " + entity.getModelNumber();
                                                        model = model.replaceAll("Charger", "").trim();
                                                        params.put("BRAND", entity.getBrand());
                                                        params.put("CONNECTOR_PIN", bullet.getValue());
                                                        params.put("MODEL", model);
                                                        entityParameterMap.put(entity.getID(), params);
                                                }
                                        }
                                }
                        }
                        break;

                default:
                        break;
                }
                return entityParameterMap;
        }
        
}