Example usage for com.mongodb Mongo getDB

List of usage examples for com.mongodb Mongo getDB

Introduction

In this page you can find the example usage for com.mongodb Mongo getDB.

Prototype

@Deprecated 
public DB getDB(final String dbName) 

Source Link

Document

Gets a database object.

Usage

From source file:com.mycompany.Farmerama.LoginCheckUserToDb.java

public LoginCheckUserToDb() {
    Mongo mongo = new Mongo("localhost", 27017);
    db = mongo.getDB("accounts");
    account = db.getCollection("account");
}

From source file:com.mycompany.Farmerama.PhotoAlbum.java

public PhotoAlbum(String username) {
    Mongo mongo = new Mongo("localhost", 27017);
    db = mongo.getDB("album");
    photo = db.getCollection(username);//  w  ww.ja v a2  s . c  om
    //initComponents();
    this.userName = username;
}

From source file:com.mycompany.Farmerama.SignUpVal.java

public SignUpVal() {
    Mongo mongo = new Mongo("localhost", 27017);
    db = mongo.getDB("accounts");
    account = db.getCollection("account");
}

From source file:com.mythesis.userbehaviouranalysis.ProfileAnalysis.java

License:Apache License

/**
 * finds the profiles that match user's interests given his web history
 * @param userID the user's id/*from www. j av a  2  s  .co m*/
 * @param history the user's web history
 * @param input a txt file that contains the necessary parameters
 */
