Java Code Examples for com.mongodb.DBObject#removeField()

public void insert(List<CanalEntry.Column> data, String schemaName, String tableName) {
    DBObject obj = DBConvertUtil.columnToJson(data);
    logger.debug("insert ：{}", obj.toString());
    //订单库单独处理
    if (schemaName.equals("order")) {
        //保存原始数据
        if (tableName.startsWith("order_base_info")) {
            tableName = "order_base_info";
        } else if (tableName.startsWith("order_detail_info")) {
            tableName = "order_detail_info";
        } else {
            logger.info("unknown data ：{}.{}:{}", schemaName, tableName, obj);
            return;
        }
        insertData(schemaName, tableName, obj, obj);
    } else {
        DBObject newObj = (DBObject) ObjectUtils.clone(obj);
        if (newObj.containsField("id")) {
            newObj.put("_id", newObj.get("id"));
            newObj.removeField("id");
        }
        insertData(schemaName, tableName, newObj, obj);
    }
}
 

public void updateData(String schemaName, String tableName, DBObject query, DBObject obj) {
    String path = "/" + schemaName + "/" + tableName + "/" + CanalEntry.EventType.UPDATE.getNumber();
    int i = 0;
    DBObject newObj = (DBObject) ObjectUtils.clone(obj);
    DBObject logObj = (DBObject) ObjectUtils.clone(obj);
    //保存原始数据
    try {
        obj.removeField("id");
        i++;
        naiveMongoTemplate.getCollection(tableName).update(query, obj);
        i++;
        SpringUtil.doEvent(path, newObj);
        i++;
    } catch (MongoClientException | MongoSocketException clientException) {
        //客户端连接异常抛出，阻塞同步，防止mongodb宕机
        throw clientException;
    } catch (Exception e) {
        logError(schemaName, tableName, 2, i, logObj, e);
    }
}
 

@Test
public void shouldSaveTheIncomingEvent() throws Exception {
	application = Application.builder().name("fake").build();
    eventRepository.saveIncoming(tenant, application, incomingEvent);
    

    DBObject saved = mongoTemplate.findOne(
            Query.query(Criteria.where("incoming.deviceGuid").is(deviceGuid)
                    .andOperator(Criteria.where("ts").is(firstEventTimestamp.toEpochMilli()))),
            DBObject.class,
            EventRepositoryMongoImpl.EVENTS_INCOMING_COLLECTION_NAME
    );
    saved.removeField("_id");
    saved.removeField("_class");

    assertThat(saved, equalTo(persisted));
}
 

private boolean isContained(List<DBObject> item, BasicDBObject doc) {
    boolean res = false;
    for (int i = 0; i < item.size() && !res; i++) {
        DBObject aux = item.get(i);
        aux.removeField("_id");
        aux.removeField("timestamp");

        if (aux.keySet().equals(doc.keySet())) {
            res = true;
        }
        // Obtenemos los columnNames
        List<String> cols = new ArrayList<String>(doc.keySet());
        for (int x = 0; x < cols.size() && res; x++) {
            if (!aux.get(cols.get(x)).equals(doc.get(cols.get(x)))) {
                res = false;
            } else {
                res = true;
            }
        }
    }
    return res;
}
 

@SuppressWarnings("unchecked")
private DBObject toSubDocQuery(DBObject originalQueryDBObject, boolean isParentQuery) {

    DBObject queryDBObject = appendSubField(originalQueryDBObject, isParentQuery);
    for (String key : originalQueryDBObject.keySet()) {
        if (key.equals("$or") || key.equals("$and")) {
            List<DBObject> originalOrQueryDBObjects = (List<DBObject>) originalQueryDBObject.get(key);
            List<DBObject> orQueryDBObjects = new ArrayList<DBObject>();
            for (DBObject originalOrQueryDBObject : originalOrQueryDBObjects) {
                DBObject orQueryDBObject = appendSubField(originalOrQueryDBObject, isParentQuery);
                if (orQueryDBObject.get("_id") != null) {
                    addId(queryDBObject, orQueryDBObject.get("_id"));
                    orQueryDBObject.removeField("_id");
                }
                orQueryDBObjects.add(orQueryDBObject);
            }
            queryDBObject.put(key, orQueryDBObjects);
        }
    }
    return queryDBObject;
}
 

