Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.repository.dtr;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

import com.mongodb.*;

import com.mongodb.client.AggregateIterable;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.MongoDatabase;

import com.mongodb.util.JSON;

import com.spice.profitmandi.dao.entity.dtr.NotificationCampaigns;

import com.spice.profitmandi.dao.model.ContentPojo;

import com.spice.profitmandi.dao.model.external.CatalogContentModel;

import com.spice.profitmandi.dao.model.FofoForm;

import com.spice.profitmandi.dao.model.RetailerFofoInterest;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.bson.Document;

import org.json.JSONObject;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class Mongo {

    private static final Logger LOGGER = LogManager.getLogger(Mongo.class);

    private static final String CONTENT = "CONTENT";

    private volatile boolean closed = false;

    private static final String SITE_CONTENT = "siteContent";

    private static final String CATALOG_DB = "Catalog";

    private static final String MASTER_DATA = "MasterData";

    private static final String FOFO_DB = "Fofo";

    private static final String FOFO_BRANDS = "brands";

    private static final String PROFITMANDI_BANNERS = "banners";

    private static final String RETAILER_FOFO_INTEREST = "RetailerFofoInterest";

    private static final String FOFO_FORM_COLLECTION = "RegistrationForm";

    private static final String NOTIFICATION_CAMPAIGNS = "notificationcampaigns";

    private static final String USER_DB = "User";

    private static final int MONGO_PORT = 27017;

    private static final Gson gson = new Gson();

    private MongoClient mongoClient;

    private MongoClient contentMongoClient;

    public Mongo(String mongoHost, String contentMongoHost) {

        try {

            LOGGER.info("mongoHost => {}, contentMongoHost {} ", mongoHost, contentMongoHost);

            mongoClient = new MongoClient(mongoHost, MONGO_PORT);

            contentMongoClient = new MongoClient(contentMongoHost, MONGO_PORT);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public ContentPojo getEntityById(long id) throws Exception {

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        BasicDBObject obj = new BasicDBObject();

        obj.append("_id", id);

        DBObject result = collection.findOne(obj);

        if (result == null) {

            throw new Exception();

        }

        //LOGGER.info(result.toMap());

        ContentPojo cp = gson.fromJson(new BasicDBObject(result.toMap()).toJson(), ContentPojo.class);

        if (cp.getDefaultImageUrl() != null) {

            cp.setDefaultImageUrl(cp.getDefaultImageUrl().replaceAll("saholic", "smartdukaan"));

        }

        //LOGGER.info("cp" + cp);

        return cp;

    }

    public Map<Long, ContentPojo> getEntitiesByIds(List<Long> ids) {

        Map<Long, ContentPojo> result = new HashMap<>();

        if (ids == null || ids.isEmpty()) return result;

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        BasicDBObject query = new BasicDBObject("_id", new BasicDBObject("$in", ids));

        DBCursor cursor = collection.find(query);

        while (cursor.hasNext()) {

            DBObject doc = cursor.next();

            try {

                long docId = ((Number) doc.get("_id")).longValue();

                ContentPojo cp = gson.fromJson(new BasicDBObject(doc.toMap()).toJson(), ContentPojo.class);

                if (cp.getDefaultImageUrl() != null) {

                    cp.setDefaultImageUrl(cp.getDefaultImageUrl().replaceAll("saholic", "smartdukaan"));

                }

                result.put(docId, cp);

            } catch (Exception e) {

                // skip malformed entries

            }

        }

        cursor.close();

        return result;

    }

    /**

     * siteContent docs for the /external catalogMaster feed, ordered by _id,

     * restricted to the given categoryIds (docs without a stamped categoryId

     * are invisible — the one-time backfill is mandatory).

     * sinceMillis == null: all docs. Otherwise docs whose lastModified >= since

     * OR that have no lastModified yet (pre-backfill docs stay visible).

     */

    public List<CatalogContentModel> getSiteContentPage(Collection<Integer> categoryIds, Long sinceMillis,

            int offset, int limit) {

        List<CatalogContentModel> result = new ArrayList<>();

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        DBCursor cursor = collection.find(siteContentFilter(categoryIds, sinceMillis))

                .sort(new BasicDBObject("_id", 1)).skip(offset).limit(limit);

        while (cursor.hasNext()) {

            DBObject doc = cursor.next();

            try {

                long docId = ((Number) doc.get("_id")).longValue();

                // read directly off the doc: NumberLong renders as {"$numberLong":...}

                // in toJson, which gson cannot map onto a Long field

                Object lastModified = doc.get("lastModified");

                ContentPojo cp = gson.fromJson(new BasicDBObject(doc.toMap()).toJson(), ContentPojo.class);

                if (cp.getDefaultImageUrl() != null) {

                    cp.setDefaultImageUrl(cp.getDefaultImageUrl().replaceAll("saholic", "smartdukaan"));

                }

                result.add(new CatalogContentModel(docId,

                        lastModified == null ? null : ((Number) lastModified).longValue(), cp));

            } catch (Exception e) {

                // skip malformed entries

            }

        }

        cursor.close();

        return result;

    }

    public long countSiteContent(Collection<Integer> categoryIds, Long sinceMillis) {

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        return collection.count(siteContentFilter(categoryIds, sinceMillis));

    }

    private static DBObject siteContentFilter(Collection<Integer> categoryIds, Long sinceMillis) {

        List<DBObject> and = new ArrayList<>();

        and.add(new BasicDBObject("categoryId", new BasicDBObject("$in", new ArrayList<>(categoryIds))));

        if (sinceMillis != null) {

            List<DBObject> or = new ArrayList<>();

            or.add(new BasicDBObject("lastModified", new BasicDBObject("$gte", sinceMillis)));

            or.add(new BasicDBObject("lastModified", new BasicDBObject("$exists", false)));

            and.add(new BasicDBObject("$or", or));

        }

        return new BasicDBObject("$and", and);

    }

    public ContentPojo getEntityByName(String name) throws Exception {

        //LOGGER.info("Name --- {}", name);

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        BasicDBObject obj = new BasicDBObject();

        obj.append("title", name);

        DBObject result = collection.findOne();

        if (result == null) {

            throw new Exception();

        }

        return gson.fromJson(new BasicDBObject(result.toMap()).toJson(), ContentPojo.class);

    }

    public void persistEntity(ContentPojo contentPojo) {

        DB db = contentMongoClient.getDB(CONTENT);

        DBCollection collection = db.getCollection(SITE_CONTENT);

        if (contentPojo.getCategoryId() == null) {

            // full-doc replace below would wipe the stamped categoryId; carry it forward

            DBObject existing = collection.findOne(new BasicDBObject("_id", contentPojo.getId()),

                    new BasicDBObject("categoryId", 1));

            if (existing != null && existing.get("categoryId") != null) {

                contentPojo.setCategoryId(((Number) existing.get("categoryId")).intValue());

            }

        }

        insertOrUpdateById(collection, contentPojo.getId(), contentPojo);

    }

    private static <T> void insertOrUpdateById(DBCollection collection, long id, T obj) {

        DBObject dbo = BasicDBObject.parse(gson.toJson(obj));

        LOGGER.info("dbo {}", dbo);

        dbo.put("_id", id);

        // full-document replace below, so the delta-sync marker must be (re)stamped here

        dbo.put("lastModified", System.currentTimeMillis());

        Object result = collection.update(new BasicDBObject("_id", id), dbo, true, false);

        LOGGER.info("result mongo {}", result);

    }

    public JSONObject getItemsByBundleId(long bundleId) throws Exception {

        DB db = mongoClient.getDB(CATALOG_DB);

        DBCollection collection = db.getCollection(MASTER_DATA);

        BasicDBObject obj = new BasicDBObject();

        BasicDBObject in_query = new BasicDBObject();

        obj.append("skuBundleId", bundleId);

        in_query.append("$in", new int[]{1, 2, 3, 4, 5, 6, 7});

        obj.append("source_id", in_query);

        DBObject result = collection.findOne(obj);

        if (result == null) {

            throw new Exception();

        }

        return new JSONObject(JSON.serialize(result));

    }

    public JSONObject getItemByID(long id) throws Exception {

        DB db = mongoClient.getDB(CATALOG_DB);

        DBCollection collection = db.getCollection(MASTER_DATA);

        BasicDBObject obj = new BasicDBObject();

        obj.append("_id", id);

        DBObject result = collection.findOne(obj);

        if (result == null) {

            throw new Exception();

        }

        return new JSONObject(JSON.serialize(result));

    }

    public void persistFofoRegInfo(FofoForm ff) {

        DB db = mongoClient.getDB(FOFO_DB);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        if (ff.get_id() == 0) {

            BasicDBObject orderBy = new BasicDBObject();

            orderBy.put("_id", -1);

            DBCursor cursor = collection.find().sort(orderBy).limit(1);

            long id = 1l;

            while (cursor.hasNext()) {

                FofoForm existingFofo = gson.fromJson(cursor.next().toString(), FofoForm.class);

                id = existingFofo.get_id() + 1;

            }

            ff.set_id(id);

        }

        DBObject dbObject = (DBObject) JSON.parse(gson.toJson(ff));

        collection.save(dbObject);

    }

    public List<FofoForm> getFofoForms(int offset, int limit) {

        List<FofoForm> ffList = new ArrayList<FofoForm>();

        DB db = mongoClient.getDB(FOFO_DB);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        BasicDBObject orderBy = new BasicDBObject();

        orderBy.put("_id", -1);

        DBCursor dbc = collection.find().sort(orderBy).limit(limit).skip(offset);

        while (dbc.hasNext()) {

            ffList.add(convertJSONToPojo(dbc.next().toString()));

        }

        return ffList;

    }

    public String getFofoFormJsonStringByFofoId(int fofoId) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("_id", fofoId);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        DBObject fofoDbOject = collection.findOne(filter);

        if (fofoDbOject != null) {

            return fofoDbOject.toString();

        } else {

            return null;

        }

    }

    public String getFofoFormJsonStringByEmail(String email) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("registeredEmail1", email);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        DBObject fofoDbOject = collection.findOne(filter);

        if (fofoDbOject != null) {

            return fofoDbOject.toString();

        } else {

            return null;

        }

    }

    public String getFofoFormsJsonString() {

        DB db = mongoClient.getDB(FOFO_DB);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        DBCursor cursor = collection.find();

        StringBuilder fofoFormsJsonString = new StringBuilder();

        fofoFormsJsonString.append("[");

        while (cursor.hasNext()) {

            fofoFormsJsonString.append(cursor.next().toString());

            if (cursor.hasNext()) {

                fofoFormsJsonString.append(",");

            }

        }

        fofoFormsJsonString.append("]");

        return fofoFormsJsonString.toString();

    }

    public FofoForm getFofoForm(int fofoId) {

        String fofoFormJsonString = getFofoFormJsonStringByFofoId(fofoId);

        System.out.println(fofoFormJsonString);

        return new Gson().fromJson(fofoFormJsonString, FofoForm.class);

        // return convertJSONToPojo(fofoDbOject.toString());

    }

    public FofoForm getFofoForm(String email) {

        String fofoFormJsonString = getFofoFormJsonStringByEmail(email);

        System.out.println(fofoFormJsonString);

        return new Gson().fromJson(fofoFormJsonString, FofoForm.class);

        // return convertJSONToPojo(fofoDbOject.toString());

    }

    private static FofoForm convertJSONToPojo(String json) {

        Type type = new TypeToken<FofoForm>() {

        }.getType();

        return new Gson().fromJson(json, type);

    }

    public void updateColumnsById(Map<String, Integer> map, int fofoId) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("_id", fofoId);

        DBCollection collection = db.getCollection(FOFO_FORM_COLLECTION);

        BasicDBObject updateFields = new BasicDBObject();

        for (Map.Entry<String, Integer> entry : map.entrySet()) {

            updateFields.append(entry.getKey(), entry.getValue());

        }

        BasicDBObject newDocument = new BasicDBObject();

        newDocument.append("$set", updateFields);

        collection.update(filter, newDocument);

    }

    public List<DBObject> getBrandsToDisplay(int categoryId) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("active", true);

        if (categoryId != 0) {

            filter.append("categoryId", categoryId);

        }

        return db.getCollection(FOFO_BRANDS).find(filter).toArray();

    }

    public List<DBObject> getAllBrandsToDisplay(int categoryId) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        if (categoryId != 0) {

            filter.append("categoryId", categoryId);

        }

        return db.getCollection(FOFO_BRANDS).find(filter).toArray();

    }

    public List<DBObject> getBannersByType(String bannerType) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("type", bannerType);

        BasicDBObject orderBy = new BasicDBObject();

        orderBy.put("rank", 1);

        return db.getCollection(PROFITMANDI_BANNERS).find(filter).sort(orderBy).toArray();

    }

    @SuppressWarnings("unchecked")

    public List<Document> getSubcategoriesToDisplay() {

        MongoDatabase db = mongoClient.getDatabase("Catalog");

        System.out.println("Connection to MongoDB database successfully");

        MongoCollection<Document> collection = db.getCollection("Deals");

        Document object = new Document().append("$match", new Document().append("category_id", 6).append("showDeal", 1)

                .append("dealRankPoints", new Document("$gt", 0)));

        Document ob = new Document("$group",

                new Document().append("_id",

                                new Document().append("subCategoryId", "$subCategoryId").append("subCategory", "$subCategory"))

                        .append("count", new Document("$sum", 1)));

        List<Document> pipeline = Arrays.asList(object, ob);

        AggregateIterable<Document> cursor = collection.aggregate(pipeline);

        List<Document> resultDocuments = new ArrayList<>();

        for (Document dbo : cursor) {

            System.out.println(dbo.toString());

            LOGGER.info("categories" + dbo.toString());

            resultDocuments.add(dbo);

        }

        return resultDocuments;

    }

    public boolean saveRetailerInterestOnFofo(RetailerFofoInterest retailerInterest) {

        DB db = mongoClient.getDB(FOFO_DB);

        Gson gs = new Gson();

        DBCollection fofoInterestCollection = db.getCollection(RETAILER_FOFO_INTEREST);

        DBObject dbObject = (DBObject) JSON.parse(gs.toJson(retailerInterest));

        fofoInterestCollection.save(dbObject);

        return true;

    }

    public boolean hasRetailerShownInterest(int userId) {

        DB db = mongoClient.getDB(FOFO_DB);

        BasicDBObject filter = new BasicDBObject();

        filter.append("userId", userId);

        DBCollection fofoInterestCollection = db.getCollection(RETAILER_FOFO_INTEREST);

        return fofoInterestCollection.findOne(filter) != null;

    }

    public void persistNotificationCmpInfo(NotificationCampaigns ff) {

        DB db = mongoClient.getDB(USER_DB);

        DBCollection collection = db.getCollection(NOTIFICATION_CAMPAIGNS);

        if (ff.get_id() == 0) {

            BasicDBObject orderBy = new BasicDBObject();

            orderBy.put("_id", -1);

            DBCursor cursor = collection.find().sort(orderBy).limit(1);

            long id = 1l;

            while (cursor.hasNext()) {

                Gson gson = new Gson();

                NotificationCampaigns existingFofo = gson.fromJson(cursor.next().toString(),

                        NotificationCampaigns.class);

                id = existingFofo.get_id() + 1;

            }

            ff.set_id(id);

        }

        Gson gs = new Gson();

        DBObject dbObject = (DBObject) JSON.parse(gs.toJson(ff));

        collection.save(dbObject);

    }

    /**

     * Close MongoDB connections to prevent memory leaks on shutdown

     */

    public void close() {

        if (closed) {

            return;

        }

        closed = true;

        LOGGER.info("Closing MongoDB connections...");

        try {

            if (mongoClient != null) {

                mongoClient.close();

                LOGGER.info("Main MongoClient closed");

            }

        } catch (Exception e) {

            LOGGER.error("Error closing mongoClient", e);

        }

        try {

            if (contentMongoClient != null) {

                contentMongoClient.close();

                LOGGER.info("Content MongoClient closed");

            }

        } catch (Exception e) {

            LOGGER.error("Error closing contentMongoClient", e);

        }

    }

}