How to use

User

in

org.opencb.opencga.core.models

checkUserExists(id);
User user = new User(id, name, email, "", organization, User.UserStatus.READY);
user.getAccount().setAuthOrigin(INTERNAL_AUTHORIZATION);
        + Account.FULL + " and " + Account.GUEST);
  user.getAccount().setType(accountType);
  user.setQuota(quota);
  catalogIOManagerFactory.getDefault().createUser(user.getId());
  QueryResult<User> queryResult = userDBAdaptor.insert(user, options);
  auditManager.recordCreation(AuditRecord.Resource.user, id, id, queryResult.first(), null, null);
  authenticationManagerMap.get(INTERNAL_AUTHORIZATION).newPassword(user.getId(), password);
  return queryResult;
} catch (CatalogIOException | CatalogDBException e) {
  if (!userDBAdaptor.exists(user.getId())) {
    logger.error("ERROR! DELETING USER! " + user.getId());
    catalogIOManagerFactory.getDefault().deleteUser(user.getId());

authId = user.first().getAccount().getAuthOrigin();
  throw new CatalogException("Internal error: This error should never happen.");
authenticationManagerMap.get(authId).authenticate(((String) user.first().getAttributes().get("LDAP_RDN")), password, true);

@Test
public void modifyUserTest() throws CatalogDBException {
  ObjectMap genomeMapsConfig = new ObjectMap("lastPosition", "4:1222222:1333333");
  genomeMapsConfig.put("otherConf", Arrays.asList(1, 2, 3, 4, 5));
  catalogUserDBAdaptor.setConfig(user1.getId(), "genomemaps", genomeMapsConfig);
  User user = catalogUserDBAdaptor.get(user1.getId(), null, null).first();
  assertNotNull(user.getConfigs().get("genomemaps"));
  Map<String, Object> genomemaps = (Map<String, Object>) user.getConfigs().get("genomemaps");
  assertNotNull(genomemaps.get("otherConf"));
  assertNotNull(genomemaps.get("lastPosition"));
}

long startTime = startQuery();
if (exists(user.getId())) {
  throw new CatalogDBException("User {id:\"" + user.getId() + "\"} already exists");
List<Project> projects = user.getProjects();
user.setProjects(Collections.<Project>emptyList());
user.setLastModified(TimeUtils.getTimeMillis());
Document userDocument = userConverter.convertToStorageType(user);
userDocument.append(PRIVATE_ID, user.getId());
  insert = userCollection.insert(userDocument, null);
} catch (DuplicateKeyException e) {
  throw new CatalogDBException("User {id:\"" + user.getId() + "\"} already exists");
  String projectErrorMsg = dbAdaptorFactory.getCatalogProjectDbAdaptor().insert(p, user.getId(), options).getErrorMsg();
  if (projectErrorMsg != null && !projectErrorMsg.isEmpty()) {
    errorMsg += ", " + p.getId() + ":" + projectErrorMsg;
user.setProjects(projects);
List<User> result = get(user.getId(), options, "null").getResult();

@Override
public QueryResult<User> get(Query query, QueryOptions options) throws CatalogDBException {
  if (!query.containsKey(QueryParams.STATUS_NAME.key())) {
    query.append(QueryParams.STATUS_NAME.key(), "!=" + Status.DELETED);
  }
  Bson bson = parseQuery(query);
  QueryResult<User> userQueryResult = userCollection.find(bson, null, userConverter, options);
  for (User user : userQueryResult.getResult()) {
    if (user.getProjects() != null) {
      List<Project> projects = new ArrayList<>(user.getProjects().size());
      for (Project project : user.getProjects()) {
        Query query1 = new Query(ProjectDBAdaptor.QueryParams.UID.key(), project.getUid());
        QueryResult<Project> projectQueryResult = dbAdaptorFactory.getCatalogProjectDbAdaptor().get(query1, options);
        projects.add(projectQueryResult.first());
      }
      user.setProjects(projects);
    }
  }
  return userQueryResult;
}

private void joinFields(User user, QueryOptions options) throws CatalogDBException {
  if (options == null) {
    return;
  }
  if (user.getProjects() != null) {
    for (Project project : user.getProjects()) {
      joinFields(project, options);
    }
  }
}

@Test
public void getProjectIdTest() throws CatalogDBException {
  assertTrue(catalogProjectDBAdaptor.getId(user3.getId(), user3.getProjects().get(0).getId()) != -1);
  assertTrue(catalogProjectDBAdaptor.getId(user3.getId(), "nonExistingProject") == -1);
}

new QueryResult("changePassword", 0, 0, 0, "", "", Collections.emptyList());
List<User> userList = catalogManager.getUserManager().get("user", userPre.getLastModified(), new QueryOptions(QueryOptions
    .INCLUDE, Arrays.asList(UserDBAdaptor.QueryParams.PASSWORD.key(), UserDBAdaptor.QueryParams.NAME.key(), UserDBAdaptor.QueryParams
    .EMAIL.key(), UserDBAdaptor.QueryParams.ATTRIBUTES.key())), sessionIdUser).getResult();
assertTrue(!userPre.getLastModified().equals(userPost.getLastModified()));
assertEquals(userPost.getName(), newName);
assertEquals(userPost.getEmail(), newEmail);
assertEquals(null, userPost.getPassword());
  assertEquals(userPost.getAttributes().get(entry.getKey()), entry.getValue());

@Test
public void getAllProjects() throws CatalogDBException {
  QueryResult<Project> allProjects = catalogProjectDBAdaptor.get(user3.getId(), null);
  System.out.println(allProjects);
  assertTrue(!allProjects.getResult().isEmpty());
}

@Test
public void deleteUserTest() throws CatalogException {
  User deletable1 = new User("deletable1", "deletable 1", "d1@ebi", "1234", "", User.UserStatus.READY);
  QueryResult<User> createUser = catalogUserDBAdaptor.insert(deletable1, null);
  assertFalse(createUser.getResult().isEmpty());
  assertNotNull(createUser.first());
  assertEquals(Status.READY, createUser.first().getStatus().getName());
  QueryResult<User> deleteUser = catalogUserDBAdaptor.delete(deletable1.getId(), new QueryOptions());
  assertFalse(deleteUser.getResult().isEmpty());
  assertNotNull(deleteUser.first());
  assertEquals(Status.DELETED, deleteUser.first().getStatus().getName());
  /*
  thrown.expect(CatalogDBException.class);
  catalogUserDBAdaptor.delete(deletable1.getId());
  */
}

@Test
public void getUserTest() throws CatalogDBException {
  QueryResult<User> user = catalogUserDBAdaptor.get(user1.getId(), null, null);
  assertNotSame(0, user.getResult().size());
  user = catalogUserDBAdaptor.get(user3.getId(), null, null);
  assertFalse(user.getResult().isEmpty());
  assertFalse(user.first().getProjects().isEmpty());
  user = catalogUserDBAdaptor.get(user3.getId(), new QueryOptions("exclude", Arrays.asList("projects")), null);
  assertEquals(null, user.first().getProjects());
  user = catalogUserDBAdaptor.get(user3.getId(), null, user.first().getLastModified());
  assertTrue(user.getResult().isEmpty());
  thrown.expect(CatalogDBException.class);
  catalogUserDBAdaptor.get("NonExistingUser", null, null);
}

.setAnalyst(new Analyst(userId, userQueryResult.first().getEmail(), userQueryResult.first().getOrganization()))
.setClinicalAnalysisId(clinicalAnalysisId)
.setCreationDate(TimeUtils.getTime())

@Test
public void changePasswordTest() throws CatalogDBException {
  QueryResult queryResult = catalogUserDBAdaptor.changePassword(user2.getId(), user2.getPassword(), "1234");
  assertNotSame(0, queryResult.getResult().size());
  thrown.expect(CatalogDBException.class);
  catalogUserDBAdaptor.changePassword(user2.getId(), "BAD_PASSWORD", "asdf");
}

private User.Filter getFilter(String userId, String name) throws CatalogException {
  Query query = new Query()
      .append(UserDBAdaptor.QueryParams.ID.key(), userId);
  QueryOptions queryOptions = new QueryOptions(QueryOptions.INCLUDE, UserDBAdaptor.QueryParams.CONFIGS.key());
  QueryResult<User> userQueryResult = userDBAdaptor.get(query, queryOptions);
  if (userQueryResult.getNumResults() != 1) {
    throw new CatalogException("Internal error: User " + userId + " not found.");
  }
  for (User.Filter filter : userQueryResult.first().getConfigs().getFilters()) {
    if (name.equals(filter.getName())) {
      return filter;
    }
  }
  return null;
}

user1 = new User("jcoll", "Jacobo Coll", "jcoll@ebi", "1234", "", null, User.UserStatus.READY, "", 100, 1000,
    Arrays.<Project>asList(new Project("P1", "project", "", new Status(), "", null, 1), new Project("P2", "project", "",
        new Status(), "", null, 1), new Project("P3", "project", "", new Status(), "", null, 1)),
assertNotNull(createUser.getResult());
user2 = new User("jmmut", "Jose Miguel", "jmmut@ebi", "1111", "ACME", User.UserStatus.READY);
createUser = catalogUserDBAdaptor.insert(user2, null);
assertNotNull(createUser.getResult());
user3 = new User("imedina", "Nacho", "nacho@gmail", "2222", "SPAIN", null, User.UserStatus.READY, "", 1222, 122222,
    Arrays.asList(new Project("pr1", "90 GigaGenomes", null, "very long description", "Spain", null, new Status(), "", 0,
            Arrays.asList(new Study("name", "Study name", "ph1", Study.Type.CONTROL_SET, "", "", new Status(),
assertNotNull(createUser.getResult());
user4 = new User("pfurio", "Pedro", "pfurio@blabla", "pfuriopass", "Organization", null, User.UserStatus.READY, "", 0, 50000,
    Arrays.asList(new Project("pr", "lncRNAs", null, "My description", "My org", null, new Status(), "", 0,
        Arrays.asList(
options.put("includeJobs", true);
options.put("includeSamples", true);
user1 = catalogUserDBAdaptor.get(MongoDBAdaptorTest.user1.getId(), options, null).first();
user2 = catalogUserDBAdaptor.get(MongoDBAdaptorTest.user2.getId(), options, null).first();
user3 = catalogUserDBAdaptor.get(MongoDBAdaptorTest.user3.getId(), options, null).first();
user4 = catalogUserDBAdaptor.get(MongoDBAdaptorTest.user4.getId(), options, null).first();

user.setPassword(null);
if (user.getProjects() != null) {
  for (Project project : user.getProjects()) {
    if (project.getStudies() != null) {
      for (Study study : project.getStudies()) {

  @Override
  public QueryResult resetPassword(String userId) throws CatalogException {
    ParamUtils.checkParameter(userId, "userId");
    userDBAdaptor.updateUserLastModified(userId);

    String newPassword = StringUtils.randomString(6);

    String newCryptPass = cypherPassword(newPassword);

    QueryResult<User> user =
        userDBAdaptor.get(userId, new QueryOptions(QueryOptions.INCLUDE, UserDBAdaptor.QueryParams.EMAIL.key()), "");

    if (user == null || user.getNumResults() != 1) {
      throw new CatalogException("Could not retrieve the user e-mail.");
    }

    String email = user.first().getEmail();

    QueryResult queryResult = userDBAdaptor.resetPassword(userId, email, newCryptPass);

    String mailUser = this.configuration.getEmail().getFrom();
    String mailPassword = this.configuration.getEmail().getPassword();
    String mailHost = this.configuration.getEmail().getHost();
    String mailPort = this.configuration.getEmail().getPort();

    MailUtils.sendResetPasswordMail(email, newPassword, mailUser, mailPassword, mailHost, mailPort);

    return queryResult;
  }
}

User user = new User(uid, displayname, mail, "", base, account, User.UserStatus.READY, "", -1, -1, new ArrayList<>(),
    new ArrayList<>(), new HashMap<>(), attributes);

private List<String> fetchGroupsFromLdapUser(User user, AuthenticationOrigin authenticationOrigin) throws NamingException {
  List<String> groups = new ArrayList<>();
  if (user == null) {
    return groups;
  }
  String userRdn = (String) user.getAttributes().get("LDAP_RDN");
  String base = ((String) authenticationOrigin.getOptions().get(AuthenticationOrigin.USERS_SEARCH));
  return LDAPUtils.getGroupsFromLdapUser(authenticationOrigin.getHost(), userRdn, base);
}

@Override
public boolean authenticate(String userId, String password, boolean throwException) throws CatalogException {
  String cypherPassword = cypherPassword(password);
  String storedPassword;
  boolean validSessionId = false;
  if (ROOT.equals(userId)) {
    storedPassword = metaDBAdaptor.getAdminPassword();
    try {
      validSessionId = jwtManager.getUser(password).equals(userId);
    } catch (CatalogAuthenticationException e) {
      validSessionId = false;
    }
  } else {
    storedPassword = userDBAdaptor.get(userId, new QueryOptions(QueryOptions.INCLUDE, "password"), null).first()
        .getPassword();
  }
  if (storedPassword.equals(cypherPassword) || validSessionId) {
    return true;
  } else {
    if (throwException) {
      throw CatalogAuthenticationException.incorrectUserOrPassword();
    } else {
      return false;
    }
  }
}