Java 类com.mongodb.client.model.ReturnDocument 实例源码

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;
}

@Override
public Dataset write(Dataset dataset) {
  // we populate this on first write and retain it thereafter
  if (isBlank(dataset.getId())) {
    dataset.setId(ObjectId.get().toString());
  }

  Observable<Document> observable =
      getCollection()
          .findOneAndReplace(
              Filters.eq("id", dataset.getId()),
              documentTransformer.transform(dataset),
              new FindOneAndReplaceOptions().upsert(true).returnDocument(ReturnDocument.AFTER));

  return documentTransformer.transform(Dataset.class, observable.toBlocking().single());
}

@Override
public Optional<T> peek() {
    final Bson peekQuery = QueryUtil.generatePeekQuery(defaultHeartbeatExpirationMillis);

    final Document update = new Document();
    update.put("heartbeat", new Date());
    update.put("status", OkraStatus.PROCESSING.name());

    final FindOneAndUpdateOptions options = new FindOneAndUpdateOptions();
    options.returnDocument(ReturnDocument.AFTER);

    final Document document = client
            .getDatabase(getDatabase())
            .getCollection(getCollection())
            .findOneAndUpdate(peekQuery, new Document("$set", update), options);

    if (document == null) {
        return Optional.empty();
    }

    return Optional.ofNullable(serializer.fromDocument(scheduleItemClass, document));
}

@Test
public void updatePojoTest() {

    Bson update = combine(set("user", "Jim"),
            set("action", Action.DELETE),
            // unfortunately at this point we need to provide a non generic class, so the codec is able to determine all types
            // remember: type erasure makes it impossible to retrieve type argument values at runtime
            // @todo provide a mechanism to generate non-generic class on the fly. Is that even possible ?
            // set("listOfPolymorphicTypes", buildNonGenericClassOnTheFly(Arrays.asList(new A(123), new B(456f)), List.class, Type.class),
            set("listOfPolymorphicTypes", new PolymorphicTypeList(Arrays.asList(new A(123), new B(456f)))),
            currentDate("creationDate"),
            currentTimestamp("_id"));

    FindOneAndUpdateOptions findOptions = new FindOneAndUpdateOptions();
    findOptions.upsert(true);
    findOptions.returnDocument(ReturnDocument.AFTER);

    MongoCollection<Pojo> pojoMongoCollection = mongoClient.getDatabase("test").getCollection("documents").withDocumentClass(Pojo.class);

    Pojo pojo = pojoMongoCollection.findOneAndUpdate(Filters.and(Filters.lt(DBCollection.ID_FIELD_NAME, 0),
            Filters.gt(DBCollection.ID_FIELD_NAME, 0)), update, findOptions);

    assertNotNull(pojo.id);
}

private SmofInsertResult replace(T element, SmofOpOptions options) {
    final SmofInsertResult result = new SmofInsertResultImpl();
    result.setSuccess(true);
    options.upsert(true);
    if(options.isBypassCache() || !cache.asMap().containsValue(element)) {
        final BsonDocument document = parser.toBson(element);
        final Bson query = createUniquenessQuery(document);
        result.setPostInserts(BsonUtils.extrackPosInsertions(document));
        options.setReturnDocument(ReturnDocument.AFTER);
        document.remove(Element.ID);
        final BsonDocument resDoc = collection.findOneAndReplace(query, document, options.toFindOneAndReplace());
        element.setId(resDoc.get(Element.ID).asObjectId().getValue());
        cache.put(element.getId(), element);
    }
    return result;
}

@Override
public Long getNextIdGen(Long interval) {
    Document realUpdate = getIncUpdateObject(getUpdateObject(interval));
    FindOneAndUpdateOptions options = new FindOneAndUpdateOptions()
            .upsert(true)
            .returnDocument(ReturnDocument.AFTER);

    Document ret = getIdGenCollection().findOneAndUpdate(getQueryObject(), realUpdate, options);
    if (ret == null) return null;

    Boolean valid = (Boolean) ret.get(VALID);
    if (valid != null && !valid) {
        throw RaptureExceptionFactory.create(HttpURLConnection.HTTP_BAD_REQUEST,
                mongoMsgCatalog.getMessage("IdGenerator"));
    }
    return (Long) ret.get(SEQ);
}

