Subversion Repositories SmartDukaan

package in.shop2020.storage.mongo;

import in.shop2020.metamodel.core.BulletDataObject;
import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.EntityState;
import in.shop2020.metamodel.core.ExpertReview;
import in.shop2020.metamodel.core.ExpertReviewSource;
import in.shop2020.metamodel.core.Helpdoc;
import in.shop2020.metamodel.core.SpecialPage;
import in.shop2020.metamodel.util.ExpandedBullet;
import in.shop2020.metamodel.util.ItemPojo;
import in.shop2020.storage.mongo.adapters.BDOAdapter;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.util.JSON;

/**
 * Entry point for storing everything in berkley database. Singleton class which initialises the berkley database.
 * @author rajveer
 *
 */
public class StorageManager {
        private static Log            log                         = LogFactory.getLog(StorageManager.class);
        private static DB db;
    public static ContentViews views;
    private static StorageManager storageUtils;
    private static final Gson gs = new GsonBuilder().
        registerTypeAdapter(BulletDataObject.class, new BDOAdapter()).
        //registerTypeAdapter(FreeformContent.class, new FFCAdapter()).
        create();
    
    static{
                synchronized(StorageManager.class){
                        try {
                                storageUtils = new StorageManager("CONTENT");
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
    
    /**
     * Run the sample program.
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        String jsonDeals = StorageManager.getStorageManager().getDealsJson(1007521l);
        System.out.println(jsonDeals);
    }

    /**
     * get storage manager
     * @return MongoStorageManager
     */
    public static StorageManager getStorageManager(){
                return storageUtils;
    }
    
    /**
     * Open the database and views.
     */
    private StorageManager(String mongoDB) throws Exception {
                        MongoClient mongo = new MongoClient( "localhost" , 27017 );
                        db = mongo.getDB(mongoDB);      
                        views = ContentViews.getInstance(db);
    }

    /**
     * Get the entities for a given category
     * @param categoryId
     * @return Collection<Entity>
     */
    public Collection<Entity> getEntitisByCategory(long categoryId){
        List <Entity> list = new ArrayList<Entity>();
        DBObject dbo = new BasicDBObject();
        dbo.put("categoryID", categoryId);
        Iterator<DBObject> it = views.entity.find(dbo).iterator();
        while (it.hasNext()) {
                list.add((Entity)toObject(it.next(),Entity.class));
        }
        return list;
        
    }
    
    
    /**
     * get all helpdocs
     * @return
     */
        public Map<Long, Helpdoc> getHelpdocs(){
        Map<Long, Helpdoc> helpdocs = new HashMap<Long, Helpdoc>();
        Iterator<DBObject> iterator = views.helpdoc.find().iterator();
        while (iterator.hasNext()){
                DBObject dbo = iterator.next();
                helpdocs.put((Long)dbo.get("_id"), (Helpdoc)toObject(dbo, Helpdoc.class));
        }
        return helpdocs;
    }
    
    /**
     * Get helpdoc for an given id
     * @param helpdocId
     * @return
     */
    public Helpdoc getHelpdoc(long helpdocId){
        return getById(views.helpdoc, helpdocId, Helpdoc.class);
    }

    /**
     * Delete helpdoc for an given id
     * @param helpdocId
     * @return
     */
    public void deleteHelpdoc(long helpdocId){
        views.helpdoc.remove(new BasicDBObject("_id", helpdocId));
    }

        public void updateHelpdoc(Helpdoc helpdoc){
        insertOrUpdateById(views.helpdoc, helpdoc.getID(), helpdoc);
    }

        /**
     * get metadata for all entities
     * @return
     */
        public Map<Long, EntityState> getEntitiesMetadata(){
        Map<Long,EntityState> es = new TreeMap<Long, EntityState>();
        /*DBObject findDbo = new BasicDBObject().append(
                "$set", new BasicDBObject().append("id", 10000));*/
        
        //Iterator<DBObject> iterator = views.entityMetadata.find(findDbo).iterator();
        Iterator<DBObject> iterator = views.entityMetadata.find().iterator();
        while (iterator.hasNext()){
                DBObject dbo = iterator.next();
                es.put((Long)dbo.get("_id"),(EntityState)toObject(dbo, EntityState.class));
        }
        return es;
    }
    
    /**
     * Get metadata for an given entity.
     * @param entityId
     * @return
     */
    public EntityState getEntityMetadata(long entityId){
        return (EntityState)getById(views.entityMetadata, entityId, EntityState.class);
    }

    /**
     * update metadata for an given entity
     * @param entityMetadata
     */
        public void updateEntityMetadata(EntityState entityMetadata){
        insertOrUpdateById(views.entityMetadata, entityMetadata.getID(), entityMetadata);
    }

    /**
     * Get entity for given id.
     * @param entityId
     * @return
     * @throws Exception
     */
    public Entity getEntity(long entityId) throws Exception{
        return (Entity)getById(views.entity, entityId, Entity.class);
    }
    
    /**
     * Update an existing entity
     * @param entity
     * @throws Exception
     */
    public void updateEntity(Entity entity) throws Exception{
        insertOrUpdateById(views.entity,entity.getID(),entity);
    }
        
    /**
     * Get all entities.
     * @return
     * @throws Exception
     */
        public Map<Long, Entity> getEntities() throws Exception{
        Map<Long,Entity> map = new TreeMap<Long, Entity>(); 
        Iterator<DBObject> iterator = views.entity.find().iterator();
        while(iterator.hasNext()){
                DBObject dbo = iterator.next();
                map.put((Long)dbo.get("_id"), (Entity)toObject(dbo, Entity.class));
        }
        return map;
    }
    


    /**
     * Returns all special pages from the database.
     */
    public Map<Long, SpecialPage> getSpecialPages() {
        Map<Long,SpecialPage> map = new TreeMap<Long, SpecialPage>(); 
        Iterator<DBObject> iterator = views.specialPages.find().iterator();
        while(iterator.hasNext()){
                DBObject dbo = iterator.next();
                Long pageId = (Long)dbo.removeField("_id");
                map.put(pageId, (SpecialPage)toObject(dbo, SpecialPage.class));
        }
        return map;
    }

    /**
     * Updates a given special page in the database.
     */
    public void updateSpecialPage(SpecialPage specialPage) {
        insertOrUpdateById(views.specialPages, specialPage.getID(), specialPage);
    }

    /**
     * Returns a special page object given a id after looking it up from map
     * of values loaded from database.
     */
    public SpecialPage getSpecialPage(long specialPageId) {
        return (SpecialPage)getById(views.specialPages, specialPageId, SpecialPage.class);
    }

    /**
     * Removes a special page from database, if exists in database.
     */
    public void deleteSpecialPage(long specialPageId) {
        removeById(views.specialPages, specialPageId);
    }
    
    @SuppressWarnings("unchecked")
    private static <T> T toObject(DBObject dbo, Type t) {
        dbo.removeField("_id");
        return (T)gs.fromJson(dbo.toString(), t);
    }

    @SuppressWarnings("unchecked")
    public static <T> T getById(DBCollection collection, Long id, Type t) {
        DBObject dbo = collection.findOne(id);
        if(dbo ==null) return null;
        if (dbo.get(id.toString()) != null){
                return (T)gs.fromJson(dbo.get(id.toString()).toString(), t);
        }
        dbo.removeField("_id");
        return (T)gs.fromJson(dbo.toString(), t);
    }

    public static <T> void insertOrUpdateById  (DBCollection collection, long id, T obj) {
        DBObject dbo = (DBObject)JSON.parse(gs.toJson(obj));
        dbo.put("_id", id);
        collection.update(new BasicDBObject("_id", id ), dbo, true, false);
    }

    public static <T> void addById  (DBCollection collection, long id, T obj) {
        DBObject dbo = (DBObject)JSON.parse(gs.toJson(obj));
        
        //dbo.put("_id", id);
        collection.update(new BasicDBObject("_id", id ), new BasicDBObject("$set", dbo), true, false);
    }

    private static void removeById(DBCollection collection, Long id) {
        collection.remove(new BasicDBObject("_id", id));
    }
    
    public void storeDataObject(String dataObjectName, Object dataObject) throws Exception{
        DBCollection collection = db.getCollection(dataObjectName);
        Map <String, Object>  obj = new HashMap<String, Object>();
        obj.put("1", dataObject);
        insertOrUpdateById(collection, 1L, obj);
    }
    
    @SuppressWarnings("unchecked")
    public <T> T getDataObject(String dataObjectName, Type t) throws Exception{
        DBCollection collection = db.getCollection(dataObjectName);
        return (T)getById(collection, 1L, t);
    }

        public Long getMaxPageId() {
                Iterator<DBObject> dbo = views.specialPages.find().sort(new BasicDBObject("_id", -1)).limit(1).iterator();
                while  (dbo.hasNext()) {
                        DBObject dbo1 = dbo.next();
                        return (Long) dbo1.get("_id");
                }
                return 0l;
        }
        
        public void deleteEntity(long entityId) {
                removeById(views.entity, entityId);
                removeById(views.entityMetadata, entityId);
        }
        
        public void createEntity(Entity entity, EntityState entityMetadata) {
                insertOrUpdateById(views.entity, entity.getID(), entity);
                insertOrUpdateById(views.entityMetadata, entity.getID(), entityMetadata);
        }
        
        public void storeCustomSlideScores(long entityId, Map<Long, Double> customSlideScores) {
                insertOrUpdateById(views.customSlideScores, entityId, customSlideScores);
        }
        
        public Map<Long,Double> getCustomSlideScores(long entityId) {
                Type t = new TypeToken<Map<Long,Double>>() {}.getType();
                return getById(views.customSlideScores, entityId, t);
        }

        public void storeLearnedBullets( Map<Long, List<ExpandedBullet>> learnedBullets) {
                
                for(Map.Entry<Long, List<ExpandedBullet>> learnedBullet : learnedBullets.entrySet()) {
                        insertOrUpdateById(views.learnedBullets, learnedBullet.getKey(), new BasicDBObject(learnedBullet.getKey().toString(), learnedBullet.getValue()));
                }
        }
        

        @SuppressWarnings("unchecked")
        public Map<Long, List<ExpandedBullet>> getLearnedBullets() {
                Type t = new TypeToken<List<ExpandedBullet>>() {}.getType();
                Map<Long, List<ExpandedBullet>> learnedBullets  = new HashMap<Long, List<ExpandedBullet>>();
                Iterator<DBObject> iter = views.learnedBullets.find();
                while (iter.hasNext()) {
                        DBObject dbo = iter.next();
                        String featureId = dbo.get("_id").toString();
                        learnedBullets.put(Long.parseLong(featureId), (List<ExpandedBullet>)gs.fromJson(dbo.get(featureId).toString(), t));
                }
                return learnedBullets;
        }
        
        public Set<ExpandedBullet> getLearnedBulletsByFeatureId (long featureId){
                Type t = new TypeToken<Set<ExpandedBullet>>() {}.getType();
                return getById(views.learnedBullets, featureId, t);
        }
        
        
        public void storeSearchStats(Long date, Map<String,List<String>> searchTerms){
                insertOrUpdateById(views.searchStats, date, searchTerms);
        }
        
        public void deleteSearchStats(Long date){
                removeById(views.searchStats, date);
        }
        
        public List<String> getSearchStats(Long date){
                Type t = new TypeToken<List<String>>() {}.getType();
                return getById(views.searchStats, date, t);
        }

        public ExpertReviewSource getExpertReviewSource(long sourceId) {
                return getById(views.expertReviewSource, sourceId, ExpertReviewSource.class);
        }
        
        public Set<ExpertReviewSource> getExpertReviewSources() {
                Iterator<DBObject> sourcesObj = views.expertReviewSource.find().iterator();
                Set<ExpertReviewSource> expSources = new HashSet<ExpertReviewSource>();
                while(sourcesObj.hasNext()){
                        DBObject dbobj = sourcesObj.next();
                        expSources.add((ExpertReviewSource)toObject(dbobj, ExpertReviewSource.class));
                }
                return expSources;
        }
        
        public void storeExpertReviewSource(ExpertReviewSource expertReviewSource) {
                insertOrUpdateById(views.expertReviewSource, (long)expertReviewSource.hashCode(), expertReviewSource);
        }

        public void deleteExpertReviewSource(ExpertReviewSource expertReviewSource) {
                removeById(views.expertReviewSource, (long)expertReviewSource.hashCode());
        }

        public void storeExpertReview(long entityId, ExpertReview expertReview){
                Type t = new TypeToken<List<ExpertReview>>() {}.getType();
                List<ExpertReview> expertReviews = getById(views.expertReviews, entityId, t);
                if(expertReviews == null) {
                        expertReviews = new ArrayList<ExpertReview>();
                }
                expertReviews.add(expertReview);
                Map<Long,List<ExpertReview>> erMap = new HashMap<Long, List<ExpertReview>>();
                erMap.put(entityId, expertReviews);
                insertOrUpdateById(views.expertReviews, entityId, erMap);
                
        }

        public void storeExpertReview(long entityId, List<ExpertReview> expertReviews) {
                Map<Long, List<ExpertReview>> map = new HashMap<Long, List<ExpertReview>>();
                map.put(entityId, expertReviews);
                insertOrUpdateById(views.expertReviews, entityId, map);
        }

        public void deleteExpertReview(long entityId, int index) {
                Type t = new TypeToken<List<ExpertReview>>() {}.getType();
                List<ExpertReview> er = getById(views.expertReviews, entityId, t);
                er.remove(index);
                storeExpertReview(entityId, er);
        }

        @SuppressWarnings("unchecked")
        public Map<Long, List<ExpertReview>> getExpertReviews() {
                Type t = new TypeToken<List<ExpertReview>>() {}.getType();
                Map<Long, List<ExpertReview>> er  = new HashMap<Long, List<ExpertReview>>();
                Iterator<DBObject> iter = views.expertReviews.find();
                while (iter.hasNext()) {
                        DBObject dbo = iter.next();
                        String entityId = dbo.get("_id").toString();
                        er.put(Long.parseLong(entityId), (List<ExpertReview>)gs.fromJson(dbo.get(entityId).toString(), t));
                }
                return er;
        }

        public void deleteExpertReview(long entityId) {
                removeById(views.expertReviews, entityId);
        }


        @SuppressWarnings("unchecked")
        public Map<Long, List<Long>> getHelpdocEntityIds() {
                Type t = new TypeToken<List<Long>>() {}.getType();
                Map<Long, List<Long>> er  = new HashMap<Long, List<Long>>();
                Iterator<DBObject> iter = views.helpdocEntityIds.find().iterator();
                while (iter.hasNext()) {
                        DBObject dbo = iter.next();
                        String helpdocId = dbo.get("_id").toString();
                        er.put(Long.parseLong(helpdocId), (List<Long>)gs.fromJson(dbo.get(helpdocId).toString(), t));
                }
                return er;
        }

        public List<ExpertReview> getExpertReviewByEntity(long entityId) {
                Type t = new TypeToken<List<ExpertReview>>() {}.getType();
                return getById(views.expertReviews, entityId, t);
        }
        
        public String getDealsJson(Long entityId){
                Type t = new TypeToken<ItemPojo>() {}.getType();
                DBObject dboQuery=  new BasicDBObject().append("_id", entityId);
                DBObject dboProjection = new BasicDBObject("items.dealPojo", 1);
                DBObject dbo =  views.siteContent.findOne(dboQuery,dboProjection);
                if(dbo != null && dbo.get("items")!=null){
                        return dbo.get("items").toString();
                }
                return null;
        }
        
        
    public List<Long> getEntityIdsAfter(long time){
        List <Long> list = new ArrayList<Long>();
        Iterator<DBObject> it = StorageManager.views.entityMetadata.find(new BasicDBObject("$gt", new BasicDBObject("createdOn",time))).iterator();
        while (it.hasNext()) {
                EntityState emd = (EntityState)toObject(it.next(),EntityState.class);
                list.add(emd.getID());
        }
        return list;
        
    }
    
}