public void perform(String userID, String[] history, File input) {

    System.out.println("total urls = " + history.length);
    //default parameters
    //number of random queries for each profile
    int numQueriesSuggestion = 5;
    //number of random webpages per query to suggest - total number of suggestions = 
    // numQueriesSuggestion*pagesPerQuerySuggestion
    int pagesPerQuerySuggestion = 1;
    //number of random queries to return as examples for alternatives profiles
    int numQueriesExample = 2;

    //we get the current date/time
    DateTime current = new DateTime();
    DateTimeFormatter fmt = DateTimeFormat.forPattern("dd/MM/yyyy HH:mm");
    String timestamp = fmt.print(current);

    //update user info - i'll store the results when i'll perform the last analysis
    Mongo mongo = new Mongo("localhost", 27017);
    DB db = mongo.getDB("profileAnalysis");
    DBCollection userinfo = db.getCollection("userinfo");
    BasicDBObject newDocument = new BasicDBObject();
    newDocument.put("$set", new BasicDBObject().append("timestamp", timestamp));
    BasicDBObject searchQuery = new BasicDBObject();
    searchQuery.put("userID", userID);
    userinfo.update(searchQuery, newDocument, true, false);

    //read the neccessary parameters
    Utils utils = new Utils();
    utils.readInput(input);
    HashMap<String, ArrayList<String>> wordvectors = utils.wordvectors;
    HashMap<String, String> crawlerOutputPaths = utils.crawlerOutputPaths;

    //get the urls' content
    ArrayList<String> webpages = new ArrayList<>();
    ArrayList<String> urls = new ArrayList<>();
    for (int i = 0; i < history.length; i++) {
        WebParser pageParser = new WebParser(history[i]);
        pageParser.parse();
        String content = pageParser.getContent();
        if ("".equals(content) || content == null)
            continue;
        webpages.add(content);
        urls.add(history[i]);
    }

    //calculate the urls' scores
    HashMap<String, double[]> historyScores = new HashMap<>();
    String[] webpagesArr = new String[webpages.size()];
    webpagesArr = webpages.toArray(webpagesArr);
    String[] urlsArr = new String[urls.size()];
    urlsArr = urls.toArray(urlsArr);
    for (String profile : wordvectors.keySet()) {
        Scorer scorer = new Scorer(webpagesArr, urlsArr, wordvectors.get(profile));
        double[] semanticScores = scorer.getSemanticScores();
        double[] relevanceScores = scorer.getRelevanceScores();
        double[] confidenceScores = scorer.getConfidenceScores();
        double[] scores = scoreFormula(semanticScores, relevanceScores, confidenceScores);
        historyScores.put(profile, scores);
    }

    //find the maximum score of every url and get summation of the scores for each profile
    HashMap<String, Double> userProfilesScore = new HashMap<>();
    for (int i = 0; i < webpages.size(); i++) {
        double max = 0.0;
        String info = "undefined";
        for (String profile : historyScores.keySet()) {
            if (historyScores.get(profile)[i] > max) {
                max = historyScores.get(profile)[i];
                info = profile;
            }
        }
        if (!"undefined".equals(info)) {
            Double prevscore = userProfilesScore.get(info);
            userProfilesScore.put(info, (prevscore == null) ? max : prevscore + max);
        }
    }

    //find which profile level has maximum score e.g. if football/level=0 score is greater
    //than football/level=1 score then the user is better described as a football/level=0 user
    HashMap<String, Double> userProfileScores = new HashMap<>();
    HashMap<String, String> userProfileLevels = new HashMap<>();
    for (String s : userProfilesScore.keySet()) {
        String[] info = s.split("/");
        Double prevscore = userProfileScores.get(info[0] + "/" + info[1] + "/");
        if (prevscore == null) {
            userProfileScores.put(info[0] + "/" + info[1] + "/", userProfilesScore.get(s));
            userProfileLevels.put(info[0] + "/" + info[1] + "/", info[2]);
        } else if (userProfilesScore.get(s) > prevscore) {
            userProfileScores.put(info[0] + "/" + info[1] + "/", userProfilesScore.get(s));
            userProfileLevels.put(info[0] + "/" + info[1] + "/", info[2]);
        }
    }

    //put the final profiles together in this simple form: domain/profile/level of expertise and rank them
    Double totalScore = 0.0;
    for (String s : userProfileScores.keySet())
        totalScore += userProfileScores.get(s);

    Map<String, Double> userProfiles = new HashMap<>();
    for (String s : userProfileLevels.keySet())
        userProfiles.put(s + userProfileLevels.get(s), round(userProfileScores.get(s) * 100 / totalScore, 2));

    userProfiles = sortByValue(userProfiles);

    //find page suggestions for every profile
    HashMap<String, ArrayList<String>> pageSuggestions = new HashMap<>();
    for (String profile : userProfiles.keySet()) {
        String path = crawlerOutputPaths.get(profile);
        ArrayList<String> suggestions = getSuggestions(path, numQueriesSuggestion, pagesPerQuerySuggestion,
                history);
        pageSuggestions.put(profile, suggestions);
    }

    //find alternative profiles for every profile and representative queries
    HashMap<String, HashMap<String, ArrayList<String>>> alternativeProfiles = new HashMap<>();
    for (String userProfile : userProfiles.keySet()) {
        String[] userProfileInfo = userProfile.split("/");
        HashMap<String, ArrayList<String>> profileQueries = new HashMap<>();
        for (String profile : wordvectors.keySet()) {
            String[] profileInfo = profile.split("/");
            if (profileInfo[0].equals(userProfileInfo[0]) && profileInfo[1].equals(userProfileInfo[1])
                    && !profileInfo[2].equals(userProfileInfo[2])) {
                String path = crawlerOutputPaths.get(profile);
                ArrayList<String> queries = getQueries(path, numQueriesExample);
                for (int i = 0; i < queries.size(); i++) {
                    String query = queries.get(i);
                    queries.set(i, query.substring(query.lastIndexOf("\\") + 1).replace("-query", "")
                            .replace("+", " "));
                }
                profileQueries.put(profile, queries);
            }
        }
        alternativeProfiles.put(userProfile, profileQueries);
    }

    //prepare JSON response
    JSONObject response = new JSONObject();
    response.put("userID", userID);
    response.put("timestamp", timestamp);
    JSONArray list = new JSONArray();

    for (String profile : userProfiles.keySet()) {
        JSONObject profileInfo = new JSONObject();
        profileInfo.put("profile", profile);
        profileInfo.put("score", userProfiles.get(profile));

        JSONArray temp = new JSONArray();
        ArrayList<String> suggestions = pageSuggestions.get(profile);
        for (String s : suggestions)
            temp.add(s);
        profileInfo.put("suggestions", temp);

        JSONArray alternativesArray = new JSONArray();
        for (String s : alternativeProfiles.get(profile).keySet()) {
            JSONObject alternativeInfo = new JSONObject();
            alternativeInfo.put("alternative", s);
            ArrayList<String> queries = alternativeProfiles.get(profile).get(s);
            JSONArray queriesArray = new JSONArray();
            for (String str : queries) {
                queriesArray.add(str);
            }
            alternativeInfo.put("queries", queriesArray);
            alternativesArray.add(alternativeInfo);
        }

        profileInfo.put("alternatives", alternativesArray);
        list.add(profileInfo);
    }
    response.put("profiles", list);
    System.out.println("JSON response is ready: " + response);

    //delete previous analysis and store results
    DBCollection collection = db.getCollection("history");
    BasicDBObject previous = new BasicDBObject();
    previous.put("userID", userID);
    collection.remove(previous);
    DBObject dbObject = (DBObject) JSON.parse(response.toString());
    collection.insert(dbObject);
    System.out.println("I saved the analysis...");

}

