/**
   * if hourlyjob has completed,item will insert to repository db.and partial file will delete,
   * dailydb will delete.
   *
   * @throws UnknownHostException
   */
  @Test
  public void t2() throws UnknownHostException {
    MongoClient mongoClient = new MongoClient(AppConstants.MONGODB_HOST, AppConstants.MONGODB_PORT);
    DB dailyDb = mongoClient.getDB(dailyDbName);

    DBCollection hourlyCol = dailyDb.getCollection(AppConstants.MongoNames.HOURLY_JOB_COL_NAME);
    // must drop,or complete status detect will wrong.
    hourlyCol.drop();
    for (int idx = 24; idx > 12; idx--) {
      DBObject dbo =
          new BasicDBObject()
              .append(AppConstants.MongoNames.HOURLY_JOB_NUMBER_KEY, idx + "")
              .append(AppConstants.MongoNames.HOURLY_JOB_STATUS_KEY, "end");
      hourlyCol.insert(dbo);
    }
    new DailyCopyWorkVerticle.DailyCopyProcessor(
            mongoClient,
            dailyDbName,
            repositoryDbName,
            dailyPartialDir,
            new JsonObject().putNumber("dailydbreadgap", 1000))
        .process();
    mongoClient = new MongoClient(AppConstants.MONGODB_HOST, AppConstants.MONGODB_PORT);
    DB db = mongoClient.getDB(repositoryDbName);
    DBCollection col = db.getCollection(AppConstants.MongoNames.PAGE_VISIT_COL_NAME);
    Assert.assertEquals(10005, col.count());
    Assert.assertFalse(Files.exists(Paths.get(dailyPartialDir, dailyDbName)));
  }
  public static void main(String[] args) throws UnknownHostException {
    MongoClient client = new MongoClient();
    DB db = client.getDB("course");
    DBCollection lines = db.getCollection("DotNotationTest");
    lines.drop();
    Random rand = new Random();

    // insert 10 lines with random start and end points
    for (int i = 0; i < 10; i++) {
      lines.insert(
          new BasicDBObject("_id", i)
              .append(
                  "start",
                  new BasicDBObject("x", rand.nextInt(90) + 10).append("y", rand.nextInt(90) + 10))
              .append("end", new BasicDBObject("x", rand.nextInt(90) + 10))
              .append("y", rand.nextInt(90) + 10));
    }

    // Filter by x coordinate using . notation
    QueryBuilder builder = QueryBuilder.start("start.x").greaterThan(50);

    // Dot notation is also available for field selection
    DBCursor cursor = lines.find(builder.get(), new BasicDBObject("start.y", true));
    try {
      while (cursor.hasNext()) {
        DBObject cur = cursor.next();
        System.out.println(cur);
      }
    } finally {
      cursor.close();
    }
  }
예제 #3
0
  @Override
  public String IngresarJson(String nombreDB, String json, int clienteId)
      throws UnknownHostException {
    // TODO Auto-generated method stub
    MongoClient mongoClient = new MongoClient("localhost", 27017);
    DB base = mongoClient.getDB(nombreDB);

    // Ya existe
    if (ExisteCliente(nombreDB, clienteId)) {
      //        	System.out.println("********************\n");
      //        	System.out.println("Ya existe cliente, error no se igresa el Json");
      //        	System.out.println("********************\n");
      return "Ya existe cliente, error no se igresa el Json";
    }

    // no existe el cliente
    DBCollection collection = base.getCollection("Json");
    BasicDBObject document = new BasicDBObject();
    document.put("id", clienteId);

    DBObject object = (DBObject) JSON.parse(json);
    document.put("json", object);
    // document.put("json",json);
    collection.insert(document);
    return "Ok";
  }
예제 #4
0
  /** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) */
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // TODO Auto-generated method stub
    // response.getWriter().append("Served at: ").append(request.getContextPath());
    MongoClientURI uri =
        new MongoClientURI("mongodb://*****:*****@ds019028.mlab.com:19028/asedb");
    MongoClient client = new MongoClient(uri);
    DB db = client.getDB(uri.getDatabase());
    DBCollection users = db.getCollection("UserRecords");
    BasicDBObject query = new BasicDBObject();

    String firstname = request.getParameter("FirstName");
    String lastname = request.getParameter("LastName");
    String email = request.getParameter("email");
    String password = request.getParameter("EnterPassword");
    String confpasswd = request.getParameter("ConfirmPassword");
    query.put("First Name", firstname);
    query.put("Last Name", lastname);
    query.put("Email", email);
    System.out.println(email);
    if (password == confpasswd) {
      query.put("Password", password);
    } else {

    }
    DBCursor docs = users.find(query);
    response.getWriter().write(docs.toArray().toString());

    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "GET");
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
    response.setHeader("Access-Control-Max-Age", "86400");
    System.out.println("Insert doget");
  }
