Example usage for com.mongodb BasicDBObject getString

List of usage examples for com.mongodb BasicDBObject getString

Introduction

In this page you can find the example usage for com.mongodb BasicDBObject getString.

Prototype

public String getString(final String key) 

Source Link

Document

Returns the value of a field as a string

Usage

From source file:org.opencb.cellbase.mongodb.db.regulatory.TfbsMongoDBAdaptor.java

License:Apache License

@Override
public List<QueryResult> getAllByTargetGeneIdList(List<String> targetGeneIdList, QueryOptions options) {
    //        DBCollection coreMongoDBCollection = db.getCollection("gene");

    List<DBObject[]> commandList = new ArrayList<>();
    for (String targetGeneId : targetGeneIdList) {
        DBObject[] commands = new DBObject[3];
        DBObject match = new BasicDBObject("$match", new BasicDBObject("transcripts.xrefs.id", targetGeneId));
        DBObject unwind = new BasicDBObject("$unwind", "$transcripts");
        BasicDBObject projectObj = new BasicDBObject("_id", 0);
        projectObj.append("transcripts.id", 1);
        projectObj.append("transcripts.tfbs", 1);
        DBObject project = new BasicDBObject("$project", projectObj);
        commands[0] = match;/*from w ww  .j  a va 2s  .  com*/
        commands[1] = unwind;
        commands[2] = project;
        commandList.add(commands);
    }

    //        List<QueryResult> queryResults = executeAggregationList(targetGeneIdList, commandList, options, coreMongoDBCollection);
    List<QueryResult> queryResults = new ArrayList<>();
    for (int i = 0; i < targetGeneIdList.size(); i++) {
        String targetGeneId = targetGeneIdList.get(0);
        //            QueryResult queryResult = queryResults.get(0);
        QueryResult queryResult = new QueryResult();
        BasicDBList list = (BasicDBList) queryResult.getResult();

        for (int j = 0; j < list.size(); j++) {
            BasicDBObject gene = (BasicDBObject) list.get(j);
            BasicDBObject transcript = (BasicDBObject) gene.get("transcripts");
            String transcriptId = transcript.getString("id");
            if (transcriptId.toUpperCase().equals(targetGeneId)) {
                BasicDBList tfbs = (BasicDBList) transcript.get("tfbs");
                queryResult.setResult(tfbs);
                break;
            }
        }
    }

    return queryResults;
}

From source file:org.opencb.cellbase.server.ws.feature.GeneWSServer.java

License:Apache License

@GET
@Path("/{geneId}/snp")
@ApiOperation(httpMethod = "GET", value = "Get all SNPs within the specified gene(s)")
public Response getSNPByGeneId(@PathParam("geneId") String query) {
    try {/* ww w.ja  v  a 2  s .  c  o  m*/
        parseQueryParams();

        GeneDBAdaptor geneDBAdaptor = dbAdaptorFactory.getGeneDBAdaptor(this.species, this.assembly);
        VariationDBAdaptor variationDBAdaptor = dbAdaptorFactory.getVariationDBAdaptor(this.species,
                this.assembly);

        List<QueryResult> qrList;
        if (queryOptions.containsKey("count") && queryOptions.getBoolean("count")) {
            queryOptions.remove("count");
            qrList = geneDBAdaptor.getAllByIdList(Splitter.on(",").splitToList(query), queryOptions);
            queryOptions.put("count", true);
        } else {
            qrList = geneDBAdaptor.getAllByIdList(Splitter.on(",").splitToList(query), queryOptions);
        }

        List<QueryResult> queryResults = new ArrayList<>();
        for (QueryResult qr : qrList) {
            QueryResult queryResult = new QueryResult();
            queryResult.setId(qr.getId());

            // FIXME MongoDB code should not be here
            BasicDBObject gene = (BasicDBObject) qr.getResult().get(0);
            QueryResult variationQueryResult = variationDBAdaptor.getAllByRegion(gene.getString("chromosome"),
                    gene.getInt("start"), gene.getInt("end"), queryOptions);

            queryResult.setNumResults(variationQueryResult.getNumResults());
            queryResult.setResult(variationQueryResult.getResult());
            queryResults.add(queryResult);
        }

        return createOkResponse(queryResults);
    } catch (Exception e) {
        return createErrorResponse(e);
    }
}

From source file:org.opendaylight.controller.samples.onftappingapp.MatchCriteria.java

License:Apache License

public MatchCriteria(DBObject matchCriteriaObj) {

    this.setName((String) matchCriteriaObj.get("name"));
    this.setReferenceCount((long) matchCriteriaObj.get("refCount"));

    ObjectId oid = (ObjectId) matchCriteriaObj.get("_id");
    this.setObjectId(oid.toString());
    this.setEnabled((Boolean) matchCriteriaObj.get("enabled"));
    this.setReflexive((Boolean) matchCriteriaObj.get("reflexive"));
    this.setPriority((int) matchCriteriaObj.get("priority"));

    BasicDBList mfList = (BasicDBList) matchCriteriaObj.get("matchFields");
    BasicDBObject[] mfArray = mfList.toArray(new BasicDBObject[0]);
    for (BasicDBObject dbObj : mfArray) {
        MatchField matchField = new MatchField();
        matchField.setType(dbObj.getString("type"));
        matchField.setValue(dbObj.getString("value"));
        // Add the match field to the match criteria
        this.addMatchField(matchField);
    }//w w w . j  a va2 s  .  c o  m
}

From source file:org.opendaylight.controller.samples.onftappingapp.RewriteParams.java

License:Apache License