From source file:com.mythesis.userbehaviouranalysis.ProfileAnalysis.java

License:Apache License

/**
 * a method that stores the query that has been suggested by the user
 * @param crawlerOutputPath SWebRank output directory used to check if a relevant query already exists
 * @param profile the query's relevant profile
 * @param query the given query//from   www  .j  av a  2s. c o m
 */
public void storeQuery(String crawlerOutputPath, String profile, String query) {

    System.out.println(crawlerOutputPath);
    System.out.println(profile);
    System.out.println(query);
    //Find output paths
    File root = new File(crawlerOutputPath);
    File[] contents = root.listFiles();
    List<String> sWebRanklevels = new ArrayList<>();
    for (File f : contents) {
        if (f.getAbsolutePath().contains("level"))
            sWebRanklevels.add(f.getAbsolutePath());
    }

    //Find all query paths
    List<String> queries = new ArrayList<>();
    for (String s : sWebRanklevels) {
        File level = new File(s);
        File[] queriesFiles = level.listFiles();
        for (File f : queriesFiles) {
            if (!f.getAbsolutePath().contains("txt")) {
                String str = f.getAbsolutePath();
                queries.add(str.substring(str.lastIndexOf("\\") + 1).replace("-query", "").replace("+", " "));
            }
        }
    }

    //check if a relevant query already exists - I use Jaro-Winkler distance
    query = query.trim().replaceAll(" +", " ");
    for (String q : queries) {
        JaroWinklerDistance jwd = new JaroWinklerDistance();
        double distance = jwd.getDistance(q, query);
        if (distance > 0.9) { // threshold = 0.9
            return;
        }
    }

    Mongo mongo = new Mongo("localhost", 27017);
    DB db = mongo.getDB("profileAnalysis");

    DBCollection DBqueries = db.getCollection("newQueries");
    BasicDBObject searchQuery = new BasicDBObject();
    searchQuery.put("profile", profile);
    DBObject document = DBqueries.findOne(searchQuery);
    boolean flag = false;

    //check if a relevant query exists in the database - I use Jaro-Winkler distance
    if (document != null) {
        flag = true;
        BasicDBList storedQueries = (BasicDBList) document.get("queries");
        for (Object quer : storedQueries) {
            JaroWinklerDistance jwd = new JaroWinklerDistance();
            double distance = jwd.getDistance((String) quer, query);
            if (distance > 0.9) { // threshold = 0.9
                return;
            }
        }
    }

    //if document already exists add the new query
    if (flag) {
        DBqueries.update(searchQuery, new BasicDBObject("$push", new BasicDBObject("queries", query)));
    } else { //otherwise create a new document
        BasicDBList dbl = new BasicDBList();
        dbl.add(query);
        BasicDBObject entry = new BasicDBObject("profile", profile).append("queries", dbl);
        DBqueries.insert(entry);
    }
}

From source file:com.mythesis.userbehaviouranalysis.RequestServlet.java

License:Apache License