예제 #5
0
 public static DB createDbMock() {
   DB db = mock(DB.class);
   MongoClient mongoClient = mock(MongoClient.class);
   when(mongoClient.getDB(Mockito.anyString())).thenReturn(db);
   MongoDBConnection.setMongoClient(mongoClient);
   return db;
 }
예제 #6
0
  @Override
  public void run() {
    MongoProfile profile = options.getProfile();

    MongoClient mongo = null;
    DBCursor cursor = null;
    try {
      mongo = new MongoClient(profile.getAddress(), profile.getCredentials());

      DB db = mongo.getDB(options.getDatabase());
      DBCollection col = db.getCollection(options.getCollection());
      cursor = col.find();

      while (cursor.hasNext()) {
        DBObject doc = cursor.next();

        Map<String, Object> m = convert(doc);
        pushPipe(new Row(m));
      }
    } catch (Throwable t) {
      slog.error("araqne logdb mongo: cannot run mongo.find", t);
    } finally {
      if (cursor != null) cursor.close();

      if (mongo != null) mongo.close();
    }
  }
  public static void main(String[] args) throws UnknownHostException {
    MongoClient client = new MongoClient(new ServerAddress("localhost", 27017));
    final DB db = client.getDB("course");

    Spark.get(
        new Route("/") {
          @Override
          public Object handle(Request request, Response response) {
            DBCollection users = db.getCollection("user");
            DBObject user = users.findOne();
            StringWriter writer = new StringWriter();
            Configuration configuration = new Configuration();
            configuration.setClassForTemplateLoading(
                HelloWorldMongoDBSparkFreemarkerStyle.class, "/");

            try {
              Template template = configuration.getTemplate("hello.ftl");
              template.process(user, writer);
            } catch (Exception e) {
              halt(100);
              e.printStackTrace();
            }

            return writer;
          }
        });
  }
예제 #8
0
 public ReceiveDataResource() throws UnknownHostException {
   super("Mongo_URI", "Mongo_DB");
   mongoClient = new MongoClient(new MongoClientURI(this.uri));
   siteDatabase = mongoClient.getDB(this.db);
   eventsDAO = new EventsDAO(siteDatabase);
   formDAO = new FormDAO(siteDatabase);
 }
예제 #9
0
  /**
   * @param userName
   * @param password
   * @return boolean Checks if provided username and password combination exists in database. If it
   *     does returns true, else returns false
   */
  public boolean userExists(String userName, String password) {
    boolean found = false;

    try {
      openConnection();

      DB db = mongoClient.getDB("userData");
      DBCollection coll1 = db.getCollection("users");
      DBCursor cursor1 =
          coll1
              .find(
                  new BasicDBObject("userName", userName), new BasicDBObject("userPass", password))
              .sort(new BasicDBObject("_id", -1))
              .limit(1);

      if (cursor1.hasNext()) {
        found = true;
      }

      close();
    } catch (UnknownHostException e) {
      e.printStackTrace();
    }

    return found;
  }
