2222

package com.paic.wiseapm.alert.service.impl;

import com.mongodb.AggregationOutput;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.WriteResult;
import com.mongodb.client.model.DBCollectionCountOptions;
import com.paic.mario.common.model.metric.PageResult;
import com.paic.mario.toolkit.utils.MLoggerUtils;
import com.paic.mario.util.CommonUtils;
import com.paic.mario.util.PropertiesUtil;
import com.paic.mongo.model.AlertSetSend;
import com.paic.wiseapm.alert.constant.MongoTable;
import com.paic.wiseapm.alert.model.AlertEmailContent;
import com.paic.wiseapm.alert.model.EmailFolder;
import com.paic.wiseapm.alert.model.EmailRuleFilter;
import com.paic.wiseapm.alert.service.AlertEmailService;
import com.paic.wiseapm.alert.util.TimeUtil;
import com.pingan.wiseapm.util.DateFormatUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.BasicQuery;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

@Service
public class AlertEmailServiceImpl implements AlertEmailService {
    
    private String BEST_INDEX="time_-1_mailSC_1";

    private static List<String> SOURCES;
    static {
        String string = PropertiesUtil.getProperty("email.sources");
        if (StringUtils.isNotEmpty(string)) {
            SOURCES = new ArrayList<>(Arrays.asList(string.split(",")));
        }
    }

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public List<EmailFolder> getEmailFolders(String userId, String folderId) {
        List<EmailFolder> result = new ArrayList<>();
        if (StringUtils.isNotEmpty(userId) || StringUtils.isNotEmpty(folderId)) {
            Query query = new Query();
            if (StringUtils.isNotEmpty(folderId)) {
                query.addCriteria(new Criteria("folderId").is(folderId));
            }
            if (StringUtils.isNotEmpty(userId)) {
                query.addCriteria(new Criteria("accountId").is(userId));
            }
            result = mongoTemplate.find(query, EmailFolder.class, MongoTable.EMAIL_FOLDERS);
        }
        return result;
    }

    @Override
    public int getEmailCount(String startTime, String endTime, List<String> userIds, EmailRuleFilter filter) {
        long start = DateFormatUtil.parseDate(startTime).getTime() / 1000;
        long end = DateFormatUtil.parseDate(endTime).getTime() / 1000;
        BasicDBObject queryObject = new BasicDBObject();

        BasicDBObject timeObject = new BasicDBObject();
        timeObject.append("$gte", start);
        timeObject.append("$lt", end);
        queryObject.append("time", timeObject);

        if (CollectionUtils.isNotEmpty(SOURCES)) {
            BasicDBObject sourceObject = new BasicDBObject();
            sourceObject.append("$in", SOURCES);
            queryObject.append("source", sourceObject);
        }

        // List<BasicDBObject> userObjects = new ArrayList<>();
        // BasicDBObject userReObject = new BasicDBObject();
        // userReObject.append("$regex", userId);
        // userObjects.add(new BasicDBObject().append("tags.mail_s",
        // userReObject));
        // userObjects.add(new BasicDBObject().append("tags.mail_c",
        // userReObject));
        // queryObject.append("$or", userObjects);

        BasicDBObject userInObject = new BasicDBObject();
        userInObject.append("$in", userIds);
        queryObject.append("mailSC", userInObject);

        if (filter != null) {
            if (StringUtils.isNotEmpty(filter.getMailTitleWords())) {
                BasicDBObject titleReObject = new BasicDBObject();
                titleReObject.append("$regex", CommonUtils.makeRegExp(filter.getMailTitleWords()));
                queryObject.append("emailTitle", titleReObject);
            }
            if (StringUtils.isNoneEmpty(filter.getAlertLevel())) {
                BasicDBObject levelObject = new BasicDBObject();
                levelObject.append("$in", Arrays.asList(filter.getAlertLevel().split(";")));
                queryObject.append("alertLevel", levelObject);
            }

            if (StringUtils.isNoneEmpty(filter.getResource())) {
                BasicDBObject resObject = new BasicDBObject();
                resObject.append("$in", Arrays.asList(filter.getResource().split(";")));
                queryObject.append("tags.objName", resObject);
            }
        }

        Query query = new BasicQuery(queryObject);
        // query.withHint("time_-1_mailSC_1");
        MLoggerUtils.info("getEmailCount query:{}", query);
        long exeTime = System.currentTimeMillis();
        int step = PropertiesUtil.getIntWithDefault("email.table.split.step", 1);
        int result = 0;
        if (step == 1) {
            result = (int) mongoTemplate.count(query, MongoTable.ALERTSETSEND);
        }
        if (step == 2) {
            List<String> days = TimeUtil.getDays(start, end);
            if (days != null && days.size() > 0) {
                for (int i = 0; i < days.size(); i++) {
                   // int countOfDay = (int) mongoTemplate.count(query, MongoTable.ALERTSETSEND + "_" + days.get(i));
                    DBCollectionCountOptions options= new DBCollectionCountOptions();
                    options.hintString(BEST_INDEX);
                    int countOfDay=(int) mongoTemplate.countWithHint(query, null, MongoTable.ALERTSETSEND + "_" + days.get(i), options);
                    
                    result += countOfDay;
                }

            }

        }

        MLoggerUtils.info("getEmailCount cost:{}ms", System.currentTimeMillis() - exeTime);
        return result;
    }

