예제 #1
0
 public String parseJSONFind(String workspaceID, String jsonString) {
   StringBuffer ret = new StringBuffer();
   ret.append("{\n");
   System.out.println(workspaceID);
   System.out.println(jsonString);
   int counter = 0;
   DB db = m.getDB(Tokens.WORKSPACE_DATABASE);
   DBCollection coll = db.getCollection(workspaceID);
   BasicDBObject query =
       (BasicDBObject) JSON.parse(jsonString); // FixStrings.usr2mongo(jsonString)
   System.out.println("query: " + query.toString());
   DBCursor find = coll.find(query);
   Iterator<DBObject> iter = find.iterator();
   while (iter.hasNext()) {
     counter++;
     if (counter > 1) ret.append(",\n");
     DBObject next = iter.next();
     Map toMap = next.toMap();
     ret.append("\"" + toMap.get("_id").toString() + "\" : ");
     // remove the redundant id
     next.removeField("_id");
     // ret+= "\"kbid" + counter + "\" : ";
     String rec = FixStrings.mongo2usr(next.toString());
     ret.append(rec);
   }
   ret.append("\n}\n");
   // System.out.println(workspaceID);
   return ret.toString();
 }
예제 #2
0
  public String retrieveAll(Boolean onlyNames) {
    String ret = "[";
    DBObject resp;
    DBCursor cur = this.services.find();

    while (cur.hasNext()) {
      resp = cur.next();
      resp.removeField("_id");
      System.out.println(resp);
      if (resp.get("state") == null || !((String) resp.get("state")).equals(State.VOID)) {
        if (onlyNames) {
          ret += resp.get("name") + ",";
        } else {
          ret += resp + ",";
        }
      } else {
        return null;
      }
    }

    ret = ret.substring(0, ret.length() - 1);
    ret += "]";

    return ret;
  }
  @Override
  public void clearFavorites(String email) throws UserNotFound {
    if (email == null) {
      throw new IllegalArgumentException("Email cannot be null");
    }
    DBCollection col = db.getCollection(MongoDBConstants.COLLECTION_USERS);
    // Search user by email
    DBObject userDb = col.findOne(new BasicDBObject(MongoDBConstants.USER_PROP_EMAIL, email));
    if (userDb == null) {
      throw new UserNotFound("Unable to find user with email '" + email + "'");
    }

    userDb.removeField(MongoDBConstants.USER_PROP_FAVORITES);
    col.save(userDb);
  }
예제 #4
0
  public String retrieveJson(String name) {
    BasicDBObject query = new BasicDBObject("name", name);
    DBObject resp;
    // DBCursor cur;

    resp = this.services.findOne(query);

    // resp = cur.next();
    if (resp != null) {
      resp.removeField("_id");
      System.out.println(resp);
    }

    return resp.toString();
  }
예제 #5
0
  public <T> Key<T> merge(T entity, WriteConcern wc) {
    LinkedHashMap<Object, DBObject> involvedObjects = new LinkedHashMap<Object, DBObject>();
    DBObject dbObj = mapr.toDBObject(entity, involvedObjects);
    Key<T> key = getKey(entity);
    entity = ProxyHelper.unwrap(entity);
    Object id = getId(entity);
    if (id == null)
      throw new MappingException("Could not get id for " + entity.getClass().getName());
    Query<T> query = (Query<T>) createQuery(entity.getClass()).filter(Mapper.ID_KEY, id);

    // remove (immutable) _id field for update.
    dbObj.removeField(Mapper.ID_KEY);
    UpdateResults<T> res = update(query, new BasicDBObject("$set", dbObj), false, false, wc);

    // check for updated count if we have a gle
    CommandResult gle = res.getWriteResult().getCachedLastError();
    if (gle != null && res.getUpdatedCount() == 0) throw new UpdateException("Not updated: " + gle);

    postSaveOperations(entity, dbObj, involvedObjects);
    return key;
  }
  @Override
  public List<Favorite> removeFromFavorites(String email, List<Favorite> favoritesToRemove)
      throws UserNotFound {
    if (email == null) {
      throw new IllegalArgumentException("Email cannot be null");
    }
    DBCollection col = db.getCollection(MongoDBConstants.COLLECTION_USERS);
    // Search user by email
    DBObject userDb = col.findOne(new BasicDBObject(MongoDBConstants.USER_PROP_EMAIL, email));
    if (userDb == null) {
      throw new UserNotFound("Unable to find user with email '" + email + "'");
    }

    DBObject favoritesDb = (DBObject) userDb.get(MongoDBConstants.USER_PROP_FAVORITES);
    if (favoritesDb == null) {
      favoritesDb = new BasicDBObject();
    }

    if (favoritesToRemove != null) {
      for (Favorite favoriteToRemove : favoritesToRemove) {
        DBObject favoriteItemsDb = (DBObject) favoritesDb.get(favoriteToRemove.getStationId());
        if (favoriteItemsDb != null) {
          favoritesDb.removeField(favoriteToRemove.getStationId());
        }
      }
    }
    userDb.put(MongoDBConstants.USER_PROP_FAVORITES, favoritesDb);
    col.save(userDb);

    List<Favorite> returnValue = new ArrayList<Favorite>(favoritesDb.keySet().size());
    for (String stationId : favoritesDb.keySet()) {
      Favorite favorite = new Favorite();
      favorite.setStationId(stationId);
      DBObject favoriteItemDb = (DBObject) favoritesDb.get(stationId);
      favorite.setLastMessageId(
          (Long) favoriteItemDb.get(MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID));
      returnValue.add(favorite);
    }
    return returnValue;
  }
  /**
   * Removes the type information from the entire conversion result.
   *
   * @param object
   * @param recursively whether to apply the removal recursively
   * @return
   */
  private Object removeTypeInfo(Object object, boolean recursively) {

    if (!(object instanceof DBObject)) {
      return object;
    }

    DBObject dbObject = (DBObject) object;
    String keyToRemove = null;

    for (String key : dbObject.keySet()) {

      if (recursively) {

        Object value = dbObject.get(key);

        if (value instanceof BasicDBList) {
          for (Object element : (BasicDBList) value) {
            removeTypeInfo(element, recursively);
          }
        } else {
          removeTypeInfo(value, recursively);
        }
      }

      if (typeMapper.isTypeKey(key)) {

        keyToRemove = key;

        if (!recursively) {
          break;
        }
      }
    }

    if (keyToRemove != null) {
      dbObject.removeField(keyToRemove);
    }

    return dbObject;
  }
