コード例 #1
0
  MolgenisUserViewData(MolgenisUser mu, List<MolgenisGroup> molgenisGroups) {
    this(mu.getId(), mu.getUsername());
    firstName = (null == mu.getFirstName() ? "" : mu.getFirstName());
    middleName = (null == mu.getMiddleNames() ? "" : mu.getMiddleNames());
    lastName = (null == mu.getLastName() ? "" : mu.getLastName());

    fullName = firstName + ' ' + middleName + ' ' + lastName;

    this.active = mu.isActive();
    this.superuser = mu.isSuperuser();

    for (MolgenisGroup mg : molgenisGroups) {
      this.groupList.add(mg.getId());
    }
  }
コード例 #2
0
  @BeforeMethod
  public void beforeMethod() {
    owner = new MolgenisUser();
    owner.setUsername("flup");
    owner.setPassword("geheim");
    owner.setId("12345");
    owner.setActive(true);
    owner.setEmail("*****@*****.**");
    owner.setFirstName("Flup");
    owner.setLastName("de Flap");

    DefaultEntityMetaData target1 = new DefaultEntityMetaData("target1");
    target1.addAttribute("id", ROLE_ID);
    DefaultEntityMetaData target2 = new DefaultEntityMetaData("target2");
    target2.addAttribute("id", ROLE_ID);

    mappingProject = new MappingProject("My first mapping project", owner);
    mappingTarget1 = mappingProject.addTarget(target1);
    mappingTarget2 = mappingProject.addTarget(target2);

    Entity mappingTargetEntity = new MapEntity(MappingTargetRepositoryImpl.META_DATA);
    mappingTargetEntity.set(MappingTargetMetaData.TARGET, "target1");
    mappingTargetEntity.set(MappingTargetMetaData.IDENTIFIER, "mappingTargetID1");
    Entity mappingTargetEntity2 = new MapEntity(MappingTargetRepositoryImpl.META_DATA);
    mappingTargetEntity2.set(MappingTargetMetaData.TARGET, "target2");
    mappingTargetEntity2.set(MappingTargetMetaData.IDENTIFIER, "mappingTargetID2");
    mappingTargetEntities = asList(mappingTargetEntity, mappingTargetEntity2);

    mappingProjectEntity = new MapEntity(META_DATA);
    mappingProjectEntity.set(IDENTIFIER, "mappingProjectID");
    mappingProjectEntity.set(MAPPINGTARGETS, mappingTargetEntities);
    mappingProjectEntity.set(OWNER, owner);
    mappingProjectEntity.set(NAME, "My first mapping project");
  }
コード例 #3
0
  @Test
  public void findUserByToken() {
    MolgenisToken molgenisToken = new MolgenisToken();
    molgenisToken.setToken("token");
    MolgenisUser user = new MolgenisUser();
    user.setUsername("admin");
    molgenisToken.setMolgenisUser(user);

    when(dataService.findOne(
            MolgenisToken.ENTITY_NAME,
            new QueryImpl().eq(MolgenisToken.TOKEN, "token"),
            MolgenisToken.class))
        .thenReturn(molgenisToken);

    UserDetails userDetails =
        new User("admin", "admin", Arrays.asList(new SimpleGrantedAuthority("admin")));
    when(userDetailsService.loadUserByUsername("admin")).thenReturn(userDetails);

    assertEquals(tokenService.findUserByToken("token"), userDetails);
  }