예제 #10
0
  public static Double connect(String s) {
    double score = 0;

    try {

      System.out.println("in mongo");
      // mongoClient = new MongoClient("localhost", 27017);
      // @SuppressWarnings("deprecation")
      DB db = mongoClient.getDB("rank");
      coll = db.getCollection("rankTable");
      while (true) {

        // System.out.println("SEARCH");
        // Scanner sc = new Scanner(System.in);
        // String m = sc.nextLine();
        BasicDBObject q = new BasicDBObject();
        q.put("path", s);
        DBCursor cursor = coll.find(q);

        while (cursor.hasNext()) {

          score = (double) cursor.next().get("score");
        }
      }

    } catch (Exception e) {
      System.err.println(e.getClass().getName() + ": " + e.getMessage());
    }
    // mongoClient.close();
    return score;
  }
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    StringBuilder buffer = new StringBuilder();
    BufferedReader reader = request.getReader();
    String line;
    while ((line = reader.readLine()) != null) {
      buffer.append(line);
    }
    String data = buffer.toString();
    System.out.println(data);

    JSONObject params = new JSONObject(data);
    String email = (String) params.get("email");
    String password = (String) params.get("password");

    MongoClientURI uri =
        new MongoClientURI("mongodb://*****:*****@ds011459.mlab.com:11459/farmville");
    MongoClient client = new MongoClient(uri);
    DB db = client.getDB(uri.getDatabase());
    DBCollection users = db.getCollection("logindetails");

    BasicDBObject newDocument = new BasicDBObject();
    newDocument.append("$set", new BasicDBObject().append("password", password));
    BasicDBObject searchQuery = new BasicDBObject().append("email", email);
    WriteResult result = users.update(searchQuery, newDocument);

    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST");
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
    response.setHeader("Access-Control-Max-Age", "86400");

    response.getWriter().write(result.toString());
  }
  // Steps:
  // 1. Install unlimited strength encryption jar files in jre/lib/security
  // (e.g. http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html)
  // 2. run kinit
  // 3. Set system properties, e.g.:
  //    -Djava.security.krb5.realm=10GEN.ME -Djavax.security.auth.useSubjectCredsOnly=false
  // -Djava.security.krb5.kdc=kdc.10gen.me
  // auth.login.defaultCallbackHandler=name of class that implements
  // javax.security.auth.callback.CallbackHandler
  // You may also need to define realms and domain_realm entries in your krb5.conf file (in /etc by
  // default)
  public static void main(String[] args) throws UnknownHostException, InterruptedException {
    // Set this property to avoid the default behavior where the program prompts on the command line
    // for username/password
    Security.setProperty("auth.login.defaultCallbackHandler", "DefaultSecurityCallbackHandler");

    String server = args[0];
    String user = args[1];
    String dbName = args[2];

    MongoClient mongo =
        new MongoClient(
            new MongoClientAuthority(
                new ServerAddress(server),
                new MongoClientCredentials(user, MongoClientCredentials.GSSAPI_MECHANISM)),
            new MongoClientOptions.Builder().socketKeepAlive(true).socketTimeout(30000).build());
    DB testDB = mongo.getDB(dbName);
    System.out.println("Find     one: " + testDB.getCollection("test").findOne());
    System.out.println("Count: " + testDB.getCollection("test").count());
    WriteResult writeResult = testDB.getCollection("test").insert(new BasicDBObject());
    System.out.println("Write result: " + writeResult);

    System.out.println();

    System.out.println("Count: " + testDB.getCollection("test").count());
  }
예제 #13
0
  /** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) */
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // TODO Auto-generated method stub
    // response.getWriter().append("Served at: ").append(request.getContextPath());

    MongoClientURI uri =
        new MongoClientURI("mongodb://*****:*****@ds037824.mongolab.com:37824/aseproject");
    MongoClient client = new MongoClient(uri);

    DB db = client.getDB(uri.getDatabase());
    DBCollection users = db.getCollection("users");
    BasicDBObject query = new BasicDBObject();
    query.put("name", request.getParameter("name"));
    query.put("password", request.getParameter("password"));
    DBCursor docs = users.find();
    response.getWriter().write(docs.toArray().toString());

    /*JSONObject obj=new JSONObject();
    obj.put("message", "Hello World");
    response.getWriter().write(obj.toString());
    */
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "GET");
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
    response.setHeader("Access-Control-Max-Age", "86400");
  }
  /** Connect the instance. */
  public synchronized MongoClient connect() {
    if (m == null) {
      Builder options = new MongoClientOptions.Builder();
      options.connectionsPerHost(maxConnections);
      options.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockMultiplier);

      try {

        // Connect to replica servers if given. Else the standard way to one server.
        if (replicaServers != null && replicaServers.size() > 0) {
          m = new MongoClient(replicaServers, options.build());
        } else {
          ServerAddress address = new ServerAddress(host, port);
          m = new MongoClient(address, options.build());
        }
        db = m.getDB(database);
        db.setWriteConcern(WriteConcern.SAFE);

        // Try to authenticate if configured.
        if (useAuth) {
          if (!db.authenticate(username, password.toCharArray())) {
            throw new RuntimeException(
                "Could not authenticate to database '"
                    + database
                    + "' with user '"
                    + username
                    + "'.");
          }
        }
      } catch (UnknownHostException e) {
        throw new RuntimeException("Cannot resolve host name for MongoDB", e);
      }
    }
    return m;
  }