@Override
public void updateRow(String rowId, Map<String, Object> recordValues) {
    String key = getKey(rowId); // stupid key is row id plus "l/" prepended
                                // to it

    MongoCollection<Document> collection = MongoDBFactory.getCollection(instanceName, tableName);
    Document query = new Document();
    query.put(KEY, key);
    Document toPut = new Document();
    toPut.put(KEY, key);
    toPut.put(ROWID, rowId);
    toPut.put(EPOCH, EpochManager.nextEpoch(collection));
    toPut.putAll(recordValues);

    FindOneAndUpdateOptions options = new FindOneAndUpdateOptions().upsert(true).returnDocument(ReturnDocument.AFTER);

    @SuppressWarnings("unused")
    Document ret = collection.findOneAndUpdate(query, new Document($SET, toPut), options);
}

@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();
}

/**
 * Saves a set of {@link ProtectedRegion} for the specified world to database.
 *
 * @param world The name of the world
 * @param set The {@link Set} of regions
 * @throws StorageException Thrown if something goes wrong during database query
 */
public void saveAll(final String world, Set<ProtectedRegion> set) throws StorageException {
    MongoCollection<ProcessingProtectedRegion> collection = getCollection();
    final AtomicReference<Throwable> lastError = new AtomicReference<>();
    final CountDownLatch waiter = new CountDownLatch(set.size());
    for (final ProtectedRegion region : set) {
        if (listener != null)
            listener.beforeDatabaseUpdate(world, region);
        collection.findOneAndUpdate(
                Filters.and(Filters.eq("name", region.getId()), Filters.eq("world", world)),
                new Document("$set", new ProcessingProtectedRegion(region, world)),
                new FindOneAndUpdateOptions().upsert(true).returnDocument(ReturnDocument.AFTER),
                OperationResultCallback.create(lastError, waiter, new UpdateCallback(world))
        );
    }
    ConcurrentUtils.safeAwait(waiter);
    Throwable realLastError = lastError.get();
    if (realLastError != null)
        throw new StorageException("An error occurred while saving or updating in MongoDB.", realLastError);
}

@Override
public io.vertx.ext.mongo.MongoClient findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler) {
  requireNonNull(collection, "collection cannot be null");
  requireNonNull(query, "query cannot be null");
  requireNonNull(update, "update cannot be null");
  requireNonNull(findOptions, "find options cannot be null");
  requireNonNull(updateOptions, "update options cannot be null");
  requireNonNull(resultHandler, "resultHandler cannot be null");

  JsonObject encodedQuery = encodeKeyWhenUseObjectId(query);

  Bson bquery = wrap(encodedQuery);
  Bson bupdate = wrap(update);
  FindOneAndUpdateOptions foauOptions = new FindOneAndUpdateOptions();
  foauOptions.sort(wrap(findOptions.getSort()));
  foauOptions.projection(wrap(findOptions.getFields()));
  foauOptions.upsert(updateOptions.isUpsert());
  foauOptions.returnDocument(updateOptions.isReturningNewDocument() ? ReturnDocument.AFTER : ReturnDocument.BEFORE);

  MongoCollection<JsonObject> coll = getCollection(collection);
  coll.findOneAndUpdate(bquery, bupdate, foauOptions, wrapCallback(resultHandler));
  return this;
}

