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();

    	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;

	}

}