public RewriteParams(BasicDBObject objDoc) throws UnknownHostException {
    this.setName(objDoc.getString("name"));
    this.setIPAddress((String) objDoc.get("IPAddress"));
    this.setMacAddr((String) objDoc.getString("MACAddress"));
    this.setVlanId((int) objDoc.getInt("VLAN_ID"));
}

From source file:org.openhab.persistence.mongodb.internal.MongoDBPersistenceService.java

License:Open Source License

@Override
public Iterable<HistoricItem> query(FilterCriteria filter) {
    if (!initialized) {
        return Collections.emptyList();
    }/*from ww  w.  j a  v  a 2  s  .  c  o m*/

    if (!isConnected()) {
        connectToDatabase();
    }

    if (!isConnected()) {
        return Collections.emptyList();
    }

    String name = filter.getItemName();
    Item item = getItem(name);

    List<HistoricItem> items = new ArrayList<HistoricItem>();
    DBObject query = new BasicDBObject();
    if (filter.getItemName() != null) {
        query.put(FIELD_ITEM, filter.getItemName());
    }
    if (filter.getState() != null && filter.getOperator() != null) {
        String op = convertOperator(filter.getOperator());
        Object value = convertValue(filter.getState());
        query.put(FIELD_VALUE, new BasicDBObject(op, value));
    }
    if (filter.getBeginDate() != null) {
        query.put(FIELD_TIMESTAMP, new BasicDBObject("$gte", filter.getBeginDate()));
    }
    if (filter.getEndDate() != null) {
        query.put(FIELD_TIMESTAMP, new BasicDBObject("$lte", filter.getEndDate()));
    }

    Integer sortDir = (filter.getOrdering() == Ordering.ASCENDING) ? 1 : -1;
    DBCursor cursor = this.mongoCollection.find(query).sort(new BasicDBObject(FIELD_TIMESTAMP, sortDir))
            .skip(filter.getPageNumber() * filter.getPageSize()).limit(filter.getPageSize());

    while (cursor.hasNext()) {
        BasicDBObject obj = (BasicDBObject) cursor.next();

        final State state;
        if (item instanceof NumberItem) {
            state = new DecimalType(obj.getDouble(FIELD_VALUE));
        } else if (item instanceof DimmerItem) {
            state = new PercentType(obj.getInt(FIELD_VALUE));
        } else if (item instanceof SwitchItem) {
            state = OnOffType.valueOf(obj.getString(FIELD_VALUE));
        } else if (item instanceof ContactItem) {
            state = OpenClosedType.valueOf(obj.getString(FIELD_VALUE));
        } else if (item instanceof RollershutterItem) {
            state = new PercentType(obj.getInt(FIELD_VALUE));
        } else if (item instanceof ColorItem) {
            state = new HSBType(obj.getString(FIELD_VALUE));
        } else if (item instanceof DateTimeItem) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(obj.getDate(FIELD_VALUE));
            state = new DateTimeType(cal);
        } else {
            state = new StringType(obj.getString(FIELD_VALUE));
        }

        items.add(new MongoDBItem(name, state, obj.getDate(FIELD_TIMESTAMP)));
    }

    return items;
}

From source file:org.ossmeter.platform.mining.msr14.Extractor.java

License:Open Source License