/**
 * Handles the HTTP <code>GET</code> method.
 * @param request servlet request//w  w  w.j a v  a 2 s .  c om
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    String userPath = request.getServletPath();
    String params = request.getQueryString().split("=")[1];
    System.out.println("I'm going to send the analysis to " + request.getQueryString());

    if (userPath.equals("/analysis")) {
        Mongo mongo = new Mongo("localhost", 27017);
        DB db = mongo.getDB("profileAnalysis");
        DBCollection userinfo = db.getCollection("history");
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.put("userID", params);
        DBCursor cursor = userinfo.find(searchQuery);
        if (cursor.hasNext()) {
            String entry = cursor.next().toString();
            System.out.println(entry);
            response.setHeader("Access-Control-Request-Method", "GET");
            response.setContentType("application/json");
            response.getWriter().write(entry);
        }
    }

}

From source file:com.mythesis.userbehaviouranalysis.RequestServlet.java

License:Apache License

/**
 * Handles the HTTP <code>POST</code> method.
 * @param request servlet request//from   www.  j av  a 2 s.  co m
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    String userPath = request.getServletPath();
    File input = new File("D://UserBehaviourAnalysisInput.txt");
    ProfileAnalysis analysis = new ProfileAnalysis();
    switch (userPath) {
    // if history is sent
    case "/history":
        String id = request.getParameter("userID");
        String[] urls = request.getParameter("urls").split(",");

        Mongo mongo = new Mongo("localhost", 27017);
        DB db = mongo.getDB("profileAnalysis");
        DBCollection userinfo = db.getCollection("userinfo");
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.put("userID", id);
        DBCursor cursor = userinfo.find(searchQuery);
        if (cursor.hasNext()) {
            DateTime current = new DateTime();
            SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy HH:mm");
            DBObject entry = cursor.next();
            String check = (String) entry.get("timestamp");
            Date temp = null;
            try {
                temp = format.parse(check);
            } catch (ParseException ex) {
                Logger.getLogger(RequestServlet.class.getName()).log(Level.SEVERE, null, ex);
            }
            DateTime previous = new DateTime(temp);
            System.out.println("last history analysis on: " + previous);
            System.out.println("current date/time: " + current);
            Duration duration = new Duration(previous, current);
            if (duration.getStandardHours() < 24)
                break;
        }
        analysis.perform(id, urls, input);
        break;
    // if query is sent    
    case "/query":
        try {
            JSONObject data = new JSONObject(request.getParameter("data"));
            Iterator it = data.keys();

            ArrayList<String> profiles = new ArrayList<>();
            ArrayList<String> queries = new ArrayList<>();
            while (it.hasNext()) {
                String key = (String) it.next();
                profiles.add(key);
                queries.add((String) data.get(key));
            }
            analysis.storeQueries(profiles, queries, input);
        } catch (JSONException ex) {
            Logger.getLogger(RequestServlet.class.getName()).log(Level.SEVERE, null, ex);
        }
        break;
    }
}

From source file:com.novemberain.quartz.mongodb.MongoDBJobStore.java

License:Open Source License

private DB selectDatabase(Mongo mongo) {
    DB db = mongo.getDB(dbName);
    // MongoDB defaults are insane, set a reasonable write concern explicitly. MK.
    // But we would be insane not to override this when writing lock records. LB.
    db.setWriteConcern(WriteConcern.JOURNALED);
    if (username != null) {
        if (authDbName != null) {
            // authentificating to db which gives access to all other dbs (role - readWriteAnyDatabase)
            // by default in mongo it should be "admin"
            DB authDb = mongo.getDB(authDbName);
            authDb.authenticate(username, password.toCharArray());
        } else {//from  www .jav a 2s. c om
            db.authenticate(username, password.toCharArray());
        }

    }
    return db;
}

From source file:com.opencanarias.mset.internal.benchmark.repository.cdo.mongodb.JVMMongodbCDOModelRepository.java

License:Open Source License

@Override
protected void doClean() {
    try {/* w w w.  j a v a  2  s.  co  m*/
        Mongo mongo = new Mongo(MONGO_URI);
        DB db = mongo.getDB(getRepositoryName());
        db.dropDatabase();
    } catch (UnknownHostException e) {
        fireRepositoryEvent(EventLevel.ERROR, "Error while cleaning MongoDB", e);
        logger.error("Error while cleaning MongoDB", e);
    }
}

From source file:com.ovea.mongodb.EmbeddedMongoDB.java

License:Apache License

public static EmbeddedMongoDB addRunning(int port, String username, String password) {
    try {/*from   w  w w  . ja  v  a2  s.co  m*/
        Mongo mongo = null;
        File path = null;
        try {
            mongo = new Mongo("localhost", port);
            DB db = mongo.getDB("admin");
            if (username != null && password != null)
                db.authenticate(username, password.toCharArray());
            BSONObject obj = (BSONObject) db.command("getCmdLineOpts").get("parsed");
            if (obj != null) {
                String val = (String) obj.get("dbpath");
                if (val != null)
                    path = new File(val);
            }
        } finally {
            if (mongo != null)
                mongo.close();
        }
        return add(new FileEntry(port, -1, path));
    } catch (UnknownHostException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}