    @Override
    public int getReadEmailCount(String startTime, String endTime, String userId, EmailRuleFilter filter) {
        long start = DateFormatUtil.parseDate(startTime).getTime() / 1000;
        long end = DateFormatUtil.parseDate(endTime).getTime() / 1000;
        BasicDBObject queryObject = new BasicDBObject();

        BasicDBObject timeObject = new BasicDBObject();
        timeObject.append("$gte", start);
        timeObject.append("$lt", end);
        queryObject.append("time", timeObject);

        // if(CollectionUtils.isNotEmpty(SOURCES)) {
        // BasicDBObject sourceObject=new BasicDBObject();
        // sourceObject.append("$in", SOURCES);
        // queryObject.append("source", sourceObject);
        // }

        queryObject.append("accountId", userId);

        if (filter != null) {
            if (StringUtils.isNotEmpty(filter.getMailTitleWords())) {
                BasicDBObject titleReObject = new BasicDBObject();
                titleReObject.append("$regex", CommonUtils.makeRegExp(filter.getMailTitleWords()));
                queryObject.append("emailTitle", titleReObject);
            }
            if (StringUtils.isNoneEmpty(filter.getAlertLevel())) {
                BasicDBObject levelObject = new BasicDBObject();
                levelObject.append("$in", Arrays.asList(filter.getAlertLevel().split(";")));
                queryObject.append("alertLevel", levelObject);
            }

            if (StringUtils.isNoneEmpty(filter.getResource())) {
                BasicDBObject resObject = new BasicDBObject();
                resObject.append("$in", Arrays.asList(filter.getResource().split(";")));
                queryObject.append("resource", resObject);
            }
        }

        Query query = new BasicQuery(queryObject);
        MLoggerUtils.info("getReadEmailCount query:{}", query);

        long exeTime = System.currentTimeMillis();
        int result = (int) mongoTemplate.count(query, MongoTable.EMAIL_READ);
        MLoggerUtils.info("getReadEmailCount cost:{}ms", System.currentTimeMillis() - exeTime);
        return result;
    }

