Java Updates类代码示例

import com.mongodb.client.model.Updates; //导入依赖的package包/类
public O2MSyncDataLoader getPendingDataLoader() {
	O2MSyncDataLoader loader = null;
	Document document = syncEventDoc.findOneAndUpdate(
			Filters.and(Filters.eq(SyncAttrs.STATUS, SyncStatus.PENDING),
					Filters.eq(SyncAttrs.EVENT_TYPE, String.valueOf(EventType.System))),
			Updates.set(SyncAttrs.STATUS, SyncStatus.IN_PROGRESS),
			new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
					.projection(Projections.include(SyncAttrs.SOURCE_DB_NAME, SyncAttrs.SOURCE_USER_NAME)));
	if (document != null && !document.isEmpty()) {
		Object interval = document.get(SyncAttrs.INTERVAL);
		String appName = document.getString(SyncAttrs.APPLICATION_NAME);
		if(interval!=null && interval instanceof Long){
			loader = new O2MSyncDataLoader((Long)interval, appName);
		}else{
			loader = new O2MSyncDataLoader(120000, appName);
		}
		loader.setEventId(document.getObjectId(SyncAttrs.ID));
		loader.setDbName(document.getString(SyncAttrs.SOURCE_DB_NAME));
		loader.setDbUserName(document.getString(SyncAttrs.SOURCE_USER_NAME));
		loader.setStatus(document.getString(SyncAttrs.STATUS));
	}
	return loader;
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
public SyncEvent retryEvent(ObjectId eventId, boolean retryFailed, boolean retryEntire, boolean dropCollection) {
	Document updateQuery = new Document();
	updateQuery.append("$set", new Document(SyncAttrs.STATUS, SyncStatus.PENDING).append(SyncAttrs.IS_RETRY, true))
			.append("$unset", new Document(SyncAttrs.ERRORS, true).append(SyncAttrs.MARKER, true));
	if (retryFailed) {
		syncEvents.updateMany(
				Filters.and(Filters.eq(SyncAttrs.PARENT_EVENT_ID, eventId),
						Filters.eq(SyncAttrs.STATUS, SyncStatus.FAILED), Filters.ne(SyncAttrs.ID, eventId)),
				updateQuery);
		syncEvents.updateOne(Filters.eq(SyncAttrs.ID, eventId),
				Updates.set(SyncAttrs.STATUS, SyncStatus.IN_PROGRESS));
	} else {
		if (retryEntire) {
			syncEvents.updateMany(Filters.eq(SyncAttrs.PARENT_EVENT_ID, eventId),
					Updates.set(SyncAttrs.STATUS, SyncStatus.CANCELLED));
			syncEvents.updateOne(Filters.eq(SyncAttrs.ID, eventId), updateQuery);
		}
	}
	return getEvent(eventId);
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@ExtDirectMethod(ExtDirectMethodType.FORM_POST)
public ExtDirectFormPostResult resetRequest(
		@RequestParam("email") String emailOrLoginName) {

	String token = UUID.randomUUID().toString();

	User user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
			Filters.and(
					Filters.or(Filters.eq(CUser.email, emailOrLoginName),
							Filters.eq(CUser.loginName, emailOrLoginName)),
					Filters.eq(CUser.deleted, false)),
			Updates.combine(
					Updates.set(CUser.passwordResetTokenValidUntil,
							Date.from(ZonedDateTime.now(ZoneOffset.UTC).plusHours(4)
									.toInstant())),
					Updates.set(CUser.passwordResetToken, token)),
			new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
					.upsert(false));

	if (user != null) {
		this.mailService.sendPasswortResetEmail(user);
	}

	return new ExtDirectFormPostResult();
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
/**
 * update a person documents in mongo server
 * <p>
 * using db {@link Params#TEST_MONGO} and collection {@link Params#PERSON}
 * </p>
 *
 * @param mongoIP       the ip of the mongo server
 * @param mongoPort     the port of the mongo server
 * @param mongoHttpPort the port for the rest api of the mongo server
 * @param oldName       the old name of the person to update
 * @param newName       the new name of the person to update
 */
public static void update1Person(String mongoIP, int mongoPort, int mongoHttpPort, int oldName, int newName) {

    MongoClient mongoClient = new MongoClient(mongoIP, mongoPort);
    MongoDatabase database = mongoClient.getDatabase(Params.TEST_MONGO);
    MongoCollection<Document> collection = database.getCollection(Params.PERSON);
    collection.updateOne(Filters.eq(Params.NAME, oldName), Updates
        .set(Params.NAME, newName));
    mongoClient.close();
    // verify
    // http://10.10.10.3:28017/testmongo/person/?filter_name=sadf
    String base_uri = Params.HTTP + mongoIP;

    // content type is not that precise from mongo-http interface
    RestAssured.registerParser(Params.MIME_TYPE_TEXT_PLAIN, Parser.JSON);
    RestAssured.given().log().path().contentType(ContentType.JSON).baseUri(base_uri).port(mongoHttpPort)
        .queryParam(Params.FILTER + Params.UNDERLINE + Params.NAME, newName)
        .get(Params.TEST_MONGO_PERSON_PATH).then().assertThat().statusCode(HttpStatus.SC_OK).
        //contentType(ContentType.JSON).
            body("total_rows", Matchers.equalTo(1));
    RestAssured.unregisterParser("text/plain");
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@ExtDirectMethod
public UserDetailDto getAuthUser(
		@AuthenticationPrincipal MongoUserDetails userDetails) {

	if (userDetails != null) {
		User user = userDetails.getUser(this.mongoDb);
		UserDetailDto userDetailDto = new UserDetailDto(userDetails, user, null);

		if (!userDetails.isPreAuth()) {
			this.mongoDb.getCollection(User.class).updateOne(
					Filters.eq(CUser.id, userDetails.getUserDbId()),
					Updates.set(CUser.lastAccess, new Date()));
		}

		return userDetailDto;
	}

	return null;
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@Test
public void testUnkownIgnore() {
	MongoDatabase db = connect();

	UnknownIgnorePojo pojo = new UnknownIgnorePojo();
	pojo.setName("ralph");

	MongoCollection<UnknownIgnorePojo> coll = db.getCollection(COLL_NAME,
			UnknownIgnorePojo.class);
	coll.insertOne(pojo);

	db.getCollection(COLL_NAME).updateOne(Filters.eq("_id", pojo.getId()),
			Updates.set("newField", "new"));

	UnknownIgnorePojo readPojo = coll.find().first();
	assertThat(readPojo).isEqualToComparingFieldByField(pojo);

	Document doc = db.getCollection(COLL_NAME).find().first();
	assertThat(doc).hasSize(3);
	assertThat(doc.get("_id")).isEqualTo(pojo.getId());
	assertThat(doc.get("name")).isEqualTo("ralph");
	assertThat(doc.get("newField")).isEqualTo("new");
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
public static <TItem> Bson optionalSet(final String fieldName, final TItem value) {
    if (value == null) {
        return null;
    } else {
        return Updates.set(fieldName, value);
    }
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
public SyncEvent getPendingEvent(List<String> eventTypes) {
	return syncEvents.findOneAndUpdate(
			Filters.and(Filters.eq(SyncAttrs.STATUS, SyncStatus.PENDING),
					Filters.in(SyncAttrs.EVENT_TYPE, eventTypes)),
			Updates.set(SyncAttrs.STATUS, SyncStatus.IN_PROGRESS),
			new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
public SyncNode getFailedNode(long lastPingTime) {
	SyncNode failedNode = syncNodeMapping.findOneAndUpdate(
			Filters.and(Filters.lte(SyncAttrs.LAST_PING_TIME, lastPingTime),
					Filters.eq(SyncAttrs.LIFE_CYCLE, SyncConfig.INSTANCE.getDbProperty(SyncConstants.LIFE))),
			Updates.set(SyncAttrs.LAST_PING_TIME, System.currentTimeMillis()),
			new FindOneAndUpdateOptions().upsert(false).returnDocument(ReturnDocument.BEFORE));
	if (failedNode != null && failedNode.getFailureTime() == 0) {
		syncNodeMapping.findOneAndUpdate(Filters.eq(SyncAttrs.ID, failedNode.getId()),
				Updates.set(SyncAttrs.FAILURE_TIME, failedNode.getLastPingTime()));
	}
	return failedNode;
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
private void processEventLogFlow() throws InterruptedException {
	FindIterable<O2MSyncEventLog> it = getCursor();
	retryCount = 0;
	it.forEach(new Block<O2MSyncEventLog>() {
		@Override
		public void apply(O2MSyncEventLog eventLog) {
			try {
				if (marker.isFailed()) {
					releaseReources();
					return;
				}
				logCollection.findOneAndUpdate(Filters.eq(SyncAttrs.ID, eventLog.getLogId()),
						Updates.set(O2MSyncEventLogCodec.STATUS, O2MSyncEventLogCodec.RUNNING));
				logger.info("Processing filter : "+eventLog.getEventFilters());
				if (eventLog.getOperation().equals(SyncConstants.DELETE)) {
					processDeletedDoc(eventLog);
				}else{
					processMongoObject(map.getMapObject(), true, null, map.getMapObject().getCollectionName(),
							eventLog);	
				}					
				logCollection.findOneAndUpdate(Filters.eq(SyncAttrs.ID, eventLog.getLogId()),
						Updates.set(O2MSyncEventLogCodec.STATUS, O2MSyncEventLogCodec.COMPLETE));
				logger.info("Processed filter : "+eventLog.getEventFilters());
			} catch (SyncError e) {
				logger.error("Error in O2M replication", e);
				Mailer.sendmail(eventId, null, e, Mailer.FAILURE);
			}
		}
	});
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@Override
public boolean putIfAbsent(String key, V value) {
  try {
    Bson query = Filters.eq(DrillMongoConstants.ID, key);
    Bson update = Updates.set(pKey, bytes(value));
    UpdateResult updateResult = collection.updateOne(query, update, new UpdateOptions().upsert(true));
    return updateResult.getModifiedCount() == 1;
  } catch (Exception e) {
    logger.error(e.getMessage(), e);
    throw new DrillRuntimeException(e.getMessage(), e);
  }
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@Test
void update() {
    List<TestMongoEntity> entities = testEntities();
    collection.bulkInsert(entities);

    long updatedCount = collection.update(Filters.eq("string_field", entities.get(0).stringField), Updates.set("enum_field", TestMongoEntity.TestEnum.VALUE2));
    assertThat(updatedCount).isEqualTo(1);
    assertThat(collection.get(entities.get(0).id)).get().satisfies(loadedEntity -> assertThat(loadedEntity.enumField).isEqualTo(TestMongoEntity.TestEnum.VALUE2));
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@Scheduled(cron = "0 0 5 * * *")
public void doCleanup() {
	// Inactivate users that have a lastAccess timestamp that is older than one year
	ZonedDateTime oneYearAgo = ZonedDateTime.now(ZoneOffset.UTC).minusYears(1);
	this.mongoDb.getCollection(User.class).updateMany(
			Filters.lte(CUser.lastAccess, Date.from(oneYearAgo.toInstant())),
			Updates.set(CUser.enabled, false));
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@ExtDirectMethod
public String enable2f(@AuthenticationPrincipal MongoUserDetails userDetails) {
	String randomSecret = TotpAuthUtil.randomSecret();

	this.mongoDb.getCollection(User.class).updateOne(
			Filters.eq(CUser.id, userDetails.getUserDbId()),
			Updates.set(CUser.secret, randomSecret));

	return randomSecret;
}
 

import com.mongodb.client.model.Updates; //导入依赖的package包/类
@ExtDirectMethod(STORE_MODIFY)
public ValidationMessagesResult<User> update(User updatedEntity, Locale locale) {
	List<ValidationMessages> violations = validateEntity(updatedEntity, locale);
	violations.addAll(checkIfLastAdmin(updatedEntity, locale));

	if (violations.isEmpty()) {

		List<Bson> updates = new ArrayList<>();
		updates.add(Updates.set(CUser.loginName, updatedEntity.getLoginName()));
		updates.add(Updates.set(CUser.email, updatedEntity.getEmail()));
		updates.add(Updates.set(CUser.firstName, updatedEntity.getFirstName()));
		updates.add(Updates.set(CUser.lastName, updatedEntity.getLastName()));
		updates.add(Updates.set(CUser.locale, updatedEntity.getLocale()));
		updates.add(Updates.set(CUser.enabled, updatedEntity.isEnabled()));
		if (updatedEntity.getAuthorities() != null
				&& !updatedEntity.getAuthorities().isEmpty()) {
			updates.add(
					Updates.set(CUser.authorities, updatedEntity.getAuthorities()));
		}
		else {
			updates.add(Updates.unset(CUser.authorities));
		}
		updates.add(Updates.setOnInsert(CUser.deleted, false));

		this.mongoDb.getCollection(User.class).updateOne(
				Filters.eq(CUser.id, updatedEntity.getId()), Updates.combine(updates),
				new UpdateOptions().upsert(true));

		if (!updatedEntity.isEnabled()) {
			deletePersistentLogins(updatedEntity.getId());
		}

		return new ValidationMessagesResult<>(updatedEntity);
	}

	ValidationMessagesResult<User> result = new ValidationMessagesResult<>(
			updatedEntity);
	result.setValidations(violations);
	return result;
}