@Override
public io.vertx.ext.mongo.MongoClient findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions, Handler<AsyncResult<JsonObject>> resultHandler) {
  requireNonNull(collection, "collection cannot be null");
  requireNonNull(query, "query cannot be null");
  requireNonNull(findOptions, "find options cannot be null");
  requireNonNull(updateOptions, "update options cannot be null");
  requireNonNull(resultHandler, "resultHandler cannot be null");

  JsonObject encodedQuery = encodeKeyWhenUseObjectId(query);

  Bson bquery = wrap(encodedQuery);
  FindOneAndReplaceOptions foarOptions = new FindOneAndReplaceOptions();
  foarOptions.sort(wrap(findOptions.getSort()));
  foarOptions.projection(wrap(findOptions.getFields()));
  foarOptions.upsert(updateOptions.isUpsert());
  foarOptions.returnDocument(updateOptions.isReturningNewDocument() ? ReturnDocument.AFTER : ReturnDocument.BEFORE);

  MongoCollection<JsonObject> coll = getCollection(collection);
  coll.findOneAndReplace(bquery, replace, foarOptions, wrapCallback(resultHandler));
  return this;
}

/**
 * Configures this modifier so that new (updated) version of document will be returned in
 * case of successful update.
 * @see #returningOld()
 * @return {@code this} modifier for chained invocation
 */
// safe unchecked: we expect I to be a self type
@SuppressWarnings("unchecked")
public final M returningNew() {
  options.returnDocument(ReturnDocument.AFTER);
  return (M) this;
}

/**
 * Configures this modifier so that new (updated) version of document will be returned in
 * case of successful update.
 * @see #returningOld()
 * @return {@code this} modifier for chained invocation
 */
// safe unchecked: we expect I to be a self type
@SuppressWarnings("unchecked")
public final M returningNew() {
  options.returnDocument(ReturnDocument.AFTER);
  return (M) this;
}

@Override
public Optional<T> reschedule(final T item) {
    validateReschedule(item);

    final Document query = new Document();
    query.put("_id", new ObjectId(item.getId()));
    query.put("heartbeat", DateUtil.toDate(item.getHeartbeat()));

    final Document setDoc = new Document();
    setDoc.put("heartbeat", null);
    setDoc.put("runDate", DateUtil.toDate(item.getRunDate()));
    setDoc.put("status", OkraStatus.PENDING.name());

    final Document update = new Document();
    update.put("$set", setDoc);

    final FindOneAndUpdateOptions options = new FindOneAndUpdateOptions();
    options.returnDocument(ReturnDocument.AFTER);

    final Document document = client
            .getDatabase(getDatabase())
            .getCollection(getCollection())
            .findOneAndUpdate(query, update, options);

    if (document == null) {
        return Optional.empty();
    }

    return Optional.ofNullable(serializer.fromDocument(scheduleItemClass, document));
}

@Override
public Optional<T> heartbeatAndUpdateCustomAttrs(final T item, final Map<String, Object> attrs) {
    validateHeartbeat(item);

    final Document query = new Document();
    query.put("_id", new ObjectId(item.getId()));
    query.put("status", OkraStatus.PROCESSING.name());
    query.put("heartbeat", DateUtil.toDate(item.getHeartbeat()));

    final Document update = new Document();
    update.put("$set", new Document("heartbeat", new Date()));

    if (attrs != null && !attrs.isEmpty()) {
        attrs.forEach((key, value) -> update.append("$set", new Document(key, value)));
    }

    final FindOneAndUpdateOptions options = new FindOneAndUpdateOptions();
    options.returnDocument(ReturnDocument.AFTER);

    final Document result = client
            .getDatabase(getDatabase())
            .getCollection(getCollection())
            .findOneAndUpdate(query, update, options);

    if (result == null) {
        return Optional.empty();
    }

    return Optional.ofNullable(serializer.fromDocument(scheduleItemClass, result));
}

public SyncMap saveMapping(SyncMap map) {
    // TODO : check why this is needed
    if (map.getMapId() == null) {
        map.setMapId(new ObjectId());
    }
    return syncMappings.findOneAndReplace(Filters.eq(SyncAttrs.ID, map.getMapId()), map,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

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));
}