public static void main(String[] args) throws Exception {
    long start = System.currentTimeMillis();

    Mongo msrMongo = new Mongo(new ServerAddress("localhost", 1234)); // GitHub challenge data
    Mongo bioMongo = new Mongo(new ServerAddress("localhost", 12345));// Extracted data

    // Create indexes
    Biodiversity bio = new Biodiversity(bioMongo.getDB("biodiversity"));
    bio.setClearPongoCacheOnSync(true);//w ww .j  ava2 s.  co  m
    bioMongo.getDB("biodiversity").getCollection("users").ensureIndex(new BasicDBObject("login", 1));

    BasicDBObject index = new BasicDBObject();
    index.put("name", 1);
    index.put("ownerName", 1);
    bioMongo.getDB("biodiversity").getCollection("projects").ensureIndex(index);

    index = new BasicDBObject();
    index.put("projectName", 1);
    index.put("projectOwner", 1);
    bioMongo.getDB("biodiversity").getCollection("projectMemberships").ensureIndex(index);

    index = new BasicDBObject();
    index.put("projectName", 1);
    index.put("userName", 1);
    bioMongo.getDB("biodiversity").getCollection("projectMemberships").ensureIndex(index);

    bioMongo.getDB("biodiversity").getCollection("projectMemberships")
            .ensureIndex(new BasicDBObject("userName", 1));

    DB msrDb = msrMongo.getDB("msr14");

    //      #1 User extraction
    System.out.println("Extracting users...");
    DBCursor cursor = msrDb.getCollection("users").find();
    cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    Iterator<DBObject> it = cursor.iterator();

    int count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         User user = new User();
    //         user.setGhId(obj.getString("id"));
    //         user.setLogin(obj.getString("login"));
    //         user.setLocation(obj.getString("location"));
    //         user.setPublicRepos(obj.getInt("public_repos", 0));
    //         user.setJoinedDate(obj.getString("created_at"));
    //         user.setFollowerCount(obj.getInt("followers", 0));
    //         user.setFollowingCount(obj.getInt("following", 0));
    //         user.setPublicGists(obj.getInt("public_gists", 0));
    //         
    //         bio.getUsers().add(user);
    //         
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      
    ////      #1.2 Project extraction
    //      System.out.println("Extracting projects...");
    //      cursor = msrDb.getCollection("repos").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         Project project = new Project();
    //         project.setName(obj.getString("name"));
    //         project.setGhId(obj.getString("id"));
    //         project.setCreatedAt(obj.getString("created_at"));
    //         project.setSize(obj.getInt("size", 0));
    //         project.setWatchersCount(obj.getInt("watchers",0));
    //         project.setWatchersCount2(obj.getInt("watchers_count",0));
    //         project.setLanguage(obj.getString("language"));
    //         project.setForks(obj.getInt("forks", 0));
    //         project.setForksCount(obj.getInt("forks_count", 0));
    //         project.setOpenIssues(obj.getInt("open_issues",0));
    //         project.setOpenIssuesCount(obj.getInt("open_issues_count",0));
    //         project.setOpenIssues(obj.getInt("open_issues",0));
    //         project.setNetworkCount(obj.getInt("network_count", 0));
    //         
    //         BasicDBObject ownerObj = (BasicDBObject) obj.get("owner");
    //         User owner = null;
    //         if (ownerObj != null) {
    //            owner = bio.getUsers().findOne(User.LOGIN.eq(ownerObj.getString("login")));
    //            if (owner !=null) {
    //               project.setOwner(owner);
    //               project.setOwnerName(owner.getLogin());
    //            }
    //         }
    //         bio.getProjects().add(project);
    //         
    //         if (owner != null) { // This comes here as to reference the project, we need to have added to the project list first
    //            ProjectMembership pm = getProjectMembership(bio, owner, project);
    //            pm.setOwner(true);
    //         }
    //         
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      
    //      System.exit(0);

    ////      #2 Follower/following extraction
    //      System.out.println("Extracting followers...");
    //      cursor = msrDb.getCollection("followers").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         String followerLogin = obj.getString("login");
    //         String followedLogin = obj.getString("follows");
    //         
    //         User follower = bio.getUsers().findOne(User.LOGIN.eq(followerLogin));
    //         User followed = bio.getUsers().findOne(User.LOGIN.eq(followedLogin));
    //         
    //         if (follower != null && followed != null) {
    //            follower.getFollowing().add(followed);
    //            followed.getFollowers().add(follower);
    //         } else{
    ////            System.err.println("Follower or followed is null. Follower: " +follower + ". followed: " + followed);
    //         }
    //         if (follower != null) follower.setFollowingCount(follower.getFollowingCount()+1);
    //         if (followed != null) followed.setFollowerCount(followed.getFollowerCount()+1);
    //         
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      
    //      System.exit(0);

    System.out.println("Clearing ProjectMembership commit data");

    for (ProjectMembership pm : bio.getProjectMemberships()) {
        pm.setCommitCount(0);
        pm.setCommitTotalChanges(0);
        pm.setCommitAdditions(0);
        pm.setCommitDeletions(0);
        pm.setCommitsAsAuthor(0);
        pm.setCommitsAsCommitter(0);
        pm.setCommitTotalFiles(0);
        pm.setAverageFilesPerCommit(0);
        pm.getCommitTimes().clear();
    }
    bio.sync();
    System.out.println("cleared.");

    //      #3 Commits
    System.out.println("Extracting commits...");
    cursor = msrDb.getCollection("commits").find();
    cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    it = cursor.iterator();

    count = 0;
    while (it.hasNext()) {
        BasicDBObject obj = (BasicDBObject) it.next();

        // Author and committer
        BasicDBObject commitAuthor = (BasicDBObject) obj.get("author");
        BasicDBObject commitCommitter = (BasicDBObject) obj.get("committer");

        String authorLogin = "";
        if (commitAuthor != null)
            authorLogin = commitAuthor.getString("login");
        String committerLogin = "";
        if (commitCommitter != null)
            committerLogin = commitCommitter.getString("login");

        // Stats
        BasicDBObject stats = (BasicDBObject) obj.get("stats");
        if (stats == null)
            stats = new BasicDBObject(); // Create a new one so we can get zeroed values
        int total = stats.getInt("total", 0);
        int additions = stats.getInt("additions", 0);
        int deletions = stats.getInt("deletions", 0);

        String commitDate = ((BasicDBObject) ((BasicDBObject) obj.get("commit")).get("author"))
                .getString("date");

        BasicDBList files = (BasicDBList) obj.get("files");
        String[] url = convertUrlIntoProjectNameAndOwner(obj.getString("url"));

        ProjectMembership authorPm = null;
        ProjectMembership committerPm = null;

        if (authorLogin != null) {
            authorPm = getProjectMembership(bio, authorLogin, url[1], url[0]);
            authorPm.setCommitCount(authorPm.getCommitCount() + 1);
            authorPm.setCommitTotalChanges(authorPm.getCommitTotalChanges() + total);
            authorPm.setCommitAdditions(authorPm.getCommitAdditions() + additions);
            authorPm.setCommitDeletions(authorPm.getCommitDeletions() + deletions);
            authorPm.setCommitsAsAuthor(authorPm.getCommitsAsAuthor() + 1);
            if (files != null)
                authorPm.setCommitTotalFiles(authorPm.getCommitTotalChanges() + files.size());
            authorPm.setAverageFilesPerCommit(authorPm.getCommitTotalFiles() / authorPm.getCommitCount());
            authorPm.getCommitTimes().add(commitDate);
        }

        if (authorLogin != null && !authorLogin.equals(committerLogin)) {
            committerPm = getProjectMembership(bio, committerLogin, url[1], url[0]);

            committerPm.setCommitCount(committerPm.getCommitCount() + 1);
            //            committerPm.setCommitTotalChanges(committerPm.getCommitTotalChanges()+total);
            //            committerPm.setCommitAdditions(committerPm.getCommitAdditions()+additions);
            //            committerPm.setCommitDeletions(committerPm.getCommitDeletions()+deletions);
            committerPm.setCommitsAsCommitter(committerPm.getCommitsAsCommitter() + 1);
            committerPm.setCommitTotalFiles(committerPm.getCommitTotalChanges() + files.size());
            committerPm.setAverageFilesPerCommit(committerPm.getCommitTotalFiles() / authorPm.getCommitCount());
            if (files != null)
                committerPm.setCommitTotalFiles(committerPm.getCommitTotalChanges() + files.size());
            committerPm
                    .setAverageFilesPerCommit(committerPm.getCommitTotalFiles() / committerPm.getCommitCount());
            committerPm.getCommitTimes().add(commitDate);
        }

        bio.sync();
        count++;
        if (count % 1000 == 0) {
            System.out.print(count + ", ");
            bio.sync();
        }
    }
    cursor.close();
    bio.sync();
    System.out.println();

    System.exit(0);

    //         if (author != null) {
    ////            if (author.getCommits() ==null) author.setCommits(new Commits());
    //            author.setCommitCount(author.getCommitCount()+1);
    //            author.setCommitTotalChanges(author.getCommitTotalChanges()+total);
    //            author.setCommitAdditions(author.getCommitAdditions()+additions);
    //            author.setCommitDeletions(author.getCommitDeletions()+deletions);
    //            author.setCommitsAsAuthor(author.getCommitsAsAuthor()+1);
    //            author.getCommitTimes().add(commitDate);
    //         }
    //         if (committer != null) {
    ////            if (committer.getCommits() ==null) committer.setCommits(new Commits());
    //            committer.setCommitCount(committer.getCommitCount()+1);
    //            committer.setCommitTotalChanges(committer.getCommitTotalChanges()+total);
    //            committer.setCommitAdditions(committer.getCommitAdditions()+additions);
    //            committer.setCommitDeletions(committer.getCommitDeletions()+deletions);
    //            committer.setCommitsAsCommitter(committer.getCommitsAsCommitter()+1);
    //            committer.getCommitTimes().add(commitDate);
    //         }
    //         
    //         ProjectMembership authorPm = null;
    //         ProjectMembership committerPm = null;
    //         
    ////          Only a very small number of commit comments actually reference the repo
    ////          Instead we're going to have to strip the string 
    //         String[] url = convertUrlIntoProjectNameAndOwner(obj.getString("url"));
    //         Project project = null;
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(url[1]), Project.OWNERNAME.eq(url[0])).iterator();
    //         if (repoIt.hasNext()) {
    //            project = repoIt.next();
    //            if (project != null) {
    //      
    //               project.setCommitCount(project.getCommitCount()+1);
    //               project.setCommitTotalChanges(project.getCommitTotalChanges()+total);
    //               project.setCommitAdditions(project.getCommitAdditions()+additions);
    //               project.setCommitDeletions(project.getCommitDeletions()+deletions);
    //               project.getCommitTimes().add(commitDate);
    //               
    //               if (author != null) {
    //                  authorPm = getProjectMembership(bio, author, project);
    //                  authorPm.setCommitCount(authorPm.getCommitCount()+1);
    //                  authorPm.setCommitTotalChanges(authorPm.getCommitTotalChanges()+total);
    //                  authorPm.setCommitAdditions(authorPm.getCommitAdditions()+additions);
    //                  authorPm.setCommitDeletions(authorPm.getCommitDeletions()+deletions);
    //                  authorPm.setCommitsAsAuthor(authorPm.getCommitsAsAuthor()+1);
    //                  
    //                  // Avoid duplicating information
    //                  if (committer != null && author.getLogin().equals(committer.getLogin())) {
    //                     authorPm.setCommitsAsCommitter(authorPm.getCommitsAsCommitter()+1);
    //                  }
    //                  
    //                  authorPm.getCommitTimes().add(commitDate);
    //               }
    //               if (committer != null && author != null && !author.getLogin().equals(committer.getLogin())) {
    //                  committerPm = getProjectMembership(bio, committer, project);
    //                  committerPm.setCommitCount(committerPm.getCommitCount()+1);
    //                  committerPm.setCommitTotalChanges(committerPm.getCommitTotalChanges()+total);
    //                  committerPm.setCommitAdditions(committerPm.getCommitAdditions()+additions);
    //                  committerPm.setCommitDeletions(committerPm.getCommitDeletions()+deletions);
    //                  committerPm.setCommitsAsCommitter(committerPm.getCommitsAsCommitter()+1);
    //                  
    //                  committerPm.getCommitTimes().add(commitDate);
    //               }
    //            } 
    //         }
    //         else {
    //            System.err.println("Didn't find project:" + url[0] + ":"+url[1] + ", prestrip: " + obj.getString("url"));
    //         }
    //         bio.getProjectMemberships().sync();
    //         bio.sync();
    //         
    //
    //         // Files
    //         BasicDBList files = (BasicDBList) obj.get("files");
    //         if (files != null) {
    //            for (Object f : files) {
    //               BasicDBObject file = (BasicDBObject)f;
    //               
    //               String filename = file.getString("filename");
    //               if (filename.lastIndexOf(".") != -1) { // If it has an extension, we want that. If not, use the entire filename
    //                  filename = filename.substring(filename.lastIndexOf("."));
    //                  filename = filename.toLowerCase(); // Ensure consistency
    //               }
    //         // FIXME: Should strip any /'s if there is no '.' - i.e. just the last one
    //               
    //               if (author != null) addArtefact(author, filename);
    //               if (committer != null) addArtefact(committer, filename);
    ////               if (project != null) addArtefact(project, filename);
    //            }
    //         }
    //         
    //         if (author != null && files !=null) {
    //            author.setCommitTotalFiles(author.getCommitTotalFiles()+files.size());
    //            author.setAverageFilesPerCommit(author.getCommitTotalFiles()/author.getCommitCount());
    //         }
    //         if (committer != null && files !=null && (author==null || !committer.getLogin().equals(author.getLogin()))) {
    //            committer.setCommitTotalFiles(committer.getCommitTotalFiles()+files.size());
    //            committer.setAverageFilesPerCommit(committer.getCommitTotalFiles()/committer.getCommitCount());
    //         }
    //         if (authorPm !=null && files != null) {
    //            authorPm.setCommitTotalFiles(authorPm.getCommitTotalChanges()+files.size());
    //            authorPm.setAverageFilesPerCommit(authorPm.getCommitTotalFiles()/authorPm.getCommitCount());
    //         }
    //         if (committerPm != null && files != null) {
    //            committerPm.setCommitTotalFiles(committerPm.getCommitTotalChanges()+files.size());
    //            committerPm.setAverageFilesPerCommit(committerPm.getCommitTotalFiles()/committerPm.getCommitCount());
    //         }
    //         
    //         if (project!=null && files != null) {
    //            project.setCommitTotalFiles(project.getCommitTotalChanges()+files.size());
    //            project.setAverageFilesPerCommit(project.getCommitTotalFiles()/project.getCommitCount());
    //         }

    //         bio.getProjectMemberships().sync();
    //         bio.sync();
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      cursor.close();
    //      bio.sync();
    //      System.out.println();
    //
    //      System.exit(0);

    ////      #4 Commit comments
    //      System.out.println("Extracting commit comments...");
    //      cursor = msrDb.getCollection("commit_comments").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //      
    //         String username = getUserLoginName(bio, "user", "login", obj);
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(username));
    //         if (user == null) {
    //            System.err.println("Found commit comment with unrecognised user: " + username);
    //            continue;
    //         }
    //         
    //         user.setNumberOfCommitComments(user.getNumberOfCommitComments()+1);
    //         
    ////         if (!user.getDbObject().containsField("commitCommentTimes")) {
    ////            user.getDbObject().put("commitCommentTimes", new BasicDBList());
    ////         }
    ////         user.getCommitCommentTimes().add(obj.getString("created_at"));
    //         
    //         // Only a very small number of commit comments actually reference the repo
    //         // Instead we're going to have to strip the string 
    //         String[] url = convertUrlIntoProjectNameAndOwner(obj.getString("url"));
    //         
    ////         System.out.println("Querying project " + url[1] + " and owner " + url[0]);
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(url[1]), Project.OWNERNAME.eq(url[0])).iterator();
    ////         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            if (project != null) {
    //               project.setNumberOfCommitComments(project.getNumberOfCommitComments()+1);
    //               
    //               if (!project.getDbObject().containsField("commitCommentTimes")) {
    //                  project.getDbObject().put("commitCommentTimes", new BasicDBList());
    //               }
    //               project.getCommitCommentTimes().add(obj.getString("created_at"));
    //               
    //               ProjectMembership pm = getProjectMembership(bio, user, project);
    //               pm.setNumberOfCommitComments(pm.getNumberOfCommitComments()+1);
    //               
    //               if (!pm.getDbObject().containsField("commitCommentTimes")) {
    //                  pm.getDbObject().put("commitCommentTimes", new BasicDBList());
    //               }
    //               pm.getCommitCommentTimes().add(obj.getString("created_at"));
    //            }
    ////         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      cursor.close();
    //      bio.sync();
    //      System.out.println();
    //      System.exit(0);

    ////      //FIXME: THIS IS CAUSING THE CPU TO HIS 350% AND THEN KILLS THE LAPTOP?!?!?!?!? 
    //      #5 Pull requests
    System.out.println("Extracting pull requests...");
    cursor = msrDb.getCollection("pull_requests").find();
    cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    it = cursor.iterator();

    System.out.println("Clearing previous data");
    for (User u : bio.getUsers()) {
        if (!u.getDbObject().containsField("pullRequestTimes")) {
            u.getDbObject().put("pullRequestTimes", new BasicDBList());
        }
        u.getPullRequestTimes().clear();
        u.setNumberOfPullRequests(0);
    }
    bio.sync();
    for (Project u : bio.getProjects()) {
        if (!u.getDbObject().containsField("pullRequestTimes")) {
            u.getDbObject().put("pullRequestTimes", new BasicDBList());
        }
        u.getPullRequestTimes().clear();
        u.setNumberOfPullRequests(0);
    }
    bio.sync();

    for (ProjectMembership u : bio.getProjectMemberships()) {
        if (!u.getDbObject().containsField("pullRequestTimes")) {
            u.getDbObject().put("pullRequestTimes", new BasicDBList());
        }
        u.getPullRequestTimes().clear();
        u.setNumberOfPullRequests(0);
    }
    bio.sync();

    System.out.println("Cleared!");

    count = 0;
    while (it.hasNext()) {

        BasicDBObject obj = (BasicDBObject) it.next();

        String username = getUserLoginName(bio, "user", "login", obj);
        User user = bio.getUsers().findOne(User.LOGIN.eq(username));
        if (user == null) {
            //            System.err.println("Found pull request with unrecognised user:" + username);
            continue;
        }

        if (!user.getDbObject().containsField("pullRequestTimes")) {
            user.getDbObject().put("pullRequestTimes", new BasicDBList());
        }
        user.getPullRequestTimes().add(obj.getString("created_at"));

        user.setNumberOfPullRequests(user.getNumberOfPullRequests() + 1);

        // Project
        System.out.println(obj.getString("repo") + " " + obj.getString("owner") + obj.getString("_id"));

        ProjectMembership pm = getProjectMembership(bio, user.getLogin(), obj.getString("repo"),
                obj.getString("owner"));
        pm.setNumberOfPullRequests(pm.getNumberOfPullRequests() + 1);

        if (!pm.getDbObject().containsField("pullRequestTimes")) {
            pm.getDbObject().put("pullRequestTimes", new BasicDBList());
        }
        pm.getPullRequestTimes().add(obj.getString("created_at"));

        //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
        //         if (repoIt.hasNext()) { // FIXME Causes it to run out of heap!
        //            Project project = repoIt.next();
        //            if (project != null) {
        //               project.setNumberOfPullRequests(project.getNumberOfPullRequests()+1);
        //               
        //               if (!project.getDbObject().containsField("pullRequestTimes")) {
        //                  project.getDbObject().put("pullRequestTimes", new BasicDBList());
        //               }
        //               project.getPullRequestTimes().add(obj.getString("created_at"));
        //               
        //            }
        //         } else {
        //            System.err.println("Didn't find project:" + obj.getString("repo") + ":"+obj.getString("owner"));
        //         }

        count++;
        if (count % 1000 == 0) {
            System.out.print(count + ", ");
            bio.sync();
            System.gc();
        }
    }
    bio.sync();
    System.out.println();
    System.exit(0);

    ////      #6 Pull request comments
    //      System.out.println("Extracting pull request comments...");
    //      cursor = msrDb.getCollection("pull_request_comments").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //      
    //         String username = getUserLoginName(bio, "user", "login", obj);
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(username));
    //         if (user == null) {
    ////            System.err.println("Found pull request comment with unrecognised user:" + username);
    //            continue;
    //         }
    //         
    //         if (!user.getDbObject().containsField("pullRequestCommentTimes")) {
    //            user.getDbObject().put("pullRequestCommentTimes", new BasicDBList());
    //         }
    //         user.getPullRequestCommentTimes().add(obj.getString("created_at"));
    //         user.setNumberOfPullRequestComments(user.getNumberOfPullRequestComments()+1);
    //         
    //         // Project
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
    ////         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            if (project != null) {
    //               project.setNumberOfPullRequestComments(project.getNumberOfPullRequestComments()+1);
    //               if (!project.getDbObject().containsField("pullRequestCommentTimes")) {
    //                  project.getDbObject().put("pullRequestCommentTimes", new BasicDBList());
    //               }
    //               project.getPullRequestCommentTimes().add(obj.getString("created_at"));
    //               
    //               ProjectMembership pm = getProjectMembership(bio, user, project);
    //               pm.setNumberOfPullRequestComments(pm.getNumberOfPullRequestComments()+1);
    //               
    //               if (!pm.getDbObject().containsField("pullRequestCommentTimes")) {
    //                  pm.getDbObject().put("pullRequestCommentTimes", new BasicDBList());
    //               }
    //               pm.getPullRequestCommentTimes().add(obj.getString("created_at"));
    //            }
    ////         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      System.exit(0);

    ////      #7 Issues
    //      System.out.println("Extracting issues...");
    //      cursor = msrDb.getCollection("issues").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //      
    //         String username = getUserLoginName(bio, "user", "login", obj);
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(username));
    //         if (user == null) {
    ////            System.err.println("Found issue with unrecognised user:" + username);
    //            continue;
    //         }
    //         
    //         if (!user.getDbObject().containsField("issueTimes")) {
    //            user.getDbObject().put("issueTimes", new BasicDBList());
    //         }
    //         user.getIssueTimes().add(obj.getString("created_at"));
    //         user.setNumberOfIssues(user.getNumberOfIssues()+1);
    //         
    //         // Project
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
    //         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            if (project != null) {
    //               project.setNumberOfIssues(project.getNumberOfIssues()+1);
    //               
    //               if (!project.getDbObject().containsField("issueTimes")) {
    //                  project.getDbObject().put("issueTimes", new BasicDBList());
    //               }
    //               project.getIssueTimes().add(obj.getString("created_at"));
    //               
    //               ProjectMembership pm = getProjectMembership(bio, user, project);
    //               pm.setNumberOfIssues(pm.getNumberOfIssues()+1);
    //               
    //               if (!pm.getDbObject().containsField("issueTimes")) {
    //                  pm.getDbObject().put("issueTimes", new BasicDBList());
    //               }
    //               pm.getIssueTimes().add(obj.getString("created_at"));
    //            }
    //         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      System.exit(0);

    ////      #8 Issue comments
    //      System.out.println("Extracting issue comments...");
    //      cursor = msrDb.getCollection("issue_comments").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //      
    //         String username = getUserLoginName(bio, "user", "login", obj);
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(username));
    //         if (user == null) {
    ////            System.err.println("Found issue comment with unrecognised user:" + username);
    //            continue;
    //         }
    //         
    //         if (!user.getDbObject().containsField("issueCommentTimes")) {
    //            user.getDbObject().put("issueCommentTimes", new BasicDBList());
    //         }
    //         user.getIssueCommentTimes().add(obj.getString("created_at"));
    //         user.setNumberOfIssueComments(user.getNumberOfIssueComments()+1);
    //         
    //         // Project
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
    //         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            if (project != null) {
    //               project.setNumberOfIssueComments(project.getNumberOfIssueComments()+1);
    //               
    //               if (!project.getDbObject().containsField("issueCommentTimes")) {
    //                  project.getDbObject().put("issueCommentTimes", new BasicDBList());
    //               }
    //               project.getIssueCommentTimes().add(obj.getString("created_at"));
    //               
    //               ProjectMembership pm = getProjectMembership(bio, user, project);
    //               pm.setNumberOfIssueComments(pm.getNumberOfIssueComments()+1);
    //               
    //               if (!pm.getDbObject().containsField("issueCommentTimes")) {
    //                  pm.getDbObject().put("issueCommentTimes", new BasicDBList());
    //               }
    //               pm.getIssueCommentTimes().add(obj.getString("created_at"));
    //            }
    //         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      System.exit(0);

    ////      #9 Issue events
    //      System.out.println("Extracting issue events...");
    //      cursor = msrDb.getCollection("issue_events").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //      
    //         String username = getUserLoginName(bio, "actor", "login", obj);
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(username));
    //         if (user == null) {
    ////            System.err.println("Found issue event with unrecognised user:" + username);
    //            continue;
    //         }
    //         
    //         String eventKind = obj.getString("event");
    //         IssueEventKind kind = null; //FIXME
    //         
    //         switch (eventKind) {
    //            case "closed": kind = IssueEventKind.CLOSED; break;
    //            case "assigned": kind = IssueEventKind.ASSIGNED; break;
    //            case "mentioned": kind = IssueEventKind.MENTIONED; break;
    //            case "merged": kind = IssueEventKind.MERGED; break;
    //            case "referenced": kind = IssueEventKind.REFERENCED; break;
    //            case "reopened": kind = IssueEventKind.REOPENED; break;
    //            case "subscribed": kind = IssueEventKind.SUBSCRIBED; break;
    //            case "head_ref_deleted" : kind = IssueEventKind.HEAD_REF_DELETED; break;
    //            case "head_ref_restored" : kind = IssueEventKind.HEAD_REF_RESTORED; break;
    //            case "head_ref_cleaned" : kind = IssueEventKind.HEAD_REF_CLEANED; break;
    //            case "unsubscribed" : kind = IssueEventKind.UNSUBSCRIBED; break;
    //            default:
    //               System.err.println("Unrecognised issue event kind: " + eventKind);
    //         }
    //         if (kind == null) continue;
    //
    //         boolean eventKindFound = false;
    //         
    //         if (!user.getDbObject().containsField("issueEvents")) {
    //            user.getDbObject().put("issueEvents", new BasicDBList());
    //         }
    //         
    //         for (IssueEvent ie : user.getIssueEvents()) {
    //            if (ie.getEventKind().equals(kind)) {
    //               ie.setCount(ie.getCount()+1);
    //               eventKindFound = true;
    //               break;
    //            }
    //         }
    //         if (!eventKindFound) {
    //            IssueEvent ie = new IssueEvent();
    //            ie.setEventKind(kind);
    //            ie.setCount(1);
    //            user.getIssueEvents().add(ie);
    //         }
    //         
    //         // Project
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
    //         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            
    //            if (!project.getDbObject().containsField("issueEvents")) {
    //               project.getDbObject().put("issueEvents", new BasicDBList());
    //            }
    //         
    //            eventKindFound = false;
    //            for (IssueEvent ie : project.getIssueEvents()) {
    //               if (ie.getEventKind().equals(kind)) {
    //                  ie.setCount(ie.getCount()+1);
    //                  eventKindFound = true;
    //                  break;
    //               }
    //            }
    //            if (!eventKindFound) {
    //               IssueEvent ie = new IssueEvent();
    //               ie.setEventKind(kind);
    //               ie.setCount(1);
    //               project.getIssueEvents().add(ie);
    //            }
    //            
    //            ProjectMembership pm = getProjectMembership(bio, user, project);
    //            
    //            if (!pm.getDbObject().containsField("issueEvents")) {
    //               pm.getDbObject().put("issueEvents", new BasicDBList());
    //            }
    //            
    //            eventKindFound = false;
    //            for (IssueEvent ie : pm.getIssueEvents()) {
    //               if (ie.getEventKind().equals(kind)) {
    //                  ie.setCount(ie.getCount()+1);
    //                  eventKindFound = true;
    //                  break;
    //               }
    //            }
    //            if (!eventKindFound) {
    //               IssueEvent ie = new IssueEvent();
    //               ie.setEventKind(kind);
    //               ie.setCount(1);
    //               pm.getIssueEvents().add(ie);
    //            }
    //         }
    //         
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();
    //      System.exit(0);
    //      
    ////      Watchers
    //      System.out.println("Extracting watchers...");
    //      cursor = msrDb.getCollection("watchers").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(obj.getString("login")));
    //         if (user == null) continue;
    //         
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.NAME.eq(obj.getString("repo")), Project.OWNERNAME.eq(obj.getString("owner"))).iterator();
    //         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //            if (project != null && !project.getWatchers().contains(user)) project.getWatchers().add(user);
    //            if (!user.getWatches().contains(project)) user.getWatches().add(project);
    //         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      System.out.println();

    ////      Org members FIXME: INCOMPLETE: Cannot match the org name against ANYTHING....
    //      System.out.println("Extracting org members...");
    //      cursor = msrDb.getCollection("org_members").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         String login = obj.getString("login");
    //         String orgName = obj.getString("org");
    //         
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(login));
    //         
    //         User org = bio.getUsers().findOne(User.LOGIN.eq(orgName));
    //         
    //         if (org!=null){
    //            System.err.println("Found org! " + orgName);
    //            
    //         }
    //         
    ////         Project project = bio.getProjects().findOne(Project.OWNERNAME.eq("orgName"));
    ////         if (project==null) {
    ////            System.err.println("Didn't find project: " + orgName);
    ////            continue;
    ////         }
    ////         ProjectMembership pm = getProjectMembership(bio, user, project);
    ////         pm.setOrgMember(true);
    //      }
    //      bio.sync();
    //      System.out.println();

    //      Repo collaborators
    //      System.out.println("Extracting repo collaborators...");
    //      cursor = msrDb.getCollection("repo_collaborators").find();
    //      cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
    //      it = cursor.iterator();
    //      
    //      count = 0;
    //      while(it.hasNext()){
    //         BasicDBObject obj = (BasicDBObject) it.next();
    //         
    //         String login = obj.getString("login");
    //         String projectName = obj.getString("repo");
    //         String ownerName = obj.getString("owner");
    //         
    //         User user = bio.getUsers().findOne(User.LOGIN.eq(login));
    //         Iterator<Project> repoIt = bio.getProjects().find(Project.OWNERNAME.eq(ownerName), Project.NAME.eq(projectName)).iterator();
    //         if (repoIt.hasNext()) {
    //            Project project = repoIt.next();
    //   
    //            ProjectMembership pm = getProjectMembership(bio, user, project);
    //            pm.setCollaborator(true);
    //         } else {
    //            System.err.println("Couldn't find repo. owner: " + ownerName + ", repo: " + projectName);
    //         }
    //         count++;
    //         if (count % 1000 == 0) {
    //            System.out.print(count + ", ");
    //            bio.sync();
    //         }
    //      }
    //      bio.sync();
    //      
    long end = System.currentTimeMillis();
    System.out.println("Finished at " + new Date());

    long duration = end - start;
    System.out.println("Duration: " + duration);

}