    @Override
    public int getUnreadFavoriteEmailCount(String startTime, String endTime, String userId) {
        long start = DateFormatUtil.parseDate(startTime).getTime() / 1000;
        long end = DateFormatUtil.parseDate(endTime).getTime() / 1000;
        BasicDBObject queryObject = new BasicDBObject();

        BasicDBObject timeObject = new BasicDBObject();
        timeObject.append("$gte", start);
        timeObject.append("$lt", end);
        queryObject.append("time", timeObject);

        // if(CollectionUtils.isNotEmpty(SOURCES)) {
        // BasicDBObject sourceObject=new BasicDBObject();
        // sourceObject.append("$in", SOURCES);
        // queryObject.append("source", sourceObject);
        // }

        queryObject.append("accountId", userId);

        queryObject.append("emailReadFlag", false);
        Query query = new BasicQuery(queryObject);
        MLoggerUtils.info("getUnreadFavoriteEmailCount query:{}", query);
        long exeTime = System.currentTimeMillis();
        int result = (int) mongoTemplate.count(query, MongoTable.EMAIL_FAVORITES);
        MLoggerUtils.info("getUnreadFavoriteEmailCount cost:{}ms", System.currentTimeMillis() - exeTime);
        return result;
    }

    @Override
    public Map<String, Integer> getEmailCountByResource(Map<String, Object> param) {
        
        Object read = param.remove("emailReadFlag");
        String table = MongoTable.ALERTSETSEND;
        if (read != null) {
            table = MongoTable.EMAIL_READ;
        } else {
            if (CollectionUtils.isNotEmpty(SOURCES)) {
                Map<String, Object> sourceObject = new HashMap<>();
                sourceObject.put("$in", SOURCES);
                param.put("source", sourceObject);
            }
        }

        Map<String, Integer> result = new HashMap<>();
        BasicDBObject matchMap = new BasicDBObject(param);
        BasicDBObject groupFields = new BasicDBObject();
        BasicDBObject sumObj = new BasicDBObject("$sum", 1);
        groupFields.put("mailCount", sumObj);

        if (read != null) {
            BasicDBObject resObj = new BasicDBObject("$first", "$resource");
            groupFields.put("resource", resObj);

            groupFields.put("_id", "$resource");
        } else {
            BasicDBObject resObj = new BasicDBObject("$first", "$tags.objName");
            groupFields.put("resource", resObj);

            groupFields.put("_id", "$tags.objName");
        }

        BasicDBObject group = new BasicDBObject("$group", groupFields);
        BasicDBObject match = new BasicDBObject("$match", matchMap);

        List<DBObject> pipeline = Arrays.asList(match, group);
        MLoggerUtils.info("getEmailCountByResource {}", pipeline);

        int step = PropertiesUtil.getIntWithDefault("email.table.split.step", 1);
        if (step == 1 || table.equals(MongoTable.EMAIL_READ)) {
            long exeTime = System.currentTimeMillis();
            AggregationOutput output = mongoTemplate.getCollection(table).aggregate(match, group);
            MLoggerUtils.info("getEmailCountByResource cost:{}ms", System.currentTimeMillis() - exeTime);
            if (output != null) {
                Iterable<DBObject> messages = output.results();
                for (DBObject message : messages) {
                    if (message.get("resource") != null) {
                        String resource = message.get("resource").toString();
                        Integer count = (int) NumberUtils.toDouble(message.get("mailCount").toString());
                        result.put(resource, count);
                    }
                }
            }
        }
        if (step == 2 && table.equals(MongoTable.ALERTSETSEND)) {
            /*
             * Map<String, Object> timeObject=new HashMap<>();
             * timeObject.put("$gte", startTime); timeObject.put("$lt",
             * endTime); param.put("time", timeObject);
             */
            // get startTime, endTime
            Map<String, Object> timeObject = (Map<String, Object>) param.get("time");
            if (timeObject != null) {
                Object start = timeObject.get("$gte");
                Object end = timeObject.get("$lt");
                if (start != null && end != null) {
                    long startTime = Long.parseLong(new String(start.toString()));
                    long endTime = Long.parseLong(new String(end.toString()));

                    List<String> days = TimeUtil.getDays(startTime, endTime);
                    // int total = 0;
                    if (days != null && days.size() > 0) {
                        for (int i = 0; i < days.size(); i++) {
                            long t1=System.currentTimeMillis();
                            DBCollection dbc= mongoTemplate.getCollection(table + "_" + days.get(i));
                            List<DBObject> indexFields=new ArrayList<DBObject>();
                            DBObject index=new BasicDBObject();
                            //time_-1_mailSC_1
                            index.put("time", -1);
                            index.put("mailSC", 1);
                            indexFields.add(index);
                            
                            dbc.setHintFields(indexFields);
                            AggregationOutput output = dbc.aggregate(match, group);
                            MLoggerUtils.info("getEmailCountByResource cost by day "+ (System.currentTimeMillis()-t1)+"_"+days.get(i));
                            if (output != null) {
                                Iterable<DBObject> messages = output.results();
                                for (DBObject message : messages) {
                                    if (message.get("resource") != null) {
                                        String resource = message.get("resource").toString();
                                        int count = (int) NumberUtils.toDouble(message.get("mailCount").toString());
                                        int total = result.get(resource) == null ? 0 : result.get(resource);
                                        total += count;
                                        result.put(resource, total);

                                    }
                                }
                            }

                        }

                    }

                }

            }

        }

        return result;
    }