예제 #15
0
 public static void main(String[] args) throws UnknownHostException {
   MongoClient mongo = new MongoClient("localhost", 27017);
   DB feederDB = mongo.getDB("feeder");
   DBCollection products = feederDB.getCollection("products");
   System.out.println(products.find().size());
   mongo.close();
 }
예제 #16
0
  /** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // TODO Auto-generated method stub
    MongoClientURI uri =
        new MongoClientURI("mongodb://*****:*****@ds047752.mlab.com:47752/ase_lab7");
    MongoClient client = new MongoClient(uri);

    DB db = client.getDB(uri.getDatabase());
    DBCollection users = db.getCollection("users");

    BasicDBObject query = new BasicDBObject().append("username", "Ram");
    query.put("name", "Ram"); // request.getParameter("name"));
    query.put("password", "password"); // request.getParameter("password"));
    BasicDBObject newDocument = new BasicDBObject();
    newDocument.put("name", "SreeRam");
    users.update(query, newDocument);

    DBCursor docs = users.find(query);
    response.getWriter().write(docs.toArray().toString());

    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "GET");
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
    response.setHeader("Access-Control-Max-Age", "86400");
  }
예제 #17
0
  public static void main(String[] args) throws UnknownHostException {
    MongoClient client = new MongoClient();
    DB db = client.getDB("course");
    DBCollection collection = db.getCollection("findCriteriaTest");
    collection.drop();

    for (int i = 0; i < 10; i++) {
      collection.insert(
          new BasicDBObject("x", new Random().nextInt(2)).append("y", new Random().nextInt(100)));
    }

    QueryBuilder builder = QueryBuilder.start("x").is(0).and("y").greaterThan(10).lessThan(90);
    // DBObject query = new BasicDBObject("x", 0).append("y", new BasicDBObject("$gt",
    // 10).append("$lt", 90));

    System.out.println("\nCount:");
    long count = collection.count(builder.get());
    System.out.println(count);

    System.out.println("\nFind all:");
    DBCursor cursor = collection.find(builder.get());
    try {
      while (cursor.hasNext()) {
        DBObject cur = cursor.next();
        System.out.println(cur);
      }
    } finally {
      cursor.close();
    }
  }
  public static void main(String[] args) throws IOException {
    DB db = null;
    try {
      cargarParametros();
      MongoClient mongoClient = new MongoClient();
      db = mongoClient.getDB(BaseDeDatos);
      // System.out.println("Connect to database successfully");

    } catch (Exception e) {
      System.err.println(e.getClass().getName() + ": " + e.getMessage());
    }
    DBCollection documentos = db.getCollection(ColeccionIndice);
    while (true) {
      BufferedReader lector = new BufferedReader(new InputStreamReader(System.in));
      String consulta = lector.readLine().toLowerCase();
      BasicDBObject palabra = new BasicDBObject("palabra", consulta);
      DBCursor cursor;
      cursor = documentos.find(palabra);
      if (cursor.count() == 0) {
        System.out.println("No se encuentra resultado");
      } else {
        int cantidad_respuestas = cursor.count();
        BasicDBObject respuesta = (BasicDBObject) cursor.one().get("documentos");
        for (int i = 0; i < respuesta.size(); i++) {

          System.out.println(respuesta.get("Documento-" + Integer.toString(i)));
        }
      }
    }
  }
예제 #19
0
  public static void main(String[] args) throws UnknownHostException {
    MongoClient client = new MongoClient();
    DB db = client.getDB("course");
    DBCollection lines = db.getCollection("dotNotationTest");
    lines.drop();
    Random rand = new Random();

    for (int i = 0; i < 10; i++) {
      lines.insert(
          new BasicDBObject("_id", i)
              .append(
                  "start",
                  new BasicDBObject("x", rand.nextInt(90) + 10).append("y", rand.nextInt(90) + 10))
              .append(
                  "end",
                  new BasicDBObject("x", rand.nextInt(90) + 10)
                      .append("y", rand.nextInt(90) + 10)));
    }

    QueryBuilder builder = QueryBuilder.start("start.x").greaterThan(50);

    DBCursor cursor =
        lines.find(builder.get(), new BasicDBObject("start.y", true).append("_id", false));

    try {
      while (cursor.hasNext()) {
        DBObject cur = cursor.next();
        System.out.println(cur);
      }
    } finally {
      cursor.close();
    }
  }
예제 #20
0
  public void inicializa() throws Exception {

    try {
      log.info("Inicializa el cliente MongoDB");
      String host = ApplicationConfiguration.getInstance().getProperty("mongo.host");
      if (StringUtils.isEmpty(host)) {
        throw new DocumentException("No está configurado el host");
      }
      String property = ApplicationConfiguration.getInstance().getProperty("mongo.port");
      if (StringUtils.isEmpty(property)) {
        throw new DocumentException("No está configurado el puerto");
      }
      int port = Integer.parseInt(property);
      String dbName = ApplicationConfiguration.getInstance().getProperty("mongo.data.base");
      if (StringUtils.isEmpty(dbName)) {
        throw new DocumentException("No está configurada la base de datos");
      }

      mongoClient = new MongoClient(host, port);
      dataBase = mongoClient.getDB(dbName);
    } catch (Exception e) {
      log.error("Error al iniciar el cliente: " + e.getMessage());
      e.printStackTrace();
      throw new DocumentException(e.getMessage());
    }
  }
예제 #21
0
  public static void main(String[] args) throws Exception {
    MongoClient mongoClient = new MongoClient("localhost", 27017);

    DB db = mongoClient.getDB("mydb");
    DBCollection coll = db.getCollection("collection");
    lanciaTest(coll);
  }
예제 #22
0
  public static void main(String[] args) throws UnknownHostException {
    System.out.println("Start Testing");

    MongoClient client = new MongoClient(new ServerAddress("192.168.0.14", 27017));
    DB db = client.getDB("course");
    DBCollection collection = db.getCollection("findTestFromJava");
    collection.drop();

    for (int i = 0; i < 10; i++) {
      collection.insert(new BasicDBObject("x", new Random().nextInt(100)));
    }
    System.out.println("Find one:");
    DBObject one = collection.findOne();
    System.out.println("one = " + one);
    System.out.println("\nFind all:");
    DBCursor cursor = collection.find();
    try {
      while (cursor.hasNext()) {
        DBObject cur = cursor.next();
        System.out.println("cursor = " + cur);
      }
    } finally {
      cursor.close();
    }
    System.out.println("\nFind Count:");
    long count = collection.count();
    System.out.println("count = " + count);
  }
예제 #23
0
  public static void main(String[] args) throws IOException {
    String term =
        JOptionPane.showInputDialog(
            "Welcome to our knock-off search engine! \nPlease enter a term to search:");
    while (term == null || term.isEmpty()) {
      term =
          JOptionPane.showInputDialog(
              "You didn't input anything! \nPlease enter a term to search: ");
    }
    MongoClient mongoClient = new MongoClient("localhost", 27017);

    System.out.println("Establishing connection...");

    // Get the connection.
    DB db = mongoClient.getDB("crawler");
    DBCollection table = db.getCollection("urlpages");

    System.out.println("Connected to MongoDB!");
    db.getCollection("pagerank").drop();

    Ranking ranker = new Ranking(db);
    ranker.link_analysis();
    ranker.TFIDF(term);

    run(term, db);

    JOptionPane.showMessageDialog(
        null,
        "Search is completed! \nPlease refer to 'C:\\data\\search_results.json' for the result.");
  }
예제 #24
0
 @Override
 public boolean save(String collectionName, DBObject queryData, DBObject saveData) {
   DB db = mongoClient.getDB(mongoDB);
   DBCollection coll = db.getCollection(collectionName);
   coll.update(queryData, saveData, true, false);
   return false;
 }
예제 #25
0
  public static void main(String[] args) throws Exception {

    // connect to the local database server
    MongoClient mongoClient = new MongoClient();

    // Authenticate - optional
    // boolean auth = db.authenticate("foo", "bar");

    // get db names
    for (String s : mongoClient.getDatabaseNames()) {
      System.out.println(s);
    }

    // get a db
    DB db = mongoClient.getDB("com_mongodb_MongoAdmin");

    // do an insert so that the db will really be created.  Calling getDB() doesn't really take any
    // action with the server
    db.getCollection("testcollection").insert(new BasicDBObject("i", 1));
    for (String s : mongoClient.getDatabaseNames()) {
      System.out.println(s);
    }

    // drop a database
    mongoClient.dropDatabase("com_mongodb_MongoAdmin");

    for (String s : mongoClient.getDatabaseNames()) {
      System.out.println(s);
    }
  }
예제 #26
0
파일: UserServlet.java 프로젝트: vyse8/Lab1
  /** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) */
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // TODO Auto-generated method stub

    // response.getWriter().append("Served at: ").append(request.getContextPath());
    // JSONObject object = new JSONObject();
    // object.put("message", "Hello World");
    // response.getWriter().write(object.toString());

    response.getWriter().write("Read Users<br /><br />");

    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST,GET,PUT,DELETE");
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
    response.setHeader("Access-Control-Max-Age", "86400");

    MongoClientURI uri =
        new MongoClientURI("mongodb://*****:*****@ds031611.mongolab.com:31611/testbeerdb");
    MongoClient client = new MongoClient(uri);

    DB db = client.getDB(uri.getDatabase());
    DBCollection songs = db.getCollection("users");

    DBCursor docs = songs.find();
    response.getWriter().write(docs.toArray().toString());

    doPost(request, response);
  }
