Subversion Repositories SmartDukaan

Rev

Rev 2667 | Rev 3719 | 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.EntityState;
import in.shop2020.metamodel.core.EntityStatus;
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 org.apache.commons.lang.StringUtils;


public class AccessoriesFinder {
        CategoryManager catm = CategoryManager.getCategoryManager();
        
        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(){
        }
        
        
        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));
                }
                
                for(Entity entity: CreationUtils.getEntities().values()){
                        if(entity.getCategoryID() == -1){
                                continue;
                        }
                        EntityState state = CreationUtils.getEntityState(entity.getID());
                        if(state.getStatus() != EntityStatus.READY){
                                continue;
                        }
                        
                        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;
                /*
                List<Long> includeCategories = new ArrayList<Long>();
                
                includeCategories.add((long) BATTERY);
                includeCategories.add((long) CARRYING_CASE);
                includeCategories.add((long) CHARGER);
                includeCategories.add((long) SCREEN_GUARD);
                includeCategories.add((long) MEMORY_CARD);
                includeCategories.add((long) HEADSET);
                includeCategories.add((long) BLUETOOTH_HEADSET);
                
                
                StringBuffer sb = new  StringBuffer();
                for(Entry<Long, Map<Long, List<Long>>> entry: entityAccessories.entrySet()){
                        long entityID = entry.getKey();
                        EntityState state = CreationUtils.getEntityState(entityID);
                        String entityName = state.getBrand() + " " + state.getModelName() + " " + state.getModelNumber();
                        sb.append(entityName + " " + entityID);
                        for(Entry<Long, List<Long>> entry1: entry.getValue().entrySet()){
                                long categoryID = entry1.getKey();
                                if(!includeCategories.contains(categoryID) ){
                                        continue;
                                }
                                String catName = catm.getCategoryLabel(categoryID);
                                sb.append("\n\t");
                                sb.append(catName);
                                sb.append("\t");
                                for(Long accID: entry1.getValue()){
                                        EntityState astate = CreationUtils.getEntityState(accID);
                                        if(astate.getStatus() != EntityStatus.READY){
                                                continue;
                                        }
                                        String accName = astate.getBrand() + " " + astate.getModelName() + " " + astate.getModelNumber();
                                        sb.append(accName + " " + accID);
                                        sb.append("\t");
                                }
                        }
                        sb.append("\n");
                        
                        
                }
                //System.out.println(sb.toString());
                FileUtils.writeStringToFile(new File("/home/rajveer/Desktop/accfile"), sb.toString());
                //System.out.println(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;
                                        /*
                                        long memory = Long.parseLong(expBullet.getValue());
                                        long unitId = expBullet.getUnitID();
                                        if(unitId == 50008){
                                                memory = 1024 * memory;
                                        }
                                        */
                                }
                        }
                        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();
                                        //System.out.println(batteryCapacity + " = " + mobileBatteryCapacity);
                                        //System.out.println(batteryModel + " = " + mobileBatteryModel);
                                        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);
                                        }
                                }
                                System.out.println(sb1.toString());

                                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 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);
                                        }
                                }
                        }
                        System.out.println(entityParameterMap);
                        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);
                                        }
                                }
                        }
                        System.out.println(entityParameterMap);
                        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;
        }
        
}


/*
DefinitionsContainer defs = Catalog.getInstance().getDefinitionsContainer();

IRMetaDataJythonWrapper jy = new IRMetaDataJythonWrapper();

Map<Long, FacetDefinition> facetDefs = defs.getFacetDefinitions();
for(FacetDefinition facetDef : facetDefs.values()) {
        
        jy.reset();
        jy.initialize();

        ExpandedFacetDefinition expFacetDef = 
                new ExpandedFacetDefinition(facetDef);
        
        jy.setExpandedFacetDefinition(expFacetDef);
        
        jy.setPossibleValues(facetIDFacetValues.get(facetDef.getID()));
        
        jy.executeRule();
        
        String facetXMLSnip = jy.getXMLSnippet();
        Utils.info("facetXMLSnip=" + facetXMLSnip);
}
*/