@GetMapping("/uml") public String getUml(@RequestParam(value = "package") String selectedPackageName, Model model) { Package molgenisPackage = metaDataService.getPackage(selectedPackageName); if (molgenisPackage != null) { model.addAttribute("molgenisPackage", molgenisPackage); } return "view-standardsregistry_uml"; }
@Override public EditorEntityTypeResponse getEditorEntityType(String entityTypeId) { EntityType entityType = metadataService .getEntityType(entityTypeId) .orElseThrow(() -> new UnknownEntityTypeException(entityTypeId)); return createEntityTypeResponse( entityType, metadataService .getReferringAttributes(entityTypeId) .filter(EntityTypeUtils::isSingleReferenceType) .collect(toList())); }
/** @return the first writable package */ private Optional<Package> getParentPackage() { return metaDataService.getPackages().stream().filter(this::isWritablePackage).findFirst(); }
@GetMapping("/details") public String showView(@RequestParam(value = "package", required = false) String selectedPackageName, Model model) { if (selectedPackageName == null) { List<Package> packages = Lists.newArrayList(metaDataService.getRootPackages()); selectedPackageName = packages.get(0).getId(); } model.addAttribute("tagService", tagService); model.addAttribute("selectedPackageName", selectedPackageName); model.addAttribute("package", metaDataService.getPackage(selectedPackageName)); return VIEW_NAME_DETAILS; }
dataService .getMeta() .getEntityType(entityTypeId) .orElseThrow(() -> new UnknownEntityTypeException(entityTypeId)); targetMetadata.setPackage(entityType.getPackage()); dataService .getMeta() .getPackage(packageId) .orElseThrow(() -> new UnknownEntityException(PACKAGE, packageId)); targetMetadata.setPackage(aPackage);
EntityType entityType = dataService.getMeta().getEntityType(repository.getName()); Repository externalRepository = dataService.getMeta().createRepository(targetMetaData); permissionSystemService.giveUserWriteMetaPermissions(targetMetaData); runAsSystem(() -> dataService.getMeta().updateEntityType(externalRepository.getEntityType())); .updateEntityType( addAnnotatorMetaDataToRepositories(entityType, attributeFactory, annotator)));
Package aPackage = metaDataService .getPackage(fullyQualifiedPackageName) .orElseGet(() -> createPackage(fullyQualifiedPackageName)); aPackage.setLabel(packageName); aPackage.setParent(parentPackage); metaDataService.addPackage(aPackage); metaDataService.addEntityType(entityType);
public Stream<EntityType> getCompatibleEntityTypes(EntityType target) { return dataService.getMeta().getEntityTypes().filter(candidate -> !candidate.isAbstract()) .filter(isCompatible(target)); }
private EntityType getEntityType(String id) { return metaDataService.getEntityType(id).orElseThrow(() -> new UnknownEntityTypeException(id)); }
private void deleteRepository(String entityTypeId) { try { dataService.getMeta().deleteEntityType(entityTypeId); LOG.info("Deleted repository {}", entityTypeId); } catch (Exception ex) { LOG.error("Failed to delete existing writable repository {}", entityTypeId); } }
private EntityType persistEntityType(EntityType copy) { dataService.getMeta().addEntityType(copy); return copy; }
private Repository<Entity> addTargetEntityType(EntityType targetMetadata) { Repository<Entity> targetRepo = dataService.getMeta().createRepository(targetMetadata); permissionSystemService.giveUserWriteMetaPermissions(targetMetadata); return targetRepo; }
private EntityType pasteDefaultValues(EntityType copy, CopyState state) { stream(copy.getAtomicAttributes()) .filter(EntityTypeUtils::isReferenceType) .forEach( attr -> attr.setDefaultValue( state.referenceDefaultValues().getOrDefault(attr.getIdentifier(), null))); dataService.getMeta().updateEntityType(copy); return copy; }
/** Public for testability */ public Stream<EntityType> getCompatibleEntityTypes(EntityType target) { return dataService .getMeta() .getEntityTypes() .filter(candidate -> !candidate.isAbstract()) .filter(isCompatible(target)); }
@Override public Map<Attribute, Hit<OntologyTerm>> findTags(String entity, List<String> ontologyIds) { Map<Attribute, Hit<OntologyTerm>> result = new LinkedHashMap<Attribute, Hit<OntologyTerm>>(); EntityType emd = metaDataService.getEntityType(entity); for (Attribute amd : emd.getAtomicAttributes()) { Hit<OntologyTerm> tag = findTags(amd, ontologyIds); if (tag != null) { result.put(amd, tag); } } return result; }
private void deleteMetaInternal(String entityTypeId) { dataService.getMeta().deleteEntityType(entityTypeId); }
private void createInputRepository(Repository<Entity> inputRepository) { // Add the original input dataset to database dataService.getMeta().addEntityType(inputRepository.getEntityType()); Repository<Entity> target = dataService.getRepository(inputRepository.getName()); inputRepository.forEachBatched(entities -> target.add(entities.stream()), BATCH_SIZE); }
private Repository<Entity> addTargetEntityType(EntityType targetMetadata) { Repository<Entity> targetRepo = runAsSystem(() -> dataService.getMeta().createRepository(targetMetadata)); permissionSystemService.giveUserWriteMetaPermissions(targetMetadata); return targetRepo; }
@GetMapping("/documentation/{packageName}") public String getModelDocumentation(@PathVariable("packageName") String packageName, @RequestParam(value = "embed", required = false) Boolean embed, Model model) { Package aPackage = metaDataService.getPackage(packageName); model.addAttribute("package", aPackage); model.addAttribute("tagService", tagService); return VIEW_NAME_DOCUMENTATION_EMBED; }
@Override public List<EditorPackageIdentifier> getEditorPackages() { return createPackageListResponse(metadataService.getPackages()); }