    @Override
    public PageResult<AlertEmailContent> getEmailList(Map<String, Object> param) {
        Integer pageNum = (Integer) param.remove("pageNum");
        Integer pageSize = (Integer) param.remove("pageSize");
        List<Long> countOfDays=new ArrayList<Long>();
        List<String> days=new ArrayList<String>();
        List<String> _idnot = (List<String>) param.remove("_idnot");
        if (_idnot != null) {
            List<ObjectId> readIds = new ArrayList<>();
            for (int i = 0; i < _idnot.size(); i++) {
                ObjectId objectId = new ObjectId(_idnot.get(i));
                readIds.add(objectId);
            }
            Map<String, Object> not = new HashMap<>();
            Map<String, Object> in = new HashMap<>();
            in.put("$in", readIds);
            not.put("$not", in);
            param.put("_id", not);
        }
        if (CollectionUtils.isNotEmpty(SOURCES)) {
            Map<String, Object> sourceObject = new HashMap<>();
            sourceObject.put("$in", SOURCES);
            param.put("source", sourceObject);
        }
        BasicDBObject queryObject = new BasicDBObject(param);
        Query query = new BasicQuery(queryObject);
         query.withHint(BEST_INDEX);
        PageResult<AlertEmailContent> result = new PageResult<>();

        BasicDBObject fieldsObject = new BasicDBObject();
        fieldsObject.append("tags", 1);
        fieldsObject.append("alertLevel", 1);
        fieldsObject.append("_id", 1);
        fieldsObject.append("emailTitle", 1);
        fieldsObject.append("eventId", 1);
        fieldsObject.append("source", 1);
        fieldsObject.append("time", 1);
        Query queryList = new BasicQuery(queryObject, fieldsObject);
        long count = 0;
        int step = PropertiesUtil.getIntWithDefault("email.table.split.step", 1);
        if (pageNum != null && pageSize != null) {
            MLoggerUtils.info("getEmailList count query:{}", query);
            long exeTime = System.currentTimeMillis();
            if (step == 1) {
                count = mongoTemplate.count(query, MongoTable.ALERTSETSEND);
            }
            if (step == 2) {
                Map<String, Object> timeObject = (Map<String, Object>) param.get("time");
                if (timeObject != null) {
                    Object start = timeObject.get("$gte");
                    Object end = timeObject.get("$lt");
                    if (start != null && end != null) {
                        long startTime = Long.parseLong(new String(start.toString()));
                        long endTime = Long.parseLong(new String(end.toString()));

                        days = TimeUtil.getDays(startTime, endTime);

                        if (days != null && days.size() > 0) {
                            for (int i = 0; i < days.size(); i++) {
                                //"time_-1_mailSC_1"
                               // long countOfDay = mongoTemplate.count(query, MongoTable.ALERTSETSEND + "_" + days.get(i));
                                DBCollectionCountOptions options= new DBCollectionCountOptions();
                                options.hintString(BEST_INDEX);
                            //    long t1=System.currentTimeMillis();
                            //    mongoTemplate.count(query,null, MongoTable.ALERTSETSEND + "_" + days.get(i));
                                long t2=System.currentTimeMillis();
                                long countOfDay = mongoTemplate.countWithHint(query,null, MongoTable.ALERTSETSEND + "_" + days.get(i)+"",options);
                                countOfDays.add(countOfDay);
                                long t3=System.currentTimeMillis();
                          //      MLoggerUtils.info("getEmailList count---without hint "+ (t2-t1)+ "_"+days.get(i));
                                MLoggerUtils.info("getEmailList count---with hint "+ (t3-t2)+"_"+days.get(i));
                                
                                count += countOfDay;
                            }

                        }

                    }

                }

            }
            MLoggerUtils.info("getEmailList count cost:{}ms", System.currentTimeMillis() - exeTime);
            result.setPageNum(pageNum);
            result.setPageSize(pageSize);
            result.setPages((int) count / pageSize + 1);
           // if (step == 1) {
            queryList.skip((pageNum - 1) * pageSize);
            queryList.limit(pageSize);
          //  }

        }

        queryList.with(new Sort(Sort.Direction.DESC, "time"));
        queryList.withHint(BEST_INDEX);
        MLoggerUtils.info("getEmailList query:{}", queryList);
        long exeTime = System.currentTimeMillis();
        List<AlertSetSend> oris = new ArrayList<AlertSetSend>();
        if (step == 1) {
            oris = mongoTemplate.find(queryList, AlertSetSend.class, MongoTable.ALERTSETSEND);
        }
        if (step == 2) {
            int skip = (pageNum - 1) * pageSize;

     
            if (days!=null && days.size()>0) {
                    if(days.size() == 1){// one day query
                        long t1=System.currentTimeMillis();
                         oris = mongoTemplate.find(queryList, AlertSetSend.class, MongoTable.ALERTSETSEND+"_"+days.get(0));
                         
                         MLoggerUtils.info("getEmailList cost:"+(System.currentTimeMillis()-t1)+"ms -"+ days.get(0));
                    }
//                    if( days.size() == 2){// two day query
//                        
//                        if(skip>=countOfDays.get(0)){//only need query the second day
//                            long t1=System.currentTimeMillis();
//                            queryList.skip((int) (skip-countOfDays.get(0)));
//                            oris = mongoTemplate.find(queryList, AlertSetSend.class, MongoTable.ALERTSETSEND+"_"+days.get(1));
//                            MLoggerUtils.info("getEmailList cost:"+(System.currentTimeMillis()-t1)+"ms -"+ days.get(1));
//                        }else{
//                            long t1=System.currentTimeMillis();
//                             List<AlertSetSend> yesterdayList=mongoTemplate.find(queryList, AlertSetSend.class, MongoTable.ALERTSETSEND+"_"+days.get(0));
//                             MLoggerUtils.info("getEmailList cost:"+(System.currentTimeMillis()-t1)+"ms -"+ days.get(0));
//                             if(yesterdayList!=null){
//                                
//                                 if(yesterdayList.size()<pageSize){// need fill others from the second days
//                                     queryList.skip(0);
//                                     queryList.limit(pageSize-yesterdayList.size());
//                                      t1=System.currentTimeMillis();
//                                     List<AlertSetSend> todayList=mongoTemplate.find(queryList, AlertSetSend.class, MongoTable.ALERTSETSEND+"_"+days.get(1));
//                                     MLoggerUtils.info("getEmailList cost:"+(System.currentTimeMillis()-t1)+"ms -"+ days.get(1));
//                                     if(todayList!=null){
//                                         oris.addAll(todayList);
//                                     }
//                                         
//                                 }
//                                 
//                                 oris.addAll(yesterdayList);
//                                 
//                             }
//                            
//                        }
//                                           
//                   }

                    if ( days.size() > 1) {// multiple days
                        long total=0;
                        
                        for(int i=0;i<countOfDays.size();i++){
                            total+=countOfDays.get(i);
                            if(total<(skip+oris.size())){
                                continue;
                            }else{
                                 long start=countOfDays.get(i)-(total-skip-oris.size());
                                 queryList.skip((int) start);
                                 queryList.limit(pageSize-oris.size());
                                 long t1=System.currentTimeMillis();
                                List<AlertSetSend> listOfDay = mongoTemplate.find(queryList, AlertSetSend.class,MongoTable.ALERTSETSEND + "_"+ days.get(i));
                                 MLoggerUtils.info("getEmailList cost:"+(System.currentTimeMillis()-t1)+"ms -"+ days.get(i));
                                if(listOfDay!=null){
                                    oris.addAll(0,listOfDay);
                                
                                    if(oris.size()>=pageSize){
                                        break;
                                    }
                                }
                            }
                            
                        }

                       

                    }

                

            }
        }

        MLoggerUtils.info("getEmailList cost:{}ms", System.currentTimeMillis() - exeTime);
        List<AlertEmailContent> list = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(oris)) {
            for (int i = 0; i < oris.size(); i++) {
                AlertSetSend sent = oris.get(i);
                AlertEmailContent content = new AlertEmailContent();
                content.setAlertId(sent.get_id());
                content.setAlertLevel(sent.getAlertLevel());
                content.setEmailTitle(sent.getEmailTitle());
                content.setEventId(sent.getEventId());
                content.setResource(String.valueOf(sent.getTags().get("objName")));
                content.setSource(sent.getSource());
                content.setTime(sent.getTime());
                content.setTags(sent.getTags());
                list.add(content);
            }
        }
        result.setList(list);
        if (count == 0) {
            count = list.size();
        }
        result.setTotal(count);
        return result;
    }

    @Override
    public List<String> getReadIds(Map<String, Object> readParam) {
        readParam.remove("pageSize");
        readParam.remove("pageNum");
        List<String> result = new ArrayList<>();
        BasicDBObject queryObject = new BasicDBObject(readParam);
        BasicDBObject fieldsObject = new BasicDBObject();
        fieldsObject.append("alertId", 1);
        fieldsObject.append("_id", 0);
        Query query = new BasicQuery(queryObject, fieldsObject);
        MLoggerUtils.info("getReadIds query:{}", query);
        long exeTime = System.currentTimeMillis();
        List<Map> list = mongoTemplate.find(query, Map.class, MongoTable.EMAIL_READ);
        MLoggerUtils.info("getReadIds count cost:{}ms", System.currentTimeMillis() - exeTime);
        if (CollectionUtils.isNotEmpty(list)) {
            for (int i = 0; i < list.size(); i++) {
                result.add(String.valueOf(list.get(i).get("alertId")));
            }

        }
        return result;
    }

    @Override
    public PageResult<AlertEmailContent> getReadEmailList(Map<String, Object> param) {
        Integer pageNum = (Integer) param.remove("pageNum");
        Integer pageSize = (Integer) param.remove("pageSize");
        BasicDBObject queryObject = new BasicDBObject(param);
        Query query = new BasicQuery(queryObject);

        PageResult<AlertEmailContent> result = new PageResult<>();
        long count = 0;
        if (pageNum != null && pageSize != null) {
            Query queryCount = new BasicQuery(queryObject);
            MLoggerUtils.info("getReadEmailList count query:{}", queryCount);
            long exeTime = System.currentTimeMillis();
            count = mongoTemplate.count(queryCount, MongoTable.EMAIL_READ);
            MLoggerUtils.info("getReadEmailList count cost:{}ms", System.currentTimeMillis() - exeTime);
            result.setPageNum(pageNum);
            result.setPageSize(pageSize);
            result.setPages((int) count / pageSize + 1);
            query.skip((pageNum - 1) * pageSize);
            query.limit(pageSize);
        }
        query.with(new Sort(Sort.Direction.DESC, "time"));
        MLoggerUtils.info("getReadEmailList query:{}", query);
        long exeTime = System.currentTimeMillis();
        List<AlertEmailContent> list = mongoTemplate.find(query, AlertEmailContent.class, MongoTable.EMAIL_READ);
        MLoggerUtils.info("getReadEmailList cost:{}ms", System.currentTimeMillis() - exeTime);
        result.setList(list);
        if (count == 0) {
            count = list.size();
        }
        result.setTotal(count);
        return result;
    }

    @Override
    public int addEmailFolders(EmailFolder folder) {
        int result = 0;
        try {
            mongoTemplate.insert(folder, MongoTable.EMAIL_FOLDERS);
            result = 1;
        } catch (Exception e) {
            MLoggerUtils.error(e.getMessage(), e);
        }
        return result;
    }

    @Override
    public int updateEmailFolders(EmailFolder folder) {
        int result = 0;
        try {
            Query query = new Query();
            query.addCriteria(new Criteria("folderId").is(folder.getFolderId()));
            Update update = new Update();
            update.set("folderName", folder.getFolderName());
            update.set("ruleFilter", folder.getRuleFilter());
            update.set("lcd", System.currentTimeMillis() / 1000);
            WriteResult writeResult = mongoTemplate.updateMulti(query, update, MongoTable.EMAIL_FOLDERS);
            result = writeResult.getN();
        } catch (Exception e) {
            MLoggerUtils.error(e.getMessage(), e);
        }
        return result;
    }

    @Override
    public int deleteEmailFolders(String folderId) {
        int result = 0;
        try {
            Query query = new Query();
            query.addCriteria(new Criteria("folderId").is(folderId));
            WriteResult writeResult = mongoTemplate.remove(query, MongoTable.EMAIL_FOLDERS);
            result = writeResult.getN();
        } catch (Exception e) {
            MLoggerUtils.error(e.getMessage(), e);
        }
        return result;
    }

    @Override
    public PageResult<AlertEmailContent> getFavoriteEmailList(Map<String, Object> param) {
        Integer pageNum = (Integer) param.remove("pageNum");
        Integer pageSize = (Integer) param.remove("pageSize");
        BasicDBObject queryObject = new BasicDBObject(param);
        Query query = new BasicQuery(queryObject);
        PageResult<AlertEmailContent> result = new PageResult<>();
        long count = 0;
        if (pageNum != null && pageSize != null) {
            Query queryCount = new BasicQuery(queryObject);
            MLoggerUtils.info("getFavoriteEmailList count query:{}", queryCount);
            long exeTime = System.currentTimeMillis();
            count = mongoTemplate.count(queryCount, MongoTable.EMAIL_FAVORITES);
            MLoggerUtils.info("getFavoriteEmailList count cost:{}ms", System.currentTimeMillis() - exeTime);
            result.setPageNum(pageNum);
            result.setPageSize(pageSize);
            result.setPages((int) count / pageSize + 1);
            query.with(new Sort(Sort.Direction.DESC, "time"));
            query.skip((pageNum - 1) * pageSize);
            query.limit(pageSize);
        }
        MLoggerUtils.info("getFavoriteEmailList query:{}", query);
        long exeTime = System.currentTimeMillis();
        List<AlertEmailContent> list = mongoTemplate.find(query, AlertEmailContent.class,
                MongoTable.EMAIL_FAVORITES);
        MLoggerUtils.info("getFavoriteEmailList cost:{}ms", System.currentTimeMillis() - exeTime);
        result.setList(list);
        if (count == 0) {
            count = list.size();
        }
        result.setTotal(count);
        return result;
    }

    @Override
    public int getExtralUnreadEmailCount(Map<String, Object> param) {
        Object read = param.remove("emailReadFlag");
        String table = MongoTable.ALERTSETSEND;
        if (read != null) {
            table = MongoTable.EMAIL_READ;
        } else {
            if (CollectionUtils.isNotEmpty(SOURCES)) {
                Map<String, Object> sourceObject = new HashMap<>();
                sourceObject.put("$in", SOURCES);
                param.put("source", sourceObject);
            }
        }

        BasicDBObject matchMap = new BasicDBObject(param);
        Query query = new BasicQuery(matchMap);

        MLoggerUtils.info("getExtralUnreadEmailCount {}", query);
        int step = PropertiesUtil.getIntWithDefault("email.table.split.step", 1);
        if (step == 1 || table.equals(MongoTable.EMAIL_READ)) {
            long exeTime = System.currentTimeMillis();
            long result = mongoTemplate.count(query, table);
            MLoggerUtils.info("getExtralUnreadEmailCount cost:{}ms", System.currentTimeMillis() - exeTime);

            return (int) result;
        }
        if (step == 2 && table.equals(MongoTable.ALERTSETSEND)) {

            long total = 0;
            /*
             * Map<String, Object> timeObject=new HashMap<>();
             * timeObject.put("$gte", startTime); timeObject.put("$lt",
             * endTime); param.put("time", timeObject);
             */
            // get startTime, endTime
            Map<String, Object> timeObject = (Map<String, Object>) param.get("time");
            if (timeObject != null) {
                Object start = timeObject.get("$gte");
                Object end = timeObject.get("$lt");
                if (start != null && end != null) {
                    long startTime = Long.parseLong(new String(start.toString()));
                    long endTime = Long.parseLong(new String(end.toString()));

                    List<String> days = TimeUtil.getDays(startTime, endTime);

                    if (days != null && days.size() > 0) {
                        for (int i = 0; i < days.size(); i++) {
                            DBCollectionCountOptions options= new DBCollectionCountOptions();
                            options.hintString(BEST_INDEX);
                             long result = mongoTemplate.countWithHint(query, null,table + "_" + days.get(i),options);
                        //    long result = mongoTemplate.count(query, table + "_" + days.get(i));
                            total += result;
                        }

                    }

                }

            }

            return (int) total;

        }
        return 0;

    }
}