From source file:org.ossmeter.platform.mining.msr14.Extractor.java

License:Open Source License

/**
 * Some 'user' field in commit_comments are Strings. Some are objects. Seriously.
 * @param bio//from   w w w  . j  a  v  a2s  .  co m
 * @param obj
 * @return
 */
protected static String getUserLoginName(Biodiversity bio, String userField, String loginField,
        BasicDBObject obj) {
    String username = null;
    if (obj.get(userField) == null)
        return null;
    if (obj.get(userField) instanceof String) {
        username = obj.getString(userField);
    } else {
        username = ((BasicDBObject) obj.get(userField)).getString(loginField);
    }
    return username;
}

From source file:org.seasr.meandre.components.transform.bson.SelectBsonFields.java

License:Open Source License

@Override
public void executeCallBack(ComponentContext cc) throws Exception {
    BasicDBObject bson = (BasicDBObject) cc.getDataComponentFromInput(IN_BSON);
    for (int i = 0; i < _fields.length; i++) {
        String f = bson.getString(_fields[i]);
        if (f == null) {
            console.warning(String.format("Got null string for field %s (%s)", i, _fields[i]));
            f = "";
        }//from  w ww  .  j a v  a 2s.c o m
        cc.pushDataComponentToOutput(PARAM_OUT_STRING + (i + 1), BasicDataTypesTools.stringToStrings(f));
    }
}