예제 #27
0
  @Override
  public String ActualizarJson(String nombreDB, String json, int clienteId)
      throws UnknownHostException {
    // TODO Auto-generated method stub

    if (!ExisteCliente(nombreDB, clienteId)) {
      //        	System.out.println("********************\n");
      //        	System.out.println("No existe el cliente, no se puede actualizar");
      //        	System.out.println("********************\n");
      return "No existe el cliente, no se puede actualizar";
    }
    MongoClient mongoClient = new MongoClient("localhost", 27017);
    DB base = mongoClient.getDB(nombreDB);
    DBCollection collection = base.getCollection("Json");

    BasicDBObject document = new BasicDBObject();
    DBObject object = (DBObject) JSON.parse(json);
    document.put("id", clienteId);
    document.put("json", object);

    BasicDBObject query = new BasicDBObject().append("id", clienteId);

    collection.findAndModify(query, document);
    return "Cliente actualizado";
  }
예제 #28
0
  public static void main(String[] args) throws UnknownHostException {

    MongoClient client = new MongoClient();
    DB courseDB = client.getDB("course");
    DBCollection list = courseDB.getCollection("DotNotationTest");

    list.drop();

    Random random = new Random();

    for (int i = 0; i < 10; i++) {
      list.insert(
          new BasicDBObject("_id", i)
              .append(
                  "start",
                  new BasicDBObject("x", random.nextInt(2)).append("y", random.nextInt(90) + 10))
              .append(
                  "end",
                  new BasicDBObject("x", random.nextInt(2)).append("y", random.nextInt(90) + 10)));
    }

    DBCursor cursor =
        list.find().sort(new BasicDBObject("start.x", 1).append("start.y", -1)).skip(2).limit(10);

    try {
      while (cursor.hasNext()) {
        DBObject cur = cursor.next();
        System.out.println(cur);
      }
    } finally {
      cursor.close();
    }
  }
