import org.jongo.MongoCursor; //导入依赖的package包/类
public List<Document> removedItems(String collection, long fromSequence, long newSequence) {
    List<Document> documentList = new ArrayList<>();
    MongoCollection userCollection = jongo.getCollection(collection);

    MongoCursor<NitriteDocument> removeLogs = userCollection
        .find("{" +
            " $and: [" +
            " {" + DELETED + ": { $eq: true }}," +
            " {" + DELETE_TIME + ": { $gte: # }}," +
            " {" + DELETE_TIME + ": { $lte: # }}" +
            " ]}", fromSequence, newSequence)
        .as(NitriteDocument.class);

    if (removeLogs != null) {
        for (NitriteDocument logEntry : removeLogs) {
            Document document = new Document(logEntry.getDocument());
            document.remove(DOC_SOURCE);
            documentList.add(document);
        }
    }

    return documentList;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public List<Document> modifiedItems(String collection, long fromSequence, long newSequence) {
    MongoCollection userCollection = jongo.getCollection(collection);
    MongoCursor<NitriteDocument> documents = userCollection
        .find("{" +
            " $and: [" +
            " {" + DELETED + ": { $eq: false }}," +
            " {" + SYNC_TIME + ": { $gte: # }}," +
            " {" + SYNC_TIME + ": { $lte: # }}" +
            " ]}", fromSequence, newSequence)
        .as(NitriteDocument.class);

    List<Document> result = new ArrayList<>();
    for (NitriteDocument nitriteDocument : documents) {
        Document doc = new Document(nitriteDocument.getDocument());
        doc.remove(DOC_SOURCE);
        result.add(doc);
    }

    return result;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public static Optional<List<ModerationLog>> getModerationLogs(CurseGUID channelId) {
    try {
        List<ModerationLog> commandRet = new ArrayList<>();
        MongoCursor<ModerationLog> commands = jongo.getCollection(MONGO_MODERATION_LOGGING_COLLECTION).find("{channelID: '" + channelId.serialize() + "'}")
                .as(ModerationLog.class);
        while (commands.hasNext()) {
            commandRet.add(commands.next());
        }
        commands.close();
        return Optional.of(commandRet);
    } catch (IOException | NullPointerException e) {
        log.error("error getting moderation data", e);
        return Optional.empty();
    }

}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public static Optional<List<ModerationLog>> getMessageLog(CurseGUID channelId, Date eventTime) {
    try {
        List<ModerationLog> commandRet = new ArrayList<>();
        MongoCursor<ModerationLog> commands = jongo.getCollection(MONGO_MODERATION_LOGGING_COLLECTION)
                .find("{channelID: '" + channelId.serialize() + "' , messageTime: 'ISODate(" + eventTime.toString() + ")'}")
                .as(ModerationLog.class);
        while (commands.hasNext()) {
            commandRet.add(commands.next());
        }
        commands.close();
        return Optional.of(commandRet);
    } catch (IOException | NullPointerException e) {
        log.error("error getting moderation data", e);
        return Optional.empty();
    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public static Optional<List<MongoCurseforgeCheck>> getCurseChecksForAuthor(@Nonnull String author) {
    try {
        List<MongoCurseforgeCheck> commandRet = new ArrayList<>();
        MongoCursor<MongoCurseforgeCheck> commands = jongo.getCollection(MONGO_COMMANDS_COLLECTION).find("{author: '" + author + "'}")
                .as(MongoCurseforgeCheck.class);
        while (commands.hasNext()) {
            commandRet.add(commands.next());
        }
        commands.close();
        return Optional.of(commandRet);
    } catch (IOException | NullPointerException e) {
        log.error("error getting checks", e);
        return Optional.empty();
    }

}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
@Nonnull
//TODO should this use streams?
public static Optional<List<MongoCommand>> getCommandsForServer(CurseGUID serverID) {
    try {
        List<MongoCommand> commandRet = new ArrayList<>();
        MongoCursor<MongoCommand> commands = jongo.getCollection(MONGO_COMMANDS_COLLECTION).find("{serverID: '" + serverID.serialize() + "'}")
                .as(MongoCommand.class);
        while (commands.hasNext()) {
            commandRet.add(commands.next());
        }
        commands.close();
        return Optional.of(commandRet);
    } catch (IOException | NullPointerException e) {
        log.error("error getting commands for server", e);
        return Optional.empty();
    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
@Override
public void send() {
    Map<String, T> jobs = getJobs();
    MongoCollection collection = mongoDBService.getCollection(Constants.DB.TO_SEND);
    for (Map.Entry<String, T> entry : jobs.entrySet()) {
        String toSendQuery = "{jobId:'" + entry.getKey() + "'}";
        try {
            MongoCursor<ToSend> messageCursor = collection.find(toSendQuery).as(ToSend.class);
            for (ToSend message : messageCursor) {
                send(entry.getValue(), message);
            }
            collection.remove(toSendQuery);
            messageCursor.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
/**
 * @return active configs set for selected plugin
 */
protected Set<T> getPluginConfigs() {
    HashSet<T> configsByType = Sets.newHashSet();
    MongoCollection collection = mongoDBService.getCollection(getConfigTableName());
    try {
        MongoCursor<? extends ConfigDTO> mongoCursor = collection.find("{type:'" + configTemplate.getType() + "'}")
                .as(configTemplate.getClass());

        for (ConfigDTO configDTO : mongoCursor) {
            configsByType.add((T) configDTO);
        }
        mongoCursor.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return configsByType;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
@Override
public void process() {
    MongoCollection builds = mongoDBService.getCollection(Constants.DB.BUILDS);
    for (Map.Entry<String, WatchdogProcessorConfigDTO> entry : getJobs().entrySet()) {
        long boundTime = System.currentTimeMillis() - Integer.parseInt(entry.getValue().getTimeout()) * 60000;
        String queryToSend = String.format("{jobId:'%s', processed:'false', startTime:{$lt: '%s'}, status: '%s'}",
                entry.getKey(), boundTime, CiReport.Status.IN_PROGRESS);
        try {
            MongoCursor<CiReport> ciReports = builds.find(queryToSend).as(CiReport.class);
            if (ciReports.count() > 0) {
                putMessage(entry.getKey(), SUBJECT, BODY);
            }
            markReportsAsProcessed(builds, ciReports);
            ciReports.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public List<Document> findAll(String collection, FindOptions findOptions) {
    MongoCollection mongoCollection = jongo.getCollection(collection);
    MongoCursor<NitriteDocument> documents = mongoCollection
        .find("{" + DELETED + ": { $eq: false }}")
        .skip(findOptions.getOffset())
        .limit(findOptions.getSize())
        .as(NitriteDocument.class);

    return StreamSupport.stream(documents.spliterator(), false)
        .map(NitriteDocument::getDocument)
        .collect(Collectors.toList());
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public long getDocumentCount() {
    long sum = 0;
    Set<String> collectionNames = new HashSet<>();
    MongoCursor<Attributes> cursor = jongo.getCollection(ATTRIBUTE_REPO).find().as(Attributes.class);
    for (Attributes attributes : cursor) {
        collectionNames.add(attributes.getCollection());
    }

    for (String name : collectionNames) {
        sum = sum + jongo.getCollection(name).count();
    }
    return sum;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public List<UserAccount> findUsersByAuthorities(String... authorities) {
    MongoCursor<UserAccount> userAccounts = userRepository.find("{authorities: { $in: [#]}}",
        String.join(",", authorities))
        .as(UserAccount.class);
    return StreamSupport
        .stream(userAccounts.spliterator(), false)
        .collect(Collectors.toList());
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
/**
 * Takes a MongoCurson containing User object and moving them to an ArrayList.
 *
 * @param cursor    MongoCursor to be conveted to an ArrayList
 * @return          An ArrayList containing all user object from the cursor
 */
private ArrayList<User> cursorToArray(MongoCursor<User> cursor) {
    ArrayList<User> list = new ArrayList<>();

    while(cursor.hasNext()) {
        list.add(cursor.next());
    }

    return list;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
/**
 * Takes a MongoCursor containing Event objects and moves them to an ArrayList.
 *
 * @param cursor    MongoCursor to be converted to an ArrayList.
 * @return          An ArrayList containing all Event objects from the cursor.
 * @author Axel Nilsson (axnion)
 */
private static List<Event> cursorToArray(MongoCursor<Event> cursor) {
    List<Event> list = new ArrayList<>();

    while(cursor.hasNext()) {
        list.add(cursor.next());
    }

    return list;
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public static Optional<List<MongoCurseforgeCheck>> getCurseChecks() {
    try {
        List<MongoCurseforgeCheck> commandRet = new ArrayList<>();
        MongoCursor<MongoCurseforgeCheck> commands = jongo.getCollection(MONGO_CURSECHECKS_COLLECTION).find()
                .as(MongoCurseforgeCheck.class);
        while (commands.hasNext()) {
            commandRet.add(commands.next());
        }
        commands.close();
        return Optional.of(commandRet);
    } catch (IOException | NullPointerException e) {
        log.error("error getting checks", e);
        return Optional.empty();
    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
@Override
public List<WinlistItem> loadWinlist(GameModeId mode) {
    long timestamp = System.currentTimeMillis() - MONTH;

    MongoCursor<WinlistItem> as =
        collection.find("{mode:#, timestamp:{$gte:#}}", mode, timestamp)
            .sort("{score:-1}")
            .limit(20)
            .as(WinlistItem.class);

    return stream(as.spliterator(), false).collect(toList());
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
@Override
public void process() {
    Map<String, StatusChangedProcessorConfigDTO> jobs = getJobs();

    MongoCollection collection = mongoDBService.getCollection(Constants.DB.BUILDS);
    for (Map.Entry<String, StatusChangedProcessorConfigDTO> entry : jobs.entrySet()) {
        String toSendQuery = "{jobId:'" + entry.getKey() + "', processed:'false'}";
        try {
            MongoCursor<CiReport> ciReports = collection.find(toSendQuery).as(CiReport.class);
            int count = ciReports.count();
            CiReport firstReport = null;
            for (int i = 0; i < count - 1; i++) {
                CiReport report = ciReports.next();
                if (firstReport == null) {
                    firstReport = report;
                }
                report.setProcessed(true);
                collection.update("{id:'" + report.getId() + "'}", report);
            }
            if (ciReports.hasNext()) {
                CiReport lastReport = ciReports.next();
                CiReport.Status firstStatus = firstReport.getStatus();
                generateMessage(entry.getKey(), entry.getValue(), firstStatus, lastReport);

            }
            ciReports.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
private void markReportsAsProcessed(MongoCollection builds, MongoCursor<CiReport> ciReports) {
    while (ciReports.hasNext()) {
        CiReport report = ciReports.next();
        report.setProcessed(true);
        builds.update(String.format("{id:'%s'}", report.getId()), report);
    }
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
public MongoCursor<T> listByUserID(String userid) {
    return db.getColletion(getCollectionName()).find("{userID: '" + userid + "'").as(clazz);
}
 

import org.jongo.MongoCursor; //导入依赖的package包/类
protected MongoCursor<T> findByUserID(String userid) {
    return db.getColletion(getCollectionName()).find("{userID: '" + userid + "'").as(clazz);
}