예제 #8
0
  /**
   * @param dbName
   * @param collName
   * @param documentId
   * @param content
   * @param requestEtag
   * @return
   */
  @Override
  public OperationResult upsertDocumentPost(
      String dbName, String collName, Object documentId, DBObject content, ObjectId requestEtag) {
    DB db = client.getDB(dbName);

    DBCollection coll = db.getCollection(collName);

    ObjectId newEtag = new ObjectId();

    if (content == null) {
      content = new BasicDBObject();
    }

    content.put("_etag", newEtag);

    Object _idInContent = content.get("_id");

    content.removeField("_id");

    if (_idInContent == null) {
      // new document since the id was just auto-generated
      content.put("_id", documentId);

      coll.insert(content);

      return new OperationResult(HttpStatus.SC_CREATED, newEtag);
    }

    BasicDBObject idQuery = new BasicDBObject("_id", documentId);

    DBObject oldDocument = coll.findAndModify(idQuery, null, null, false, content, false, true);

    if (oldDocument != null) { // upsertDocument
      // check the old etag (in case restore the old document version)
      return optimisticCheckEtag(coll, oldDocument, newEtag, requestEtag, HttpStatus.SC_OK);
    } else { // insert
      return new OperationResult(HttpStatus.SC_CREATED, newEtag);
    }
  }
예제 #9
0
  public Service retrieve(String name) {
    BasicDBObject query = new BasicDBObject("name", name);
    DBObject resp;
    // DBCursor cur;
    Service service = new Service();
    ArrayList<BasicDBObject> params, plugins;

    resp = this.services.findOne(query);

    if (resp != null) {
      resp.removeField("_id");
      System.out.println(resp);

      service.setName((String) resp.get("name"));
      service.setUri((String) resp.get("uri"));
      try {
        service.setState((String) resp.get("state"));
      } catch (TypeNotPresentException ex) {
        service.setState(State.GENERATED);
      }

      // service.setPluginName((String)resp.get("pluginName"));

      params = (ArrayList<BasicDBObject>) resp.get("params");

      for (BasicDBObject param : params) {
        service.addParam((String) param.get("name"), (Boolean) param.get("required"));
      }

      plugins = (ArrayList<BasicDBObject>) resp.get("plugins");

      for (BasicDBObject plugin : plugins) {
        service.addPlugin((String) plugin.get("class_name"), (String) plugin.get("type"));
      }
      return service;
    } else {
      return null;
    }
  }
 private DBObject removeNullEntries(DBObject nativeEntry) {
   for (String key : new HashSet<String>(nativeEntry.keySet())) {
     Object o = nativeEntry.get(key);
     if (o == null) {
       nativeEntry.removeField(key);
     } else if (o instanceof Object[]) {
       for (Object o2 : (Object[]) o) {
         if (o2 instanceof DBObject) {
           removeNullEntries((DBObject) o2);
         }
       }
     } else if (o instanceof List) {
       for (Object o2 : (List) o) {
         if (o2 instanceof DBObject) {
           removeNullEntries((DBObject) o2);
         }
       }
     } else if (o instanceof DBObject) {
       removeNullEntries((DBObject) o);
     }
   }
   return nativeEntry;
 }
예제 #11
0
 /**
  * The MongoDB dialect replaces the name of the column identifier, so when the tuple is extracted
  * from the db we replace the column name of the identifier with the original one. We are assuming
  * the identifier is not embedded and is a single property.
  */
 private void replaceIdentifierColumnName(DBObject result, EntityKey key) {
   Object idValue = result.get(MongoDBDialect.ID_FIELDNAME);
   result.removeField(MongoDBDialect.ID_FIELDNAME);
   result.put(key.getColumnNames()[0], idValue);
 }