public SyncEvent saveEvent(SyncEvent event) {
    if (event.getEventId() == null) {
        event.setEventId(new ObjectId());
    }
    return syncEvents.findOneAndReplace(Filters.eq(SyncAttrs.ID, event.getEventId()), event,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncConnectionInfo updateConnection(SyncConnectionInfo connInfo) {
    if(connInfo.getConnectionId() == null){
        connInfo.setConnectionId(new ObjectId());
    }
    return connectionInfo.findOneAndReplace(
            Filters.eq(String.valueOf(ConnectionInfoAttributes._id), connInfo.getConnectionId()), connInfo,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

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;
}

public MngToOrclSyncWriter(BlockingQueue<Document> dataBuffer, MongoToOracleMap map, SyncMarker marker,
        CountDownLatch latch, boolean isRestrictedSyncEnabled, ObjectId eventId) {
    super();
    this.dataBuffer = dataBuffer;
    this.map = map;
    this.marker = marker;
    this.latch = latch;
    this.isRestrictedSyncEnabled = isRestrictedSyncEnabled;
    this.eventId = eventId;
    this.options = new FindOneAndUpdateOptions();
    options.returnDocument(ReturnDocument.BEFORE);
}

public String createNewLotCodeForTransportation() {
    Document updateLotCode = collection.findOneAndUpdate(exists("lotConfiguration.lastInsertionTransportation"),
            new Document("$inc", new Document("lotConfiguration.lastInsertionTransportation", 1)),
            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));

    LaboratoryConfiguration laboratoryConfiguration = LaboratoryConfiguration.deserialize(updateLotCode.toJson());

    return laboratoryConfiguration.getLotConfiguration().getLastInsertionTransportation().toString();
}

public String createNewLotCodeForExam() {
    Document updateLotCode = collection.findOneAndUpdate(exists("lotConfiguration.lastInsertionExam"),
            new Document("$inc", new Document("lotConfiguration.lastInsertionExam", 1)),
            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));

    LaboratoryConfiguration laboratoryConfiguration = LaboratoryConfiguration.deserialize(updateLotCode.toJson());

    return laboratoryConfiguration.getLotConfiguration().getLastInsertionExam().toString();
}

@Override
public void execUpdate(Bson filter, Bson update, SmofOpOptions options) {
    options.setReturnDocument(ReturnDocument.AFTER);
    final BsonDocument result = collection.findOneAndUpdate(filter, update, options.toFindOneAndUpdateOptions());
    final T element = parser.fromBson(result, type);
    cache.put(result.getObjectId(Element.ID).getValue(), element);
}

@Override
public void put(String key, String value) {
    MongoCollection<Document> collection = getCollection();
    Document query = new Document(KEY, key);
    Document toPut = new Document($SET, new Document(KEY, key).append(VALUE, value));

    FindOneAndUpdateOptions options = new FindOneAndUpdateOptions().upsert(true).returnDocument(ReturnDocument.BEFORE);
    Document result = collection.findOneAndUpdate(query, toPut, options);

    if (needsFolderHandling && result == null) {
        dirRepo.registerParentage(key);
    }
}

private void saveDocument(String key, String column, Object val) {
    registerKey(key);
    MongoCollection<Document> collection = getCollection(key);
    Document dbkey = new Document(ROWKEY, key).append(COLKEY, column);
    Document dbval = new Document($SET, new Document(ROWKEY, key).append(COLKEY, column).append(VALKEY, val));
    FindOneAndUpdateOptions options = new FindOneAndUpdateOptions().upsert(true).returnDocument(ReturnDocument.AFTER);
    try {
        @SuppressWarnings("unused")
        Document ret = collection.findOneAndUpdate(dbkey, dbval, options);
    } catch (MongoException me) {
        throw RaptureExceptionFactory.create(HttpURLConnection.HTTP_INTERNAL_ERROR, new ExceptionToString(me));
    }
}

/**
 * Returns the next epoch available and advances the counter. Guaranteed to
 * be unique for the given collection. If the epoch document does not
 * already exist a new one is created and the first epoch returned will be
 * 1L.
 * 
 * @param collection
 *            - the MongoCollection to the get next epoch for
 * @return Long - a unique epoch value for this collection
 */
public static Long nextEpoch(final MongoCollection<Document> collection) {
    final FindOneAndUpdateOptions options = new FindOneAndUpdateOptions().upsert(true).returnDocument(ReturnDocument.AFTER);

    MongoRetryWrapper<Long> wrapper = new MongoRetryWrapper<Long>() {
        public Long action(FindIterable<Document> cursor) {
            Document ret = collection.findOneAndUpdate(getEpochQueryObject(), getIncUpdateObject(getUpdateObject()), options);
            return (Long) ret.get(SEQ);
        }
    };
    return wrapper.doAction();
}

@ExtDirectMethod
public void sendPassordResetEmail(String userId) {
    String token = UUID.randomUUID().toString();

    User user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
            Filters.eq(CUser.id, userId),
            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));

    this.mailService.sendPasswortResetEmail(user);
}