package com.paic.wiseapm.alert.util;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class TimeUtil {

    public static final long ONE_DAY = 24 * 3600 * 1000L;

    public static String getDay(long time) {
        // TODO Auto-generated method stub

        if (time < 2559699611L) {// input value is millisecond
            time = time * 1000L;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date date = new Date();
        date.setTime(time);
        return sdf.format(date);
    }

    // public static void main(String[] args) {
    //
    // List<String> days = getDays(1560135951, 1560654351);

    // System.out.println(days);
    // System.out.println(days.size());
    //
    // }

    public static List<String> getDays(long start, long end) {
        // TODO Auto-generated method stub
        List<String> days = new ArrayList<String>();
        if (start < 2559699611L) {// input value is millisecond
            start = start * 1000L;
        }
        if (end < 2559699611L) {// input value is millisecond
            end = end * 1000L;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Date date = new Date();
        for (long time = start; time < end; time = time + TimeUtil.ONE_DAY) {
            date.setTime(time);
            String day = sdf.format(date);
            days.add(day);
        }
        String endDay = getDay(end);
        if (days != null && days.size() > 0) {
            if (!days.get(days.size() - 1).equalsIgnoreCase(endDay)) {
                days.add(endDay);
            }
        }

        return days;
    }
    
    public static String getTimeFromMongoId(String mongoId){
        long time = new Date(Long.parseLong(Integer.parseInt(mongoId.substring(0, 8), 16) + "000")).getTime();

        String day = TimeUtil.getDay(time);
        return day;

    }
    
    public static Boolean getSubmeterStandardBysTime(Long sTime) {
        // 走歷史判斷依據 startTime>6月11號才走分表邏輯,其他的不走分表邏輯
        Long historyTime = 1560182400000L;// 2019年6月11號 00:00:00 時間戳
        Boolean flag = false;
        if (sTime < 2559699611L) {
            // input value is second
            sTime = sTime * 1000L;
        }
        if (sTime > historyTime) {
            flag = true;
        }
        return flag;
    }

}