From source file:org.sipfoundry.sipxconfig.mongo.MongoReplicaSetManager.java

License:Open Source License

public void checkState() {
    try {/* w w w  .  ja  v  a 2s . c om*/
        BasicBSONObject ret = MongoUtil.runCommand(m_localDb.getDb(), CHECK_COMMAND);
        boolean initialized = false;
        if (ret != null) {
            BasicDBList members = (BasicDBList) ret.get(MEMBERS);
            if (members != null) {
                BasicDBObject primary = (BasicDBObject) members.get(0);
                if (primary != null) {
                    initialized = true;
                    String host = primary.getString(HOST);
                    String expected = format(m_primaryFqdn + ':' + MongoSettings.SERVER_PORT);
                    if (!expected.equals(host)) {
                        String rename = format(RENAME_PRIMARY_COMMAND, expected);
                        MongoUtil.runCommand(m_localDb.getDb(), rename);
                    }
                }
            }
        }

        if (!initialized) {
            initialize();
        }
    } catch (Exception ex) {
        LOG.error("Failed to check replica set state!");
    }

}

From source file:org.sipfoundry.sipxconfig.mongo.MongoServer.java

License:Open Source License

public MongoServer(BasicDBObject dbo) {
    m_id = dbo.getInt("_id");
    m_name = dbo.getString("name");
    m_type = SERVER;/*from w ww  .ja  va 2s  .  c o  m*/
    if (StringUtils.contains(m_name, String.valueOf(MongoSettings.ARBITER_PORT))) {
        m_type = ARBITER;
    }
    m_configured = true;
    m_state = dbo.getString("stateStr");
    m_health = UP;
    if (dbo.containsField(HEALTH)) {
        if (dbo.getInt(HEALTH) == 0) {
            m_health = DOWN;
        }
    }
    if (dbo.containsField(ERR_MSG)) {
        m_errMsg = dbo.getString(ERR_MSG);
    }
    try {
        BSONTimestamp optime = (BSONTimestamp) dbo.get("optime");
        if (optime.getTime() != 0) {
            m_optimeDate = new Date((long) optime.getTime() * 1000).toString();
        }
    } catch (NumberFormatException ex) {
        m_optimeDate = NA;
    }
}