예제 #29
0
  @Override
  public String Json(String nombreDB, int clienteId) throws UnknownHostException, JSONException {
    // TODO Auto-generated method stub
    MongoClient mongoClient = new MongoClient("localhost", 27017);
    DB base = mongoClient.getDB(nombreDB);

    DBCollection collection = base.getCollection("Json");
    BasicDBObject query = new BasicDBObject();
    query.put("id", clienteId);
    DBCursor cursor = collection.find(query);

    if (cursor.size() == 0) {
      //        	System.out.println("********************\n");
      //        	System.out.println("No existe el cliente, no se puede ingresar json");
      //        	System.out.println("********************\n");

      return "No existe el cliente, no se puede ingresar json";
    }
    // Existe el cliente

    DBObject objeto = (DBObject) cursor.next();

    DBObject json = (DBObject) objeto.get("json");
    //  DBObject j = JSON.parse(json.toString());
    JSONObject aj = new JSONObject(json.toString());

    return aj.toString();
  }
예제 #30
0
  public EMSMongoClient() throws IOException {
    Properties config = new Properties();

    InputStream in = this.getClass().getClassLoader().getResourceAsStream("config.properties");

    config.load(in);

    MongoClient client;

    List<ServerAddress> serverAddresses =
        Arrays.asList(
            new ServerAddress(
                config.getProperty("mongo_host"),
                Integer.parseInt(config.getProperty("mongo_port"))));

    if (config.containsKey("mongo_user") && config.containsKey("mongo_password")) {
      MongoCredential credential =
          MongoCredential.createMongoCRCredential(
              config.getProperty("mongo_user"),
              config.getProperty("mongo_db"),
              config.getProperty("mongo_password").toCharArray());

      client = new MongoClient(serverAddresses, Arrays.asList(credential));
    } else {
      client = new MongoClient(serverAddresses);
    }

    DB db = client.getDB(config.getProperty("mongo_db"));

    this.collection = db.getCollection("sessions");
  }