import org.mongojack.DBCursor; //导入依赖的package包/类
@GET
@Path("/list")
public List<Log> fetch(@PathParam("collection") String collection) {

    final DBCursor<Log> cursor = entries.find();
    final List<Log> l = new ArrayList<Log>();

    try {
        while (cursor.hasNext()) {
            l.add(cursor.next());
        }
    } finally {
        cursor.close();
    }

    return l;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@GET
@Path("/latest")
public List<Log> fetchLatest(@PathParam("collection") String collection) {

    final DBCursor<Log> cursor = entries.find().sort(new BasicDBObject("timestamp", -1)).limit(100);
    final List<Log> l = new ArrayList<Log>();

    try {
        while (cursor.hasNext()) {
            l.add(cursor.next());
        }
    } finally {
        cursor.close();
    }

    return l;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@GET
public List<MongoDocument> fetch(@PathParam("collection") String collection) {
    final JacksonDBCollection<MongoDocument, String> coll = JacksonDBCollection.wrap(mongoDB.getCollection(collection), MongoDocument.class,
            String.class);
    final DBCursor<MongoDocument> cursor = coll.find();
    final List<MongoDocument> l = new ArrayList<>();

    try {
        while(cursor.hasNext()) {
            l.add(cursor.next());
        }
    }finally {
        cursor.close();
    }

    return l;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@POST
@Path("/register/check/username")
public Response checkUsername(CheckNameDTO nameDTO) {
    Preconditions.checkNotNull(nameDTO);

    if(CharMatcher.WHITESPACE.matchesAnyOf(nameDTO.getName())) {
        return Response.status(Response.Status.FORBIDDEN).entity("{\"space\":\"true\"}").build();
    }

    //If these doesn't match, then the username is unsafe
    if (!nameDTO.getName().equals(HtmlEscapers.htmlEscaper().escape(nameDTO.getName()))) {
        log.warn("Unsafe username " + nameDTO.getName());
        return Response.status(Response.Status.FORBIDDEN).entity("{\"invalidChars\":\"true\"}").build();
    }

    @Cleanup DBCursor<Player> dbPlayer = playerCollection.find(
            DBQuery.is("username", nameDTO.getName().trim()), new BasicDBObject());

    if (dbPlayer.hasNext()) {
        return Response.status(Response.Status.FORBIDDEN).entity("{\"isTaken\":\"true\"}").build();
    }

    return Response.ok().build();
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public Optional<Player> authenticate(BasicCredentials credentials) {
    @Cleanup DBCursor<Player> dbPlayer = playerCollection.find(
            DBQuery.is("username", credentials.getUsername()), new BasicDBObject());

    if (dbPlayer == null || !dbPlayer.hasNext()) {
        return Optional.empty();
    }

    Player player = dbPlayer.next();

    CivSingleton.instance().playerCache().put(player.getId(), player.getUsername());

    if (player.getPassword().equals(DigestUtils.sha1Hex(credentials.getPassword()))) {
        return Optional.of(player);
    }
    return Optional.empty();
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Test
public void createPlayer() throws JsonProcessingException {
    @Cleanup DBCursor<Player> foobar = getApp().playerCollection.find(DBQuery.is("username", "foobar"));
    if (foobar.hasNext()) {
        getApp().playerCollection.removeById(foobar.next().getId());
    }

    Form form = new Form();
    form.param("username", "foobar");
    form.param("password", "foobar");
    form.param("email", "[email protected]");

    URI uri = UriBuilder.fromPath(BASE_URL + "/auth/register").build();
    Response response = client().target(uri)
            .request()
            .post(Entity.form(form));

    assertThat(response.getStatus()).isEqualTo(HttpStatus.CREATED_201);
    assertThat(response.getLocation().getPath()).contains(uri.getPath());
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
/**
 * Returns a {@link com.eeb.dropwizardmongo.cms.api.BasicPage} using the slug as a query parameter.
 * @param slug
 * @return {@code BasicPage} object or a 403 if the object can not be found.
 */
@GET
@Produces(MediaType.TEXT_HTML)
@Consumes(MediaType.APPLICATION_JSON)
public BasicPageView get(@PathParam("slug") String slug) {

    JacksonDBCollection<BasicPage,String> col = JacksonDBCollection.wrap(mongoDb.getCollection("assets"),
            BasicPage.class, String.class);

    //Note: MongoJack does not support the AutoClose interface
    DBCursor<BasicPage> cursor = col.find(new BasicDBObject("metadata.slug",slug));
    try  {

        if(!cursor.hasNext()) {
            Response.ResponseBuilder response = Response.status(Response.Status.FORBIDDEN);
            response.entity("{\"message\":\"Object not found\"}");
            throw new WebApplicationException(response.build());
        } else {
            return new BasicPageView(cursor.next());
        }

    } finally {
       cursor.close();
     }

}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
protected void prefillCache() {
    if (LocalCache.PVE_ENABLED) {
        final DBCursor<PveEvent> pveevents = db.findPveEvents();
        pveevents.batchSize(5000);
        for (final PveEvent pveevent : pveevents) {
            pveEventCache.put(pveevent.hashCode(), pveevent);
            esper.sendEvent(pveevent);
        }
        pveevents.close();
    }

    if (LocalCache.WVW_ENABLED) {
        final DBCursor<WvwEvent> wvwevents = db.findWvwEvents();
        wvwevents.batchSize(5000);
        for (final WvwEvent wvwevent : wvwevents) {
            wvwEventCache.put(wvwevent.hashCode(), wvwevent);
            esper.sendEvent(wvwevent);
        }
        wvwevents.close();
    }

}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public Collection<RuleDao> loadAll() {
    try {
        final DBCursor<RuleDao> ruleDaos = dbCollection.find().sort(DBSort.asc("title"));
        return ruleDaos.toArray();
    } catch (MongoException e) {
        log.error("Unable to load processing rules", e);
        return Collections.emptySet();
    }
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public Collection<RuleDao> loadNamed(Collection<String> ruleNames) {
    try {
        final DBCursor<RuleDao> ruleDaos = dbCollection.find(DBQuery.in("title", ruleNames));
        return Sets.newHashSet(ruleDaos.iterator());
    } catch (MongoException e) {
        log.error("Unable to bulk load rules", e);
        return Collections.emptySet();
    }
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public Set<PipelineConnections> loadAll() {
    try {
        final DBCursor<PipelineConnections> connections = dbCollection.find();
        return Sets.newHashSet(connections.iterator());
    } catch (MongoException e) {
        log.error("Unable to load pipeline connections", e);
        return Collections.emptySet();
    }
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public Collection<PipelineDao> loadAll() {
    try {
        final DBCursor<PipelineDao> daos = dbCollection.find();
        return Sets.newHashSet(daos.iterator());
    } catch (MongoException e) {
        log.error("Unable to load pipelines", e);
        return Collections.emptySet();
    }
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
public List<CollectorConfiguration> findByTags(List tags) {
    final DBCursor<CollectorConfiguration> cursor = dbCollection.find().in("tags", tags);
    final List<CollectorConfiguration> result = new ArrayList<>();
    while (cursor.hasNext()) {
        result.add(cursor.next());
    }
    return result;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
public List<String> loadAllTags() {
    List<String> tags = new ArrayList<>();
    DBCursor cursor = dbCollection.find();
    while (cursor.hasNext()) {
        CollectorConfiguration collectorConfiguration = (CollectorConfiguration) cursor.next();
        List<String> newTags = collectorConfiguration.tags().stream()
                .filter(t -> !tags.contains(t))
                .collect(Collectors.toList());
        tags.addAll(newTags);
    }
    return tags;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
private void where(String fieldName, BiFunction<String, Object, DBCursor<OrderItemToBePreparedViewModel>> function, Object objectToBeUsedForFiltering) {
    if (objectToBeUsedForFiltering == null) {
        return;
    }

    function.apply(fieldName, objectToBeUsedForFiltering);
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Test
public void printAllPBFGames() throws IOException {
    @Cleanup DBCursor<PBF> cursor = getApp().pbfCollection.find();
    while (cursor.hasNext()) {
        PBF pbf = cursor.next();
        assertNotNull(pbf);
        System.out.println(pbf.toString());
    }
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
@Override
public List<Comment> findByPage(Page page) {
	final DBCursor<Comment> cursor = getDbCollection().find(DBQuery.is("pageRef", 
			new DBRef<Page, String>(page.getId(), Page.class)));
	addSortCriteria(cursor, getDefaultSortCriteria());
	return toList(cursor);
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
/**
 * Returns a {@link List} containing the objects returned in a {@link DBCursor}.
 * @param cursor a {@link DBCursor}.
 * @return a {@link List}.
 */
protected List<T> toList(DBCursor<T> cursor) {
	List<T> list = new ArrayList<T>();
	for (T object : cursor) {
		list.add(object);
	}
	return list;
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
/**
 * Adds sort criteria to a {@link DBCursor}.
 * @param cursor a {@link DBCursor}.
 * @param sortingCriteria an array of {@link SortCriterion}.
 */
protected void addSortCriteria(final DBCursor<T> cursor, SortCriterion... sortingCriteria) {
	if (sortingCriteria != null && sortingCriteria.length > 0) {
		BasicDBObject orderBy = new BasicDBObject();
		for (SortCriterion sortCriterion : sortingCriteria) {
			orderBy.append(sortCriterion.getProperty(), sortCriterion.isAscending() ? 1 : -1);
		}
		cursor.sort(orderBy);
	}
}
 

import org.mongojack.DBCursor; //导入依赖的package包/类
public List<CollectorConfiguration> loadAll() {
    final DBCursor<CollectorConfiguration> cursor = dbCollection.find();
    final List<CollectorConfiguration> collectorConfigurationList = new ArrayList<>();
    Iterables.addAll(collectorConfigurationList, cursor);
    return collectorConfigurationList;
}