@Override
public void onAuthenticationSuccess(HttpServletRequest request,
        HttpServletResponse response, Authentication authentication)
        throws IOException, ServletException {

    Map<String, Object> result = new HashMap<>();
    result.put("success", true);

    MongoUserDetails userDetails = (MongoUserDetails) authentication.getPrincipal();
    if (userDetails != null) {
        User user;
        if (!userDetails.isPreAuth()) {

            user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
                    Filters.eq(CUser.id, userDetails.getUserDbId()),
                    Updates.set(CUser.lastAccess, new Date()),
                    new FindOneAndUpdateOptions()
                            .returnDocument(ReturnDocument.AFTER));
        }
        else {
            user = this.mongoDb.getCollection(User.class)
                    .find(Filters.eq(CUser.id, userDetails.getUserDbId())).first();
        }
        result.put(SecurityService.AUTH_USER, new UserDetailDto(userDetails, user,
                CsrfController.getCsrfToken(request)));
    }
    response.setCharacterEncoding("UTF-8");
    response.getWriter().print(this.objectMapper.writeValueAsString(result));
    response.getWriter().flush();
}

/**
 * Configures this modifier so that new (updated) version of document will be returned in
 * case of successful update.
 * @see #returningOld()
 * @return {@code this} modifier for chained invocation
 */
// safe unchecked: we expect I to be a self type
@SuppressWarnings("unchecked")
public final M returningNew() {
  options.returnDocument(ReturnDocument.AFTER);
  return (M) this;
}

/**
 * Configures this modifier so that new (updated) version of document will be returned in
 * case of successful update.
 * @see #returningOld()
 * @return {@code this} modifier for chained invocation
 */
// safe unchecked: we expect I to be a self type
@SuppressWarnings("unchecked")
public final M returningNew() {
  options.returnDocument(ReturnDocument.AFTER);
  return (M) this;
}

public SyncUserSession saveSession(SyncUserSession userSession) {
    return userSessionCollection.findOneAndReplace(
            Filters.eq(String.valueOf(SessionAttributes._id), userSession.getSessionId()), userSession,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public void setEncryptedPassword(ObjectId id , byte[] pass) {
     connectionInfo.findOneAndUpdate(
            Filters.and(Filters.eq(String.valueOf(ConnectionInfoAttributes._id), id)),
            Updates.set(String.valueOf(ConnectionInfoAttributes.password), pass),
            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));
}

public SyncNode updateNodeDetails(SyncNode nodeMapper) {
    return syncNodeMapping.findOneAndReplace(Filters.eq(SyncAttrs.ID, nodeMapper.getId()), nodeMapper,
            new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER).upsert(true));
}

public SyncNode getNodeDetails(SyncNode nodeMapper) {
    Bson filter = Filters.eq(SyncAttrs.UUID, nodeMapper.getUUID());
    logger.info("Getting node with filter " + filter);
    return syncNodeMapping.findOneAndUpdate(filter, Updates.unset(SyncAttrs.FAILURE_TIME),
            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));
}

public SyncUser updateUser(SyncUser user) {
    return userDetailsCollection.findOneAndReplace(
            Filters.eq(String.valueOf(UserDetailAttributes._id),user.getUserid()),user,
                    new FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER)
                                                  .upsert(true));
}

public void saveFlow(FlowEntity flowEntity) {

    if (flowEntity.getId() == null) {
      Integer nextId;
      Document lastFlow = collection.find()
          .projection(new Document("flow_id", 1))
          .sort(new Document("flow_id", -1))
          .limit(1)
          .first();
      if (lastFlow == null) {
        nextId = 1;
      } else {
        nextId = lastFlow.getInteger("flow_id") + 1;
      }

      flowEntity.setId(nextId);
    }

    Document filter = new Document()
        .append("flow_id", flowEntity.getId());

    List<Document> conditionList = flowEntity.getConditionList()
        .stream()
        .map(conditionEntity ->
            new Document()
                .append("dev_id", conditionEntity.getDevId())
                .append("dev_type", conditionEntity.getDevType())
                .append("type", conditionEntity.getType())
                .append("parameter", conditionEntity.getParameter()))
        .collect(Collectors.toList());

    List<Document> actionList = flowEntity.getActionList()
        .stream()
        .map(conditionEntity ->
            new Document()
                .append("dev_id", conditionEntity.getDevId())
                .append("dev_type", conditionEntity.getDevType())
                .append("type", conditionEntity.getType())
                .append("parameter", conditionEntity.getParameter()))
        .collect(Collectors.toList());

    Document entityDocument = new Document()
        .append("$set", new Document()
            .append("flow_id", flowEntity.getId())
            .append("name", flowEntity.getName())
            .append("order_num", flowEntity.getOrderNum())
            .append("conditions", conditionList)
            .append("actions", actionList)
        );

    FindOneAndUpdateOptions options = new FindOneAndUpdateOptions()
        .returnDocument(ReturnDocument.AFTER)
        .upsert(true);

    collection.findOneAndUpdate(filter, entityDocument, options);
  }

public SmofOpOptionsImpl() {
    upsert = false;
    validateDocuments = true;
    ret = ReturnDocument.AFTER;
    bypassCache = false;
}

@Override
   public void setReturnDocument(ReturnDocument doc) {
    this.ret = doc;
}

private void updateLockedProperties(AuthenticationFailureBadCredentialsEvent event) {
    Object principal = event.getAuthentication().getPrincipal();

    if (this.loginLockAttempts != null && (principal instanceof String
            || principal instanceof MongoUserDetails)) {

        User user = null;
        if (principal instanceof String) {
            user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
                    Filters.and(Filters.eq(CUser.loginName, principal),
                            Filters.eq(CUser.deleted, false)),
                    Updates.inc(CUser.failedLogins, 1), new FindOneAndUpdateOptions()
                            .returnDocument(ReturnDocument.AFTER).upsert(false));
        }
        else {
            user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
                    Filters.eq(CUser.id,
                            ((MongoUserDetails) principal).getUserDbId()),
                    Updates.inc(CUser.failedLogins, 1), new FindOneAndUpdateOptions()
                            .returnDocument(ReturnDocument.AFTER).upsert(false));
        }

        if (user != null) {
            if (user.getFailedLogins() >= this.loginLockAttempts) {
                if (this.loginLockMinutes != null) {
                    this.mongoDb.getCollection(User.class).updateOne(
                            Filters.eq(CUser.id, user.getId()),
                            Updates.set(CUser.lockedOutUntil,
                                    Date.from(ZonedDateTime.now(ZoneOffset.UTC)
                                            .plusMinutes(this.loginLockMinutes)
                                            .toInstant())));
                }
                else {
                    this.mongoDb.getCollection(User.class)
                            .updateOne(Filters.eq(CUser.id, user.getId()),
                                    Updates.set(CUser.lockedOutUntil,
                                            Date.from(ZonedDateTime
                                                    .now(ZoneOffset.UTC)
                                                    .plusYears(1000).toInstant())));
                }
            }
        }
        else {
            Application.logger.warn("Unknown user login attempt: {}", principal);
        }
    }
    else {
        Application.logger.warn("Invalid login attempt: {}", principal);
    }
}