コード例 #4
0
  /**
   * Imports MolgenisUser from tab/comma delimited File.
   *
   * @param MolgenisUserFile a tab delimited file with MolgenisUser data.
   */
  private static void importMolgenisUser(Database db, File MolgenisUserFile)
      throws DatabaseException, IOException, Exception {
    logger.debug("trying to import " + MolgenisUserFile);
    if (!MolgenisUserFile.exists()) {
      logger.warn("MolgenisUser.txt file is missing, skipped import");
    } else {
      // read MolgenisUser from file
      CsvReader reader = new CsvFileReader(MolgenisUserFile);
      List<MolgenisUser> molgenisUserList =
          db.toList(MolgenisUser.class, reader, Integer.MAX_VALUE); // should have no limit
      logger.debug("loaded " + molgenisUserList.size() + " MolgenisUser objects");

      // redirect incoming and outgoing fkeys
      List<Integer> molgenisUserIds = new ArrayList<Integer>(); // also doesn't scale
      for (int i = 0;
          i < molgenisUserList.size();
          i++) // sorry, not a real list so need to put back!!
      {
        MolgenisUser object = molgenisUserList.get(i);

        // remember index of this id for incoming fkeys
        molgenisUserIds.add(object.getId());

        // redirect outgoing fkeys
        if (object.getAffiliation() != null)
          object.setAffiliation_Id(instituteIdMap.get(object.getAffiliation_Id()));
        if (object.getRoles() != null)
          object.setRoles_Id(ontologyTermIdMap.get(object.getRoles_Id()));

        // add assay back to list
        molgenisUserList.set(i, object);
      }
      // add to database
      db.add(molgenisUserList);
      for (int i = 0; i < molgenisUserList.size(); i++) {
        molgenisUserIdMap.put(molgenisUserIds.get(i), molgenisUserList.get(i).getId());
        molgenisRoleIdMap.put(molgenisUserIds.get(i), molgenisUserList.get(i).getId());
        personIdMap.put(molgenisUserIds.get(i), molgenisUserList.get(i).getId());
      }
    }
  }
  public ImportWizardExcelPrognosis(File excelFile) throws Exception {

    Workbook workbook = Workbook.getWorkbook(excelFile);
    ArrayList<String> lowercasedSheetNames = new ArrayList<String>();
    Map<String, String> lowerToOriginalName = new HashMap<String, String>();

    try {

      for (String sheetName : workbook.getSheetNames()) {
        lowercasedSheetNames.add(sheetName.toLowerCase());
        lowerToOriginalName.put(sheetName.toLowerCase(), sheetName);
      }

      if (lowercasedSheetNames.contains("molgenisrole")) {
        String originalSheetname = lowerToOriginalName.get("molgenisrole");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisRoleExcelReader excelReader = new MolgenisRoleExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisRole entity = new MolgenisRole();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenisgroup")) {
        String originalSheetname = lowerToOriginalName.get("molgenisgroup");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisGroupExcelReader excelReader = new MolgenisGroupExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisGroup entity = new MolgenisGroup();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("institute")) {
        String originalSheetname = lowerToOriginalName.get("institute");
        Sheet sheet = workbook.getSheet(originalSheetname);
        InstituteExcelReader excelReader = new InstituteExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        Institute entity = new Institute();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("ontology")) {
        String originalSheetname = lowerToOriginalName.get("ontology");
        Sheet sheet = workbook.getSheet(originalSheetname);
        OntologyExcelReader excelReader = new OntologyExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        Ontology entity = new Ontology();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("ontologyterm")) {
        String originalSheetname = lowerToOriginalName.get("ontologyterm");
        Sheet sheet = workbook.getSheet(originalSheetname);
        OntologyTermExcelReader excelReader = new OntologyTermExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        OntologyTerm entity = new OntologyTerm();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("person")) {
        String originalSheetname = lowerToOriginalName.get("person");
        Sheet sheet = workbook.getSheet(originalSheetname);
        PersonExcelReader excelReader = new PersonExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        Person entity = new Person();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenisuser")) {
        String originalSheetname = lowerToOriginalName.get("molgenisuser");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisUserExcelReader excelReader = new MolgenisUserExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisUser entity = new MolgenisUser();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenisrolegrouplink")) {
        String originalSheetname = lowerToOriginalName.get("molgenisrolegrouplink");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisRoleGroupLinkExcelReader excelReader = new MolgenisRoleGroupLinkExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisRoleGroupLink entity = new MolgenisRoleGroupLink();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenisfile")) {
        String originalSheetname = lowerToOriginalName.get("molgenisfile");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisFileExcelReader excelReader = new MolgenisFileExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisFile entity = new MolgenisFile();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("runtimeproperty")) {
        String originalSheetname = lowerToOriginalName.get("runtimeproperty");
        Sheet sheet = workbook.getSheet(originalSheetname);
        RuntimePropertyExcelReader excelReader = new RuntimePropertyExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        RuntimeProperty entity = new RuntimeProperty();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("publication")) {
        String originalSheetname = lowerToOriginalName.get("publication");
        Sheet sheet = workbook.getSheet(originalSheetname);
        PublicationExcelReader excelReader = new PublicationExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        Publication entity = new Publication();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("usecase")) {
        String originalSheetname = lowerToOriginalName.get("usecase");
        Sheet sheet = workbook.getSheet(originalSheetname);
        UseCaseExcelReader excelReader = new UseCaseExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        UseCase entity = new UseCase();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenisentity")) {
        String originalSheetname = lowerToOriginalName.get("molgenisentity");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisEntityExcelReader excelReader = new MolgenisEntityExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisEntity entity = new MolgenisEntity();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }
      if (lowercasedSheetNames.contains("molgenispermission")) {
        String originalSheetname = lowerToOriginalName.get("molgenispermission");
        Sheet sheet = workbook.getSheet(originalSheetname);
        MolgenisPermissionExcelReader excelReader = new MolgenisPermissionExcelReader();
        List<String> allHeaders = excelReader.getNonEmptyHeaders(sheet);
        MolgenisPermission entity = new MolgenisPermission();
        headersToMaps(originalSheetname, allHeaders, entity.getFields());
      }

      for (String sheetName : lowerToOriginalName.values()) {
        if (importOrder.contains(sheetName)) {
          sheetsImportable.put(sheetName, true);
        } else {
          sheetsImportable.put(sheetName, false);
        }
      }

    } catch (Exception e) {
      throw e;
    } finally {
      workbook.close();
    }
  }