@BeforeTest public void createEntity() { entityType = when(mock(EntityType.class).getName()).thenReturn("Source").getMock(); Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("Identifier").getMock(); when(idAttr.getDataType()).thenReturn(INT); Attribute intAttr = when(mock(Attribute.class).getName()).thenReturn("Int").getMock(); when(intAttr.getDataType()).thenReturn(INT); Attribute stringAttr = when(mock(Attribute.class).getName()).thenReturn("String").getMock(); when(stringAttr.getDataType()).thenReturn(STRING); Attribute nonNumericStringAttr = when(mock(Attribute.class).getName()).thenReturn("NonNumericString").getMock(); when(nonNumericStringAttr.getDataType()).thenReturn(STRING); Attribute longAttr = when(mock(Attribute.class).getName()).thenReturn("Long").getMock(); when(longAttr.getDataType()).thenReturn(LONG); when(entityType.getIdAttribute()).thenReturn(idAttr); when(entityType.getAttribute("Identifier")).thenReturn(idAttr); when(entityType.getAttribute("Int")).thenReturn(intAttr); when(entityType.getAttribute("String")).thenReturn(stringAttr); when(entityType.getAttribute("NonNumericString")).thenReturn(nonNumericStringAttr); when(entityType.getAttribute("Long")).thenReturn(longAttr); entity = new DynamicEntity(entityType); entity.set("Int", 1); entity.set("String", "12"); entity.set("Long", 10L); entity.set("NonNumericString", "Hello World!"); }
@Test public void checkRangeMaxOnly() { Entity entity = new DynamicEntity(intRangeMaxMeta); entity.set("id", "123"); entity.set("intrangemin", 0); Set<ConstraintViolation> constraints = entityAttributesValidator.validate(entity, intRangeMaxMeta); assertTrue(constraints.isEmpty()); }
@Test public void checkRangeMaxOnlyInvalid() { Entity entity = new DynamicEntity(intRangeMaxMeta); entity.set("id", "123"); entity.set("intrangemin", 2); Set<ConstraintViolation> constraints = entityAttributesValidator.validate(entity, intRangeMaxMeta); assertEquals(constraints.size(), 1); }
private Entity toEntityMappingEntity( EntityMapping entityMapping, List<Entity> attributeMappingEntities) { Entity entityMappingEntity = new DynamicEntity(entityMappingMetaData); entityMappingEntity.set(EntityMappingMetaData.IDENTIFIER, entityMapping.getIdentifier()); entityMappingEntity.set(EntityMappingMetaData.SOURCE_ENTITY_TYPE, entityMapping.getName()); entityMappingEntity.set( EntityMappingMetaData.TARGET_ENTITY_TYPE, entityMapping.getTargetEntityType() != null ? entityMapping.getTargetEntityType().getName() : null); entityMappingEntity.set(EntityMappingMetaData.ATTRIBUTE_MAPPINGS, attributeMappingEntities); return entityMappingEntity; }
private Entity toEntityMappingEntity( EntityMapping entityMapping, List<Entity> attributeMappingEntities) { Entity entityMappingEntity = new MapEntity(META_DATA); entityMappingEntity.set(EntityMappingMetaData.IDENTIFIER, entityMapping.getIdentifier()); entityMappingEntity.set(EntityMappingMetaData.SOURCEENTITYMETADATA, entityMapping.getName()); entityMappingEntity.set( EntityMappingMetaData.TARGETENTITYMETADATA, entityMapping.getTargetEntityMetaData() != null ? entityMapping.getTargetEntityMetaData().getName() : null); entityMappingEntity.set(EntityMappingMetaData.ATTRIBUTEMAPPINGS, attributeMappingEntities); return entityMappingEntity; }
@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"); }
@Override public void populateTestEntity(Entity entity) throws Exception { entity.set("col1", sdf.parse("2012-03-13 23:59:33")); entity.set("col2", sdf.parse("2013-02-09 13:12:11")); assertEquals(entity.getUtilDate("col1"), sdf.parse("2012-03-13 23:59:33")); assertEquals(entity.getUtilDate("col2"), sdf.parse("2013-02-09 13:12:11")); }
@Override public Entity createTestEntity() { Entity e = new MapEntity(); e.set("col1", "lorem"); e.set("col2", "ipsum"); return e; }
/** * @param entityName The name of the entity to update * @param attributeName The name of the attribute to update * @param request EntityCollectionBatchRequestV2 * @param response HttpServletResponse * @throws Exception */ @RequestMapping(value = "/{entityName}/{attributeName}", method = PUT) @ResponseStatus(OK) public synchronized void updateAttribute( @PathVariable("entityName") String entityName, @PathVariable("attributeName") String attributeName, @RequestBody @Valid EntityCollectionBatchRequestV2 request, HttpServletResponse response) throws Exception { final EntityMetaData meta = dataService.getEntityMetaData(entityName); if (meta == null) { throw createUnknownEntityException(entityName); } try { AttributeMetaData attr = meta.getAttribute(attributeName); if (attr == null) { throw createUnknownAttributeException(entityName, attributeName); } if (attr.isReadonly()) { throw createMolgenisDataAccessExceptionReadOnlyAttribute(entityName, attributeName); } final List<Entity> entities = request .getEntities() .stream() .filter(e -> e.size() == 2) .map(e -> this.restService.toEntity(meta, e)) .collect(Collectors.toList()); if (entities.size() != request.getEntities().size()) { throw createMolgenisDataExceptionIdentifierAndValue(); } final List<Entity> updatedEntities = new ArrayList<Entity>(); int count = 0; for (Entity entity : entities) { String id = checkForEntityId(entity, count); Entity originalEntity = dataService.findOne(entityName, id); if (originalEntity == null) { throw createUnknownEntityExceptionNotValidId(id); } Object value = this.restService.toEntityValue(attr, entity.get(attributeName)); originalEntity.set(attributeName, value); updatedEntities.add(originalEntity); count++; } // update all entities this.dataService.update(entityName, updatedEntities.stream()); response.setStatus(HttpServletResponse.SC_OK); } catch (Exception e) { response.setStatus(HttpServletResponse.SC_NO_CONTENT); throw e; } }
private void toEntity( EntityMetaData emd, Map<String, Entity> entities, Map<String, Entity> attributes) { // TODO prevent duplicates Entity e = new MapEntity(); e.set("name", emd.getName()); entities.put(emd.getName(), e); logger.debug("entity: " + e); for (AttributeMetaData amd : emd.getAttributes()) { Entity a = new MapEntity(); a.set("name", amd.getName()); a.set("entity", emd.getName()); if (amd.getDataType() != null && amd.getDataType() != MolgenisFieldTypes.STRING) a.set("dataType", amd.getDataType()); if (amd.getDefaultValue() != null) a.set("defaultValue", amd.getDefaultValue()); if (amd.getRefEntity() != null) a.set("refEntity", amd.getRefEntity().getName()); logger.debug("attribute: " + a); attributes.put(emd.getName() + "." + amd.getName(), a); // compound if (amd.getDataType() == MolgenisFieldTypes.COMPOUND && entities.get(amd.getRefEntity().getName()) == null) { this.toEntity(amd.getRefEntity(), entities, attributes); } } }
Entity getDefaultSettings() { Entity defaultSettingsEntity = new DynamicEntity(this); for (Attribute attr : this.getAtomicAttributes()) { // default values are stored/retrieved as strings, so we convert them to the required type // here. String defaultValue = attr.getDefaultValue(); if (defaultValue != null) { Object typedDefaultValue = getTypedValue(defaultValue, attr, entityManager); defaultSettingsEntity.set(attr.getName(), typedDefaultValue); } } return defaultSettingsEntity; }
@BeforeMethod public void setUp() { fileStoreDownloadMock = mock(FileStoreDownload.class); fileRepositoryCollectionFactoryMock = mock(FileRepositoryCollectionFactory.class); fileRepositoryCollectionMock = mock(FileRepositoryCollection.class); importServiceFactoryMock = mock(ImportServiceFactory.class); importServiceMock = mock(ImportService.class); dataService = mock(DataService.class); progress = mock(Progress.class); fileIngester = new FileIngester( fileStoreDownloadMock, importServiceFactoryMock, fileRepositoryCollectionFactoryMock, dataService); entityMetaData = new MapEntity(EntityMetaDataMetaData.FULL_NAME, entityName); fileIngest = new MapEntity(); fileIngest.set(FileIngestMetaData.ENTITY_META_DATA, entityMetaData); fileIngest.set(FileIngestMetaData.URL, url); fileIngest.set(FileIngestMetaData.LOADER, "CSV"); }
@Test public void testReaderFiltersRows() throws IOException { Mockito.when(tabixReader.query("13:12-12")).thenReturn(iterator); Mockito.when(iterator.next()) .thenReturn( "id1\t13\t11\tnope", "id2\t13\t12\tyup", "id3\t13\t12\tyup", "id3\t13\t13\tnope", null); Iterable<Entity> actual = tabixRepository.findAll(tabixRepository.query().eq(CHROM, "13").and().eq(POS, 12)); Entity e1 = new MapEntity(entityMetaData); e1.set("ID", "id2"); e1.set("#CHROM", "13"); e1.set("POS", 12l); e1.set("Description", "yup"); Entity e2 = new MapEntity(entityMetaData); e2.set("ID", "id3"); e2.set("#CHROM", "13"); e2.set("POS", 12l); e2.set("Description", "yup"); assertEquals(Lists.newArrayList(actual), Arrays.asList(e1, e2)); }
/** * Uses the map containing the parsed OMIM map to create a list of {@link Entity} * * @param omimEntriesByGeneSymbol * @param geneSymbol */ private void addEntityToGeneEntityList( Map<String, List<List<String>>> omimEntriesByGeneSymbol, String geneSymbol) { Entity entity = new MapEntity(getEntityMetaData()); entity.set(OMIM_GENE_SYMBOLS_COL_NAME, geneSymbol); entity.set(OMIM_PHENOTYPE_COL_NAME, join(omimEntriesByGeneSymbol.get(geneSymbol).get(0), ",")); entity.set(OMIM_MIM_NUMBER_COL_NAME, join(omimEntriesByGeneSymbol.get(geneSymbol).get(1), ",")); entity.set( OMIM_CYTO_LOCATION_COL_NAME, join(omimEntriesByGeneSymbol.get(geneSymbol).get(2), ",")); entity.set(OMIM_TYPE_COL_NAME, join(omimEntriesByGeneSymbol.get(geneSymbol).get(3), ",")); entity.set(OMIM_ENTRY_COL_NAME, join(omimEntriesByGeneSymbol.get(geneSymbol).get(4), ",")); List<Entity> entities = entitiesByGeneSymbol.get(geneSymbol); if (entities == null) { entities = new ArrayList<>(); entitiesByGeneSymbol.put(geneSymbol, entities); } entities.add(entity); }
@Override public void set(String attributeName, Object value) { decoratedEntity.set(attributeName, value); }
@Test public void resolveSelfReferences() { DefaultEntityMetaData emd = new DefaultEntityMetaData("Person"); emd.addAttribute("name").setIdAttribute(true).setNillable(false); emd.addAttribute("father") .setDataType(MolgenisFieldTypes.XREF) .setNillable(true) .setRefEntity(emd); emd.addAttribute("mother") .setDataType(MolgenisFieldTypes.XREF) .setNillable(true) .setRefEntity(emd); Entity piet = new MapEntity("name"); piet.set("name", "Piet"); Entity klaas = new MapEntity("name"); klaas.set("name", "Klaas"); klaas.set("father", "Piet"); klaas.set("mother", "Katrijn"); Entity jan = new MapEntity("name"); jan.set("name", "Jan"); jan.set("father", "Piet"); jan.set("mother", "Marie"); Entity katrijn = new MapEntity("name"); katrijn.set("name", "Katrijn"); katrijn.set("father", "Jan"); katrijn.set("mother", "Marie"); Entity marie = new MapEntity("name"); marie.set("name", "Marie"); Repository repo = mock(Repository.class); when(repo.getName()).thenReturn("Person"); when(repo.findOne("Piet")).thenReturn(piet); when(repo.findOne("Jan")).thenReturn(jan); when(repo.findOne("Marie")).thenReturn(marie); when(repo.findOne("Katrijn")).thenReturn(katrijn); DataServiceImpl ds = new DataServiceImpl(); ds.addRepository(repo); Iterable<Entity> entities = Arrays.<Entity>asList( new DefaultEntity(emd, ds, piet), new DefaultEntity(emd, ds, klaas), new DefaultEntity(emd, ds, jan), new DefaultEntity(emd, ds, katrijn), new DefaultEntity(emd, ds, marie)); Iterable<Entity> sorted = new DependencyResolver().resolveSelfReferences(entities, emd); List<Entity> sortedList = Lists.newArrayList(sorted); assertEquals(sortedList.size(), 5); assertEquals(sortedList.get(0).getIdValue(), "Marie"); assertEquals(sortedList.get(1).getIdValue(), "Piet"); assertEquals(sortedList.get(2).getIdValue(), "Jan"); assertEquals(sortedList.get(3).getIdValue(), "Katrijn"); assertEquals(sortedList.get(4).getIdValue(), "Klaas"); }
@Override public void updateTestEntity(Entity entity) throws Exception { entity.set("col2", sdf.parse("2013-02-09 13:00:00")); }
@Override public void set(Entity values) { decoratedEntity.set(values); }
@RequestMapping( value = "/verify", method = RequestMethod.POST, headers = "Content-Type=multipart/form-data") public void verify( @RequestParam(value = "selectedDataSet", required = false) String selectedDataSetId, @RequestParam Part file, HttpServletResponse response, Model model) throws IOException { EntitySource reader = null; ExcelWriter<Entity> excelWriterRanks = null; try { if (selectedDataSetId != null) { String origFileName = FileUploadUtils.getOriginalFileName(file); File uploadFile = fileStore.store(file.getInputStream(), origFileName); response.setContentType("application/vnd.ms-excel"); response.addHeader( "Content-Disposition", "attachment; filename=" + getCsvFileName(file.getName() + "-ranks")); excelWriterRanks = new ExcelWriter<Entity>(response.getOutputStream()); excelWriterRanks.addCellProcessor(new LowerCaseProcessor(true, false)); Writable<Entity> sheetWriterRank = null; Writable<Entity> sheetWriterRankStatistics = null; Writable<Entity> sheetWriteBiobankRanks = null; Writable<Entity> sheetWriteSpssInput = null; reader = new ExcelEntitySourceFactory().create(uploadFile); Repository<? extends Entity> inputSheet = reader.getRepositoryByEntityName("Sheet1"); List<String> biobankNames = new ArrayList<String>(); for (AttributeMetaData attr : inputSheet.getAttributes()) { biobankNames.add(attr.getName()); } String firstColumn = biobankNames.get(0); biobankNames.remove(0); // First column has to correspond to the selected dataset DataSet ds = dataService.findOne(DataSet.ENTITY_NAME, Integer.parseInt(selectedDataSetId)); if (ds.getName().equalsIgnoreCase(firstColumn)) { Map<String, Map<String, List<String>>> maunalMappings = new HashMap<String, Map<String, List<String>>>(); for (Entity row : inputSheet) { String variableName = row.getString(firstColumn); if (!maunalMappings.containsKey(variableName)) maunalMappings.put(variableName, new HashMap<String, List<String>>()); for (String biobank : biobankNames) { if (row.get(biobank) != null) { String mappingString = row.get(biobank).toString(); if (!maunalMappings.containsKey(variableName)) { maunalMappings.put(variableName, new HashMap<String, List<String>>()); } if (!maunalMappings.get(variableName).containsKey(biobank.toLowerCase())) { maunalMappings .get(variableName) .put(biobank.toLowerCase(), new ArrayList<String>()); } maunalMappings .get(variableName) .get(biobank.toLowerCase()) .addAll(Arrays.asList(mappingString.split(","))); } } } List<String> lowerCaseBiobankNames = new ArrayList<String>(); for (String element : biobankNames) { lowerCaseBiobankNames.add(element.toLowerCase()); } List<DataSet> dataSets = dataService.findAllAsList( DataSet.ENTITY_NAME, new QueryImpl().in(DataSet.NAME, lowerCaseBiobankNames)); lowerCaseBiobankNames.add(0, firstColumn.toLowerCase()); sheetWriterRank = excelWriterRanks.createWritable("result", lowerCaseBiobankNames); Map<String, Map<String, List<Integer>>> rankCollection = new HashMap<String, Map<String, List<Integer>>>(); List<Object> allRanks = new ArrayList<Object>(); for (Entry<String, Map<String, List<String>>> entry : maunalMappings.entrySet()) { String variableName = entry.getKey(); List<String> ranks = new ArrayList<String>(); ranks.add(variableName); Map<String, List<String>> mappingDetail = entry.getValue(); List<ObservableFeature> features = dataService.findAllAsList( ObservableFeature.ENTITY_NAME, new QueryImpl().eq(ObservableFeature.NAME, variableName)); String description = features.get(0).getDescription(); if (!rankCollection.containsKey(description)) rankCollection.put(description, new HashMap<String, List<Integer>>()); if (!features.isEmpty()) { Entity row = new MapEntity(); row.set(firstColumn.toLowerCase(), description); for (DataSet dataSet : dataSets) { List<Integer> ranksBiobank = new ArrayList<Integer>(); if (mappingDetail.containsKey(dataSet.getName().toLowerCase())) { Map<String, Hit> mappedFeatureIds = findFeaturesFromIndex( "name", mappingDetail.get(dataSet.getName().toLowerCase()), dataSet.getId()); String mappingDataSetIdentifier = SecurityUtils.getCurrentUsername() + "-" + selectedDataSetId + "-" + dataSet.getId(); Query q = new QueryImpl() .eq("store_mapping_feature", features.get(0).getId()) .pageSize(50) .sort(new Sort(Direction.DESC, "store_mapping_score")); SearchRequest searchRequest = new SearchRequest(mappingDataSetIdentifier, q, null); SearchResult result = searchService.search(searchRequest); if (mappedFeatureIds.size() == 0) { row.set(dataSet.getName().toLowerCase(), "N/A2"); continue; } List<String> ids = new ArrayList<String>(); for (Hit hit : result.getSearchHits()) { Map<String, Object> columnValueMap = hit.getColumnValueMap(); ids.add(columnValueMap.get("store_mapping_mapped_feature").toString()); } Map<String, Hit> featureInfos = findFeaturesFromIndex("id", ids, dataSet.getId()); String previousDescription = null; int rank = 0; for (Hit hit : result.getSearchHits()) { Map<String, Object> columnValueMap = hit.getColumnValueMap(); String mappedFeatureId = columnValueMap.get("store_mapping_mapped_feature").toString(); String mappedFeatureDescription = featureInfos .get(mappedFeatureId) .getColumnValueMap() .get("description") .toString() .replaceAll("[^0-9a-zA-Z ]", " "); rank++; if (previousDescription != null && previousDescription.equalsIgnoreCase(mappedFeatureDescription)) rank--; if (mappedFeatureIds.containsKey(mappedFeatureId)) { ranksBiobank.add(rank); allRanks.add(rank); mappedFeatureIds.remove(mappedFeatureId); } previousDescription = mappedFeatureDescription; } if (mappedFeatureIds.size() == 0) { String output = StringUtils.join(ranksBiobank, ','); if (ranksBiobank.size() > 1) { output += " (" + averageRank(ranksBiobank) + ")"; } row.set(dataSet.getName().toLowerCase(), output); } else { for (int i = 0; i < mappedFeatureIds.size(); i++) allRanks.add("Not mapped"); row.set(dataSet.getName().toLowerCase(), "Not mapped"); ranksBiobank.clear(); } } else row.set(dataSet.getName().toLowerCase(), "N/A1"); rankCollection.get(description).put(dataSet.getName().toLowerCase(), ranksBiobank); } sheetWriterRank.add(row); } } Map<String, List<Integer>> rankCollectionPerBiobank = new HashMap<String, List<Integer>>(); { sheetWriterRankStatistics = excelWriterRanks.createWritable( "rank statistics", Arrays.asList( firstColumn.toLowerCase(), "average rank", "round-up rank", "median rank", "minium", "maximum")); for (Entry<String, Map<String, List<Integer>>> entry : rankCollection.entrySet()) { String variableName = entry.getKey(); Entity row = new MapEntity(); row.set(firstColumn.toLowerCase(), variableName); List<Integer> rankAllBiobanks = new ArrayList<Integer>(); for (Entry<String, List<Integer>> rankBiobanks : entry.getValue().entrySet()) { if (!rankCollectionPerBiobank.containsKey(rankBiobanks.getKey())) rankCollectionPerBiobank.put(rankBiobanks.getKey(), new ArrayList<Integer>()); rankCollectionPerBiobank.get(rankBiobanks.getKey()).addAll(rankBiobanks.getValue()); rankAllBiobanks.addAll(rankBiobanks.getValue()); } row.set("average rank", averageRank(rankAllBiobanks)); row.set("round-up rank", Math.ceil(averageRank(rankAllBiobanks))); Collections.sort(rankAllBiobanks); if (!rankAllBiobanks.isEmpty()) { row.set("minium", rankAllBiobanks.get(0)); row.set("maximum", rankAllBiobanks.get(rankAllBiobanks.size() - 1)); double medianRank = 0; if (rankAllBiobanks.size() % 2 == 0) { medianRank = (double) (rankAllBiobanks.get(rankAllBiobanks.size() / 2 - 1) + rankAllBiobanks.get(rankAllBiobanks.size() / 2)) / 2; } else { medianRank = rankAllBiobanks.get(rankAllBiobanks.size() / 2); } row.set("median rank", medianRank); } sheetWriterRankStatistics.add(row); } } { lowerCaseBiobankNames.remove(0); sheetWriteBiobankRanks = excelWriterRanks.createWritable("biobank average ranks", lowerCaseBiobankNames); Entity entity = new MapEntity(); for (Entry<String, List<Integer>> entry : rankCollectionPerBiobank.entrySet()) { entity.set(entry.getKey(), averageRank(entry.getValue())); } sheetWriteBiobankRanks.add(entity); } { sheetWriteSpssInput = excelWriterRanks.createWritable("spss ranks", Arrays.asList("rank")); for (Object rank : allRanks) { Entity entity = new MapEntity("rank", rank); sheetWriteSpssInput.add(entity); } } } } } finally { if (reader != null) reader.close(); if (excelWriterRanks != null) IOUtils.closeQuietly(excelWriterRanks); } }
@Override public void updateTestEntity(Entity entity) throws Exception { entity.set("col1", "ONE"); }
@Override public void populateTestEntity(Entity entity) throws Exception { entity.set("identifier", "ONE"); entity.set("col1", "TWO"); }