@DELETE
@Path("/delete/{product}")
@Produces(MediaType.APPLICATION_JSON)
public Response softDeleteEntireProduct(@PathParam("product") final String product) {

	final DBCollection collection = this.mongoLegacyDb.getCollection("summary");
	final DBCollection targetCollection = this.mongoLegacyDb.getCollection("deletedSummary");

	final BasicDBObject query = new BasicDBObject("coordinates.product", product);

	final DBCursor cursor = collection.find(query);
	DBObject doc;

	while (cursor.hasNext()) {
		doc = cursor.next();
		// kill the old id
		doc.removeField("_id");
		try {
			targetCollection.insert(doc);
		} catch (final Throwable e) {
			return Response.status(500).build();
		}
	}

	collection.remove(query);

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

@DELETE
@Path("/delete/{product}/{version}")
@Produces(MediaType.APPLICATION_JSON)
public Response softDeleteSingleVersion(@PathParam("product") final String product,
		@PathParam("version") final String version) {

	final DBCollection collection = this.mongoLegacyDb.getCollection("summary");
	final DBCollection targetCollection = this.mongoLegacyDb.getCollection("deletedSummary");

	final Pattern productReg = java.util.regex.Pattern.compile("^" + product + "/" + version + "$");
	final BasicDBObject query = new BasicDBObject("_id", productReg);

	final DBCursor cursor = collection.find(query);
	DBObject doc;

	while (cursor.hasNext()) {
		doc = cursor.next();
		// kill the old id
		doc.removeField("_id");
		try {
			targetCollection.insert(doc);
		} catch (final Throwable e) {
			return Response.status(500).build();
		}
	}

	collection.remove(query);

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

@RequestMapping(value = "/api/{projectId}/entities/{name}/{id}", method = RequestMethod.GET, headers = "Accept=application/json")
   public @ResponseBody
   String getEntityDataById(@PathVariable("projectId") String projectId, @PathVariable("name") String entityName,
    @PathVariable("id") String entityDataId,
    @RequestHeader(value = "authToken", required = false) String authToken) {

JSONObject authRes = authService.authorize(projectId,authToken,"USER");
if(!authRes.getBoolean(SUCCESS)){
    return authRes.toString(4);
}

DBCollection dbCollection = mongoTemplate.getCollection(projectId+"_"+entityName);

BasicDBObject queryObject = new BasicDBObject();
queryObject.append("_id", new ObjectId(entityDataId));

DBObject resultObject = dbCollection.findOne(queryObject);

if(resultObject == null){
    return "Not Found";
}

if(entityName.equals("User")){
    resultObject.removeField(PASSWORD);
}

dbRefToRelation(resultObject);
String json = resultObject.toString();

// Indentation
JSONObject jsonObject = new JSONObject(json);
return jsonObject.toString(4);
   }
 

@Override
public DBObject convert(final User user) {
    final DBObject dbObject = new BasicDBObject();
    dbObject.put("name", user.getName());
    dbObject.put("age", user.getAge());
    if (user.getEmailAddress() != null) {
        final DBObject emailDbObject = new BasicDBObject();
        emailDbObject.put("value", user.getEmailAddress().getValue());
        dbObject.put("email", emailDbObject);
    }
    dbObject.removeField("_class");
    return dbObject;
}
 

public Representation doRepresent() {
      // Ready query params
      String _page = getQueryValue("page");
      String _size = getQueryValue("size");

ProjectRepository projectRepo = platform.getProjectRepositoryManager().getProjectRepository();
       
      DBCursor cursor;
      if(_page != null && !"".equals(_page) && isInteger(_page) && _size != null && !"".equals(_size) && isInteger(_size)) {
      	int page = Integer.valueOf(_page);
      	int pageSize = Integer.valueOf(_size);
      	cursor = projectRepo.getProjects().getDbCollection().find().skip(page*pageSize).limit(pageSize);
      } else {
      	cursor = projectRepo.getProjects().getDbCollection().find();
      }
      
      ArrayNode projects = mapper.createArrayNode();
      
      while (cursor.hasNext()) {
          try {
          	DBObject p = cursor.next();
          	p.removeField("storage");
		p.removeField("metricProviderData");
		p.removeField("_superTypes");
		p.removeField("_id");
		
		// FIXME: Temporary solution
		p.removeField("licenses");
		p.removeField("persons");
		
		projects.add(mapper.readTree(p.toString()));
          } catch (Exception e) {
          	System.err.println("Error: " + e.getMessage());
		ObjectNode m = mapper.createObjectNode();
		m.put("apicall", "list-all-projects");
		return Util.generateErrorMessageRepresentation(m, e.getMessage());
          }
      }
      
      cursor.close();
      
      StringRepresentation resp = new StringRepresentation(projects.toString());
resp.setMediaType(MediaType.APPLICATION_JSON);
return resp;
  }
 

private void process(XMLStreamReader xml) throws XMLStreamException {
  String tag;
  String root = null;
  Stack<DBObject> json = new Stack<DBObject>();
  DBObject js;
  while (xml.hasNext()) {
    int eventType = xml.next();
    while (xml.isWhiteSpace() || eventType == XMLEvent.SPACE)
      eventType = xml.next();

    switch (eventType) {
      case XMLEvent.START_ELEMENT:
        tag = xml.getLocalName();
        if (root == null) {
          root = tag;
        } else {
          json.push(new BasicDBObject());
        }
        break;
      case XMLEvent.END_ELEMENT:
        tag = xml.getLocalName();
        if (tag.equals(root)) {
          // will terminate in next iteration
        } else {
          js = json.pop();
          if (json.size() == 0) {
            if (tag.equals(rowTag))
              printEntry(js);
            else
              printUnwantedEntry(js);
          } else {
            putListStrOrJSON(json.peek(), tag, js);
          }
        }
        break;

      case XMLEvent.CHARACTERS:
        String txt = xml.getText();
        js = json.peek();
        if (js.containsField(strTag)) {
          txt = js.get(strTag) + txt;
          js.removeField(strTag);
        }
        js.put(strTag, txt);
        break;

      case XMLEvent.START_DOCUMENT:
        break;
      case XMLEvent.END_DOCUMENT:
        break;
      case XMLEvent.COMMENT:
      case XMLEvent.ENTITY_REFERENCE:
      case XMLEvent.ATTRIBUTE:
      case XMLEvent.PROCESSING_INSTRUCTION:
      case XMLEvent.DTD:
      case XMLEvent.CDATA:
      case XMLEvent.SPACE:
        System.out.format("%s --\n", eventType);
        break;
    }
  }
}
 

public void insert(String domainName, long timestampMillis, String level, String message) {

		String collectionName = domainName;

		checkCollection(collectionName);

		DBObject object = new BasicDBObject();
		object.put("time", timestampMillis);
		object.put("level", level);
		object.put("message", message);
		object.removeField("_class");

		DBCollection collection = mongoAuditTemplate.getCollection(collectionName);
		collection.insert(object);

	}
 

@Override
protected Event doSave(Tenant tenant, Application application, Event event, Type type) throws BusinessException {
    Optional.ofNullable(tenantRepository.findByDomainName(tenant.getDomainName()))
            .orElseThrow(() -> new BusinessException(CommonValidations.TENANT_DOES_NOT_EXIST.getCode()));

    Tenant existingTenant = tenantRepository.findByDomainName(tenant.getDomainName());

    if (!application.getName().equals(event.getIncoming().getDeviceGuid())) {
    	Optional.ofNullable(deviceRepository.findByTenantAndGuid(existingTenant.getId(), event.getIncoming().getDeviceGuid()))
    		.orElseThrow(() -> new BusinessException(Validations.INCOMING_DEVICE_ID_DOES_NOT_EXIST.getCode()));
    }

    Optional.ofNullable(event.getCreationTimestamp())
            .orElseThrow(() -> new BusinessException(Validations.EVENT_TIMESTAMP_NULL.getCode()));

    if (type.equals(Type.OUTGOING)) {
        Optional.ofNullable(event.getOutgoing())
                .orElseThrow(() -> new BusinessException(Validations.EVENT_OUTGOING_NULL.getCode()));
        Optional.ofNullable(event.getOutgoing().getDeviceGuid()).filter(s -> !s.isEmpty())
                .orElseThrow(() -> new BusinessException(Validations.OUTGOING_DEVICE_GUID_NULL.getCode()));
        Optional.ofNullable(event.getOutgoing().getChannel()).filter(s -> !s.isEmpty())
                .orElseThrow(() -> new BusinessException(Validations.EVENT_OUTGOING_CHANNEL_NULL.getCode()));

        Optional.ofNullable(
                deviceRepository.findByTenantAndGuid(existingTenant.getId(),event.getOutgoing().getDeviceGuid())
        ).orElseThrow(() -> new BusinessException(Validations.OUTGOING_DEVICE_ID_DOES_NOT_EXIST.getCode()));
    }

    event.getIncoming().setTenantDomain(tenant.getDomainName());

    DBObject incoming = new BasicDBObject();
    incoming.put("deviceGuid",event.getIncoming().getDeviceGuid());
    incoming.put("tenantDomain",event.getIncoming().getTenantDomain());
    incoming.put("applicationName",event.getIncoming().getApplicationName());
    incoming.put("channel",event.getIncoming().getChannel());
    incoming.put("deviceId", event.getIncoming().getDeviceId());
    incoming.put("locationGuid", event.getIncoming().getLocationGuid());
    
    DBObject toSave = new BasicDBObject();

    toSave.removeField("ts");
    toSave.put("ts", event.getCreationTimestamp().toEpochMilli());
    toSave.put("ingestedTimestamp", event.getIngestedTimestamp());
    toSave.put(Type.INCOMING.getActorFieldName(), incoming);
    toSave.put("payload", event.getPayload());
    
    if (Optional.ofNullable(event.getGeolocation()).isPresent()) {
    	DBObject geolocation = new BasicDBObject();
    	geolocation.put("lat", event.getGeolocation().getLat());
    	geolocation.put("lon", event.getGeolocation().getLon());
    	geolocation.put("hdop", event.getGeolocation().getHdop());
    	geolocation.put("elev", event.getGeolocation().getElev());
    	
    	toSave.put("geolocation", geolocation);
    }

    if (type.equals(Type.OUTGOING)) {
        DBObject outgoing = new BasicDBObject();
        outgoing.put("deviceGuid",event.getOutgoing().getDeviceGuid());
        outgoing.put("tenantDomain",event.getOutgoing().getTenantDomain());
        outgoing.put("applicationName",event.getOutgoing().getApplicationName());
        outgoing.put("channel",event.getOutgoing().getChannel());
        outgoing.put("deviceId", event.getOutgoing().getDeviceId());
        outgoing.put("locationGuid", event.getOutgoing().getLocationGuid());

        toSave.put(Type.OUTGOING.getActorFieldName(), outgoing);
    }

    mongoTemplate.save(toSave, type.getCollectionName());

    return event;
}
 

@SuppressWarnings("unchecked")
private DBObject appendSubField(DBObject originalDBObject, boolean isParentQuery) {
    DBObject newDBObject = new Query().getQueryObject();
    for (String key : originalDBObject.keySet()) {
        if (!key.startsWith("$")) {
            String newKey = key;
            Object newValue = originalDBObject.get(key);
            String updatedKey = key.replace("body.", "");
            if (key.equals("_id") && getIds(newValue).size() != 0) {
                // use parent id for id query
                try {
                    Set<String> parentIds = getParentIds(getIds(newValue));
                    if (parentIds != null && parentIds.size() > 1) {
                        newDBObject.put(newKey, new BasicDBObject("$in", parentIds));
                    } else if (parentIds != null && parentIds.size() == 1) {
                        newDBObject.put(newKey, parentIds.iterator().next());
                    }
                } catch (InvalidIdException e) {
                    LOG.info("There was an invalid Id exception. Ignoring.");
                    // child id does not have parent id, qppend the subfield to original
                    // query, this may trigger table scan if subFiled._id is not
                    // indexed
                    // newKey = subField + "." + key;
                    // newDBObject.put(newKey, newValue);
                    LOG.error(
                            "Embedded entity's ID does not contain parentId.  Cannot determine parent superdoc.  ID: {}",
                            newValue);
                }
            }
            if (lookup.containsKey(updatedKey)) {

                if (newDBObject.get(updatedKey) != null) {
                    Object idList = newDBObject.get(updatedKey);
                    Set<String> combined = new HashSet<String>();
                    combined.addAll(extractIdSet(idList));
                    combined.addAll(extractIdSet(newValue));
                    newDBObject.put(lookup.get(updatedKey), new BasicDBObject("$in", combined));
                } else {
                    newDBObject.put(lookup.get(key.replace("body.", "")), newValue);
                }
            } else {
                // for other query, append the subfield to original key
                newKey = subField + "." + key;
                newDBObject.put(newKey, newValue);
            }

        } else if (key.equals("$or") || key.equals("$and")) {
            List<DBObject> dbObjects = (List<DBObject>) originalDBObject.get(key);
            List<DBObject> orQueryDBObjects = new ArrayList<DBObject>();
            for (DBObject dbObject : dbObjects) {
                DBObject subQuery = toSubDocQuery(dbObject, isParentQuery);
                if (subQuery.get("_id") != null) {
                    addId(newDBObject, subQuery.get("_id"));
                    subQuery.removeField("_id");
                }
                orQueryDBObjects.add(subQuery);
            }
            newDBObject.put(key, orQueryDBObjects);
        }
    }
    return newDBObject;
}
 

@SuppressWarnings("unchecked")
private void simplifyParentQuery(final DBObject query) {
    final Set<String> parentSet = new HashSet<String>();
    if (isSubDoc(this.subField) && subDoc(this.subField).collection.equals(this.collection)) {
        final String childLoc = this.subField.concat("._id");
        final String parentLoc = "_id";
        final Object dbOrObj = query.get("$or");
        if (dbOrObj != null && dbOrObj instanceof List) {
            final List<DBObject> dbOrList = (List<DBObject>) dbOrObj;
            for (DBObject childQuery : dbOrList) {
                Object childInQuery = childQuery.get(childLoc);
                if (childInQuery instanceof DBObject && ((DBObject) childInQuery).containsField("$in")) {
                    Object inList = ((DBObject) childInQuery).get("$in");
                    try {
                        Object id = query.get("_id");
                        if (id != null && id instanceof String) {
                            String singleId = (String) id;
                            if (getParentIds(inList).contains(singleId)) {
                                parentSet.add(singleId);
                            } else {
                                // No union of constraining criteria --> return
                                return;
                            }
                        } else {
                            parentSet.addAll(getParentIds(inList));
                        }
                    } catch (InvalidIdException e) {
                        // IDs aren't valid, we can't simplify the query
                        return;
                    }
                    if (parentSet.size() > 0) {
                        if (dbOrList.size() == 1) {
                            query.removeField("$or");
                        } else {
                            dbOrList.remove(childQuery);
                        }
                    }
                }
            }
        }
        if (parentSet.size() == 1) {
            LOG.info("Putting parent id {} in {}", parentSet.iterator().next(), parentLoc);
            query.put(parentLoc, parentSet.iterator().next());
        } else if (parentSet.size() > 1) {
            LOG.info("Putting parent ids $in[{}] in {}", parentSet, parentLoc);
            query.put(parentLoc, new BasicDBObject("$in", parentSet));
        }
    }
}