use of de.tudarmstadt.ukp.clarin.webanno.export.model.ExportedTagSet in project webanno by webanno.
the class JsonImportUtil method importTagSetFromJsonWithOverwrite.
/**
* Works for scenarios with overwrite enabled Checks if tagset already exists, then overwrites
* otherwise works normally
*/
public static TagSet importTagSetFromJsonWithOverwrite(Project project, InputStream tagInputStream, AnnotationSchemaService aAnnotationService) throws IOException {
String text = IOUtils.toString(tagInputStream, "UTF-8");
ExportedTagSet importedTagSet = JSONUtil.getJsonConverter().getObjectMapper().readValue(text, ExportedTagSet.class);
if (aAnnotationService.existsTagSet(importedTagSet.getName(), project)) {
// A tagset exists so we'll have to replace it
return replaceTagSet(project, importedTagSet, aAnnotationService);
} else {
// Proceed normally
return createTagSet(project, importedTagSet, aAnnotationService);
}
}
use of de.tudarmstadt.ukp.clarin.webanno.export.model.ExportedTagSet in project webanno by webanno.
the class ExportUtil method exportProjectSettings.
public static de.tudarmstadt.ukp.clarin.webanno.export.model.Project exportProjectSettings(AnnotationSchemaService annotationService, Optional<AutomationService> automationService, DocumentService documentService, ProjectService projectService, Project aProject, File aProjectSettings, File aExportTempDir) {
de.tudarmstadt.ukp.clarin.webanno.export.model.Project exProjekt = new de.tudarmstadt.ukp.clarin.webanno.export.model.Project();
exProjekt.setDescription(aProject.getDescription());
exProjekt.setName(aProject.getName());
// In older versions of WebAnno, the mode was an enum which was serialized as upper-case
// during export but as lower-case in the database. This is compensating for this case.
exProjekt.setMode(StringUtils.upperCase(aProject.getMode(), Locale.US));
exProjekt.setScriptDirection(aProject.getScriptDirection());
exProjekt.setVersion(aProject.getVersion());
exProjekt.setDisableExport(aProject.isDisableExport());
exProjekt.setCreated(aProject.getCreated());
exProjekt.setUpdated(aProject.getUpdated());
List<de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationLayer> exLayers = new ArrayList<>();
// Store map of layer and its equivalent exLayer so that the attach type is attached later
Map<AnnotationLayer, de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationLayer> layerToExLayers = new HashMap<>();
// Store map of feature and its equivalent exFeature so that the attach feature is attached
// later
Map<AnnotationFeature, de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature> featureToExFeatures = new HashMap<>();
for (AnnotationLayer layer : annotationService.listAnnotationLayer(aProject)) {
exLayers.add(ImportUtil.exportLayerDetails(layerToExLayers, featureToExFeatures, layer, annotationService));
}
// exported feature
for (AnnotationLayer layer : layerToExLayers.keySet()) {
if (layer.getAttachType() != null) {
layerToExLayers.get(layer).setAttachType(layerToExLayers.get(layer.getAttachType()));
}
if (layer.getAttachFeature() != null) {
layerToExLayers.get(layer).setAttachFeature(featureToExFeatures.get(layer.getAttachFeature()));
}
}
exProjekt.setLayers(exLayers);
List<ExportedTagSet> extTagSets = new ArrayList<>();
for (TagSet tagSet : annotationService.listTagSets(aProject)) {
ExportedTagSet exTagSet = new ExportedTagSet();
exTagSet.setCreateTag(tagSet.isCreateTag());
exTagSet.setDescription(tagSet.getDescription());
exTagSet.setLanguage(tagSet.getLanguage());
exTagSet.setName(tagSet.getName());
List<ExportedTag> exTags = new ArrayList<>();
for (Tag tag : annotationService.listTags(tagSet)) {
ExportedTag exTag = new ExportedTag();
exTag.setDescription(tag.getDescription());
exTag.setName(tag.getName());
exTags.add(exTag);
}
exTagSet.setTags(exTags);
extTagSets.add(exTagSet);
}
exProjekt.setTagSets(extTagSets);
List<SourceDocument> sourceDocuments = new ArrayList<>();
List<AnnotationDocument> annotationDocuments = new ArrayList<>();
// add source documents to a project
List<de.tudarmstadt.ukp.clarin.webanno.model.SourceDocument> documents = documentService.listSourceDocuments(aProject);
for (de.tudarmstadt.ukp.clarin.webanno.model.SourceDocument sourceDocument : documents) {
SourceDocument exDocument = new SourceDocument();
exDocument.setFormat(sourceDocument.getFormat());
exDocument.setName(sourceDocument.getName());
exDocument.setState(sourceDocument.getState());
exDocument.setTimestamp(sourceDocument.getTimestamp());
exDocument.setSentenceAccessed(sourceDocument.getSentenceAccessed());
exDocument.setCreated(sourceDocument.getCreated());
exDocument.setUpdated(sourceDocument.getUpdated());
// add annotation document to Project
for (de.tudarmstadt.ukp.clarin.webanno.model.AnnotationDocument annotationDocument : documentService.listAnnotationDocuments(sourceDocument)) {
AnnotationDocument annotationDocumentToExport = new AnnotationDocument();
annotationDocumentToExport.setName(annotationDocument.getName());
annotationDocumentToExport.setState(annotationDocument.getState());
annotationDocumentToExport.setUser(annotationDocument.getUser());
annotationDocumentToExport.setTimestamp(annotationDocument.getTimestamp());
annotationDocumentToExport.setSentenceAccessed(annotationDocument.getSentenceAccessed());
annotationDocumentToExport.setCreated(annotationDocument.getCreated());
annotationDocumentToExport.setUpdated(annotationDocument.getUpdated());
annotationDocuments.add(annotationDocumentToExport);
}
sourceDocuments.add(exDocument);
}
exProjekt.setSourceDocuments(sourceDocuments);
exProjekt.setAnnotationDocuments(annotationDocuments);
if (automationService.isPresent()) {
List<de.tudarmstadt.ukp.clarin.webanno.export.model.TrainingDocument> trainDocuments = new ArrayList<>();
List<TrainingDocument> trainingDocuments = automationService.get().listTrainingDocuments(aProject);
Map<String, de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature> fm = new HashMap<>();
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature f : featureToExFeatures.values()) {
fm.put(f.getName(), f);
}
for (TrainingDocument trainingDocument : trainingDocuments) {
de.tudarmstadt.ukp.clarin.webanno.export.model.TrainingDocument exDocument = new de.tudarmstadt.ukp.clarin.webanno.export.model.TrainingDocument();
exDocument.setFormat(trainingDocument.getFormat());
exDocument.setName(trainingDocument.getName());
exDocument.setState(trainingDocument.getState());
exDocument.setTimestamp(trainingDocument.getTimestamp());
exDocument.setSentenceAccessed(trainingDocument.getSentenceAccessed());
if (trainingDocument.getFeature() != null) {
exDocument.setFeature(fm.get(trainingDocument.getFeature().getName()));
}
trainDocuments.add(exDocument);
}
exProjekt.setTrainingDocuments(trainDocuments);
} else {
exProjekt.setTrainingDocuments(new ArrayList<>());
}
List<ProjectPermission> projectPermissions = new ArrayList<>();
// add project permissions to the project
for (User user : projectService.listProjectUsersWithPermissions(aProject)) {
for (de.tudarmstadt.ukp.clarin.webanno.model.ProjectPermission permission : projectService.listProjectPermissionLevel(user, aProject)) {
ProjectPermission permissionToExport = new ProjectPermission();
permissionToExport.setLevel(permission.getLevel());
permissionToExport.setUser(user.getUsername());
projectPermissions.add(permissionToExport);
}
}
exProjekt.setProjectPermissions(projectPermissions);
// export automation Mira template
if (automationService.isPresent()) {
List<de.tudarmstadt.ukp.clarin.webanno.export.model.MiraTemplate> exTemplates = new ArrayList<>();
for (MiraTemplate template : automationService.get().listMiraTemplates(aProject)) {
de.tudarmstadt.ukp.clarin.webanno.export.model.MiraTemplate exTemplate = new de.tudarmstadt.ukp.clarin.webanno.export.model.MiraTemplate();
exTemplate.setAnnotateAndPredict(template.isAnnotateAndRepeat());
exTemplate.setAutomationStarted(template.isAutomationStarted());
exTemplate.setCurrentLayer(template.isCurrentLayer());
exTemplate.setResult(template.getResult());
exTemplate.setTrainFeature(featureToExFeatures.get(template.getTrainFeature()));
if (template.getOtherFeatures().size() > 0) {
Set<de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature> exOtherFeatures = new HashSet<>();
for (AnnotationFeature feature : template.getOtherFeatures()) {
exOtherFeatures.add(featureToExFeatures.get(feature));
}
exTemplate.setOtherFeatures(exOtherFeatures);
}
exTemplates.add(exTemplate);
}
exProjekt.setMiraTemplates(exTemplates);
} else {
exProjekt.setMiraTemplates(new ArrayList<>());
}
return exProjekt;
}
use of de.tudarmstadt.ukp.clarin.webanno.export.model.ExportedTagSet in project webanno by webanno.
the class ImportUtil method createTagSet.
private static TagSet createTagSet(Project project, User user, ExportedTagSet importedTagSet, AnnotationSchemaService aAnnotationService) throws IOException {
String importedTagSetName = importedTagSet.getName();
if (aAnnotationService.existsTagSet(importedTagSetName, project)) {
// aAnnotationService.removeTagSet(aAnnotationService.getTagSet(
// importedTagSet.getName(), project));
// Rename Imported TagSet instead of deleting the old one.
importedTagSetName = JsonImportUtil.copyTagSetName(aAnnotationService, importedTagSetName, project);
}
TagSet newTagSet = new TagSet();
newTagSet.setDescription(importedTagSet.getDescription());
newTagSet.setName(importedTagSetName);
newTagSet.setLanguage(importedTagSet.getLanguage());
newTagSet.setProject(project);
aAnnotationService.createTagSet(newTagSet);
for (ExportedTag tag : importedTagSet.getTags()) {
Tag newTag = new Tag();
newTag.setDescription(tag.getDescription());
newTag.setName(tag.getName());
newTag.setTagSet(newTagSet);
aAnnotationService.createTag(newTag);
}
return newTagSet;
}
use of de.tudarmstadt.ukp.clarin.webanno.export.model.ExportedTagSet in project webanno by webanno.
the class ImportUtil method createLayer.
/**
* Create a {@link TagSet} for the imported project,
*
* @param aProjecct a project.
* @param aImportedProjectSetting the settings.
* @param aRepository the repository service.
* @param aAnnotationService the annotation service.
* @return hum?
* @throws IOException if an I/O error occurs.
*/
public static Map<String, AnnotationFeature> createLayer(Project aProjecct, de.tudarmstadt.ukp.clarin.webanno.export.model.Project aImportedProjectSetting, UserDao aRepository, AnnotationSchemaService aAnnotationService) throws IOException {
User user = aRepository.getCurrentUser();
List<ExportedTagSet> importedTagSets = aImportedProjectSetting.getTagSets();
if (aImportedProjectSetting.getVersion() == 0) {
// this is projects prior to version 2.0
createV0TagSet(aProjecct, importedTagSets, aAnnotationService, user);
return new HashMap<>();
}
return createV1Layer(aProjecct, aImportedProjectSetting, aAnnotationService, user);
}
use of de.tudarmstadt.ukp.clarin.webanno.export.model.ExportedTagSet in project webanno by webanno.
the class ImportUtil method createV1Layer.
private static Map<String, AnnotationFeature> createV1Layer(Project aProject, de.tudarmstadt.ukp.clarin.webanno.export.model.Project aImportedProjectSetting, AnnotationSchemaService aAnnotationService, User aUser) throws IOException {
Map<String, AnnotationFeature> featuresMap = new HashMap<>();
Map<de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationLayer, AnnotationLayer> layersMap = new HashMap<>();
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationLayer exLayer : aImportedProjectSetting.getLayers()) {
if (aAnnotationService.existsLayer(exLayer.getName(), exLayer.getType(), aProject)) {
AnnotationLayer layer = aAnnotationService.getLayer(exLayer.getName(), aProject);
setLayer(aAnnotationService, layer, exLayer, aProject, aUser);
layersMap.put(exLayer, layer);
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature exfeature : exLayer.getFeatures()) {
if (aAnnotationService.existsFeature(exfeature.getName(), layer)) {
AnnotationFeature feature = aAnnotationService.getFeature(exfeature.getName(), layer);
setFeature(aAnnotationService, feature, exfeature, aProject, aUser);
featuresMap.put(exfeature.getName(), feature);
continue;
}
AnnotationFeature feature = new AnnotationFeature();
feature.setLayer(layer);
setFeature(aAnnotationService, feature, exfeature, aProject, aUser);
featuresMap.put(exfeature.getName(), feature);
}
} else {
AnnotationLayer layer = new AnnotationLayer();
setLayer(aAnnotationService, layer, exLayer, aProject, aUser);
layersMap.put(exLayer, layer);
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature exfeature : exLayer.getFeatures()) {
AnnotationFeature feature = new AnnotationFeature();
feature.setLayer(layer);
setFeature(aAnnotationService, feature, exfeature, aProject, aUser);
featuresMap.put(exfeature.getName(), feature);
}
}
}
for (ExportedTagSet exTagSet : aImportedProjectSetting.getTagSets()) {
TagSet tagSet = new TagSet();
createTagSet(tagSet, exTagSet, aProject, aUser, aAnnotationService);
}
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationLayer exLayer : aImportedProjectSetting.getLayers()) {
if (exLayer.getAttachType() != null) {
AnnotationLayer layer = aAnnotationService.getLayer(exLayer.getName(), aProject);
AnnotationLayer attachLayer = aAnnotationService.getLayer(exLayer.getAttachType().getName(), aProject);
layer.setAttachType(attachLayer);
aAnnotationService.createLayer(layersMap.get(exLayer));
}
if (exLayer.getAttachFeature() != null) {
layersMap.get(exLayer).setAttachFeature(featuresMap.get(exLayer.getAttachFeature().getName()));
aAnnotationService.createLayer(layersMap.get(exLayer));
}
for (de.tudarmstadt.ukp.clarin.webanno.export.model.AnnotationFeature eXFeature : exLayer.getFeatures()) {
if (eXFeature.getTagSet() != null) {
featuresMap.get(eXFeature.getName()).setTagset(aAnnotationService.getTagSet(eXFeature.getTagSet().getName(), aProject));
}
}
}
return featuresMap;
}
Aggregations