private JCas createCorrectionCas(
     JCas mergeJCas,
     BratAnnotatorModel aBratAnnotatorModel,
     AnnotationDocument randomAnnotationDocument)
     throws UIMAException, ClassNotFoundException, IOException {
   User userLoggedIn =
       userRepository.get(SecurityContextHolder.getContext().getAuthentication().getName());
   mergeJCas = repository.readAnnotationCas(aBratAnnotatorModel.getDocument(), userLoggedIn);
   repository.writeCorrectionCas(mergeJCas, randomAnnotationDocument.getDocument(), userLoggedIn);
   return mergeJCas;
 }
Esempio n. 2
0
  private void update(AjaxRequestTarget target) {
    JCas jCas = null;
    try {
      CuratorUtil.updatePanel(
          target,
          automateView,
          curationContainer,
          mergeVisualizer,
          repository,
          annotationSelectionByUsernameAndAddress,
          curationSegment,
          annotationService,
          userRepository);

      jCas = repository.readCorrectionCas(bModel.getDocument());
    } catch (UIMAException e) {
      error(ExceptionUtils.getRootCauseMessage(e));
    } catch (ClassNotFoundException e) {
      error(e.getMessage());
    } catch (IOException e) {
      error(e.getMessage());
    } catch (BratAnnotationException e) {
      error(e.getMessage());
    }

    gotoPageTextField.setModelObject(getFirstSentenceNumber(jCas, bModel.getSentenceAddress()) + 1);
    gotoPageAddress = getSentenceAddress(jCas, gotoPageTextField.getModelObject());

    target.add(gotoPageTextField);
    target.add(automateView);
    target.add(numberOfPages);
  }
  public Map<String, JCas> listJcasesforCuration(
      List<AnnotationDocument> annotationDocuments,
      AnnotationDocument randomAnnotationDocument,
      Mode aMode)
      throws UIMAException, ClassNotFoundException, IOException {
    Map<String, JCas> jCases = new HashMap<String, JCas>();
    for (AnnotationDocument annotationDocument : annotationDocuments) {
      String username = annotationDocument.getUser();

      if (!annotationDocument.getState().equals(AnnotationDocumentState.FINISHED)) {
        continue;
      }

      if (randomAnnotationDocument == null) {
        randomAnnotationDocument = annotationDocument;
      }

      // Upgrading should be an explicit action during the opening of a document at the end
      // of the open dialog - it must not happen during editing because the CAS addresses
      // are used as IDs in the UI
      // repository.upgradeCasAndSave(annotationDocument.getDocument(), aMode, username);
      JCas jCas = repository.readAnnotationCas(annotationDocument);
      jCases.put(username, jCas);
    }
    return jCases;
  }
  public Map<String, JCas> listJcasesforCorrection(
      AnnotationDocument randomAnnotationDocument, SourceDocument aDocument, Mode aMode)
      throws UIMAException, ClassNotFoundException, IOException {
    Map<String, JCas> jCases = new HashMap<String, JCas>();
    User user =
        userRepository.get(SecurityContextHolder.getContext().getAuthentication().getName());
    randomAnnotationDocument = repository.getAnnotationDocument(aDocument, user);

    // Upgrading should be an explicit action during the opening of a document at the end
    // of the open dialog - it must not happen during editing because the CAS addresses
    // are used as IDs in the UI
    // repository.upgradeCasAndSave(aDocument, aMode, user.getUsername());
    JCas jCas = repository.readAnnotationCas(randomAnnotationDocument);
    jCases.put(user.getUsername(), jCas);
    return jCases;
  }
Esempio n. 5
0
  public void updatePanel(AjaxRequestTarget aTarget, CurationContainer aCC)
      throws UIMAException, ClassNotFoundException, IOException, BratAnnotationException {
    JCas jCas = repository.readCurationCas(bModel.getDocument());

    final int sentenceAddress =
        getAddr(
            selectSentenceAt(jCas, bModel.getSentenceBeginOffset(), bModel.getSentenceEndOffset()));
    bModel.setSentenceAddress(sentenceAddress);

    final Sentence sentence = selectByAddr(jCas, Sentence.class, sentenceAddress);
    List<Sentence> followingSentences =
        selectFollowing(jCas, Sentence.class, sentence, bModel.getPreferences().getWindowSize());
    // Check also, when getting the last sentence address in the display window, if this is the
    // last sentence or the ONLY sentence in the document
    Sentence lastSentenceAddressInDisplayWindow =
        followingSentences.size() == 0
            ? sentence
            : followingSentences.get(followingSentences.size() - 1);
    if (curationView == null) {
      curationView = new SourceListView();
    }
    curationView.setCurationBegin(sentence.getBegin());
    curationView.setCurationEnd(lastSentenceAddressInDisplayWindow.getEnd());

    int ws = bModel.getPreferences().getWindowSize();
    Sentence fs =
        BratAjaxCasUtil.selectSentenceAt(
            jCas, bModel.getSentenceBeginOffset(), bModel.getSentenceEndOffset());
    int l = BratAjaxCasUtil.getLastSentenceAddressInDisplayWindow(jCas, getAddr(fs), ws);
    Sentence ls = (Sentence) selectByAddr(jCas, FeatureStructure.class, l);
    fSn = BratAjaxCasUtil.getSentenceNumber(jCas, fs.getBegin());
    lSn = BratAjaxCasUtil.getSentenceNumber(jCas, ls.getBegin());

    sentencesListView.addOrReplace(sentenceList);
    aTarget.add(sentencesListView);

    /*
     * corssSentAnnoView.addOrReplace(crossSentAnnoList); aTarget.add(corssSentAnnoView);
     */
    aTarget.add(suggestionViewPanel);
    if (annotate) {
      annotator.bratRender(aTarget, editor.getCas(bModel));
      annotator.bratSetHighlight(aTarget, bModel.getSelection().getAnnotation());

    } else {
      annotator.bratRenderLater(aTarget);
    }
    annotate = false;
    CuratorUtil.updatePanel(
        aTarget,
        suggestionViewPanel,
        aCC,
        annotator,
        repository,
        annotationSelectionByUsernameAndAddress,
        curationView,
        annotationService,
        userRepository);
  }
  /**
   * Fetches the CAS that the user will be able to edit. In AUTOMATION/CORRECTION mode, this is the
   * CAS for the CORRECTION_USER and in CURATION mode it is the CAS for the CURATION user.
   *
   * @param aBratAnnotatorModel the model.
   * @param aDocument the source document.
   * @param jCases the JCases.
   * @param randomAnnotationDocument an annotation document.
   * @return the JCas.
   * @throws UIMAException hum?
   * @throws ClassNotFoundException hum?
   * @throws IOException if an I/O error occurs.
   * @throws BratAnnotationException hum?
   */
  public JCas getMergeCas(
      BratAnnotatorModel aBratAnnotatorModel,
      SourceDocument aDocument,
      Map<String, JCas> jCases,
      AnnotationDocument randomAnnotationDocument)
      throws UIMAException, ClassNotFoundException, IOException, BratAnnotationException {
    JCas mergeJCas = null;
    try {
      if (aBratAnnotatorModel.getMode().equals(Mode.AUTOMATION)
          || aBratAnnotatorModel.getMode().equals(Mode.CORRECTION)) {
        // Upgrading should be an explicit action during the opening of a document at the
        // end
        // of the open dialog - it must not happen during editing because the CAS addresses
        // are used as IDs in the UI
        // repository.upgradeCasAndSave(aDocument, aBratAnnotatorModel.getMode(),
        // aBratAnnotatorModel.getUser().getUsername());
        mergeJCas = repository.readCorrectionCas(aDocument);
      } else {
        // Upgrading should be an explicit action during the opening of a document at the
        // end
        // of the open dialog - it must not happen during editing because the CAS addresses
        // are used as IDs in the UI
        // repository.upgradeCasAndSave(aDocument, aBratAnnotatorModel.getMode(),
        // aBratAnnotatorModel.getUser().getUsername());
        mergeJCas = repository.readCurationCas(aDocument);
      }
    }
    // Create jcas, if it could not be loaded from the file system
    catch (Exception e) {

      if (aBratAnnotatorModel.getMode().equals(Mode.AUTOMATION)
          || aBratAnnotatorModel.getMode().equals(Mode.CORRECTION)) {
        mergeJCas = createCorrectionCas(mergeJCas, aBratAnnotatorModel, randomAnnotationDocument);
      } else {
        mergeJCas =
            createCurationCas(
                aBratAnnotatorModel.getProject(),
                randomAnnotationDocument,
                jCases,
                aBratAnnotatorModel.getAnnotationLayers());
      }
    }
    return mergeJCas;
  }
  /**
   * Set annotation preferences of users for a given project such as window size, annotation
   * layers,... reading from the file system.
   *
   * @param aUsername The {@link User} for whom we need to read the preference (preferences are
   *     stored per user)
   * @param aRepositoryService the repository service.
   * @param aAnnotationService the annotation service.
   * @param aBModel The {@link BratAnnotatorModel} that will be populated with preferences from the
   *     file
   * @param aMode the mode.
   * @throws BeansException hum?
   * @throws IOException hum?
   */
  public static void setAnnotationPreference(
      String aUsername,
      RepositoryService aRepositoryService,
      AnnotationService aAnnotationService,
      BratAnnotatorModel aBModel,
      Mode aMode)
      throws BeansException, IOException {
    AnnotationPreference preference = new AnnotationPreference();
    BeanWrapper wrapper = new BeanWrapperImpl(preference);
    // get annotation preference from file system
    try {
      Properties props = aRepositoryService.loadUserSettings(aUsername, aBModel.getProject());
      for (Entry<Object, Object> entry : props.entrySet()) {
        String property = entry.getKey().toString();
        int index = property.lastIndexOf(".");
        String propertyName = property.substring(index + 1);
        String mode = property.substring(0, index);
        if (wrapper.isWritableProperty(propertyName) && mode.equals(aMode.getName())) {
          if (AnnotationPreference.class.getDeclaredField(propertyName).getGenericType()
              instanceof ParameterizedType) {
            List<String> value =
                Arrays.asList(
                    StringUtils.replaceChars(entry.getValue().toString(), "[]", "").split(","));
            if (!value.get(0).equals("")) {
              wrapper.setPropertyValue(propertyName, value);
            }
          } else {
            wrapper.setPropertyValue(propertyName, entry.getValue());
          }
        }
      }
      aBModel.setPreferences(preference);

      // Get tagset using the id, from the properties file
      aBModel.getAnnotationLayers().clear();
      if (preference.getAnnotationLayers() != null) {
        for (Long id : preference.getAnnotationLayers()) {
          aBModel.getAnnotationLayers().add(aAnnotationService.getLayer(id));
        }
      } else {
        // If no layer preferences are defined, then just assume all layers are enabled
        List<AnnotationLayer> layers = aAnnotationService.listAnnotationLayer(aBModel.getProject());
        aBModel.setAnnotationLayers(layers);
      }
    }
    // no preference found
    catch (Exception e) {
      // If no layer preferences are defined, then just assume all layers are enabled
      List<AnnotationLayer> layers = aAnnotationService.listAnnotationLayer(aBModel.getProject());
      aBModel.setAnnotationLayers(layers);
    }
  }
  public static void savePreference(BratAnnotatorModel aBModel, RepositoryService aRepository)
      throws FileNotFoundException, IOException {
    AnnotationPreference preference = aBModel.getPreferences();
    ArrayList<Long> layers = new ArrayList<Long>();

    for (AnnotationLayer layer : aBModel.getAnnotationLayers()) {
      layers.add(layer.getId());
    }
    preference.setAnnotationLayers(layers);

    String username = SecurityContextHolder.getContext().getAuthentication().getName();
    aRepository.saveUserSettings(username, aBModel.getProject(), aBModel.getMode(), preference);
  }
  /**
   * For the first time a curation page is opened, create a MergeCas that contains only agreeing
   * annotations Using the CAS of the curator user.
   *
   * @param aProject the project
   * @param randomAnnotationDocument an annotation document.
   * @param jCases the JCases
   * @param aAnnotationLayers the layers.
   * @return the JCas.
   * @throws IOException if an I/O error occurs.
   */
  public JCas createCurationCas(
      Project aProject,
      AnnotationDocument randomAnnotationDocument,
      Map<String, JCas> jCases,
      List<AnnotationLayer> aAnnotationLayers)
      throws IOException {
    User userLoggedIn =
        userRepository.get(SecurityContextHolder.getContext().getAuthentication().getName());

    JCas mergeJCas = repository.readAnnotationCas(randomAnnotationDocument);
    jCases.put(CurationPanel.CURATION_USER, mergeJCas);

    List<Type> entryTypes = getEntryTypes(mergeJCas, aAnnotationLayers, annotationService);

    DiffResult diff =
        CasDiff2.doDiffSingle(
            annotationService,
            aProject,
            entryTypes,
            jCases,
            0,
            mergeJCas.getDocumentText().length());

    for (Entry<Position, ConfigurationSet> diffEntry :
        diff.getDifferingConfigurationSets().entrySet()) {
      // Remove FSes with differences from the merge CAS
      List<Configuration> cfgsForCurationUser =
          diffEntry.getValue().getConfigurations(CurationPanel.CURATION_USER);
      for (Configuration cfg : cfgsForCurationUser) {
        FeatureStructure fs = cfg.getFs(CurationPanel.CURATION_USER, jCases);
        mergeJCas.removeFsFromIndexes(fs);
      }
    }

    repository.writeCurationCas(mergeJCas, randomAnnotationDocument.getDocument(), userLoggedIn);
    return mergeJCas;
  }
Esempio n. 10
0
  private void addJCas(List<JCas> jCases, User user, SourceDocument sourceDocument) {
    try {
      // Check if there is an annotation document entry in the database. If there is none,
      // create one.
      AnnotationDocument annotationDocument =
          repository.createOrGetAnnotationDocument(sourceDocument, user);

      // Read the CAS
      JCas jcas = repository.readAnnotationCas(annotationDocument);

      // Update the annotation document CAS
      repository.upgradeCas(jcas.getCas(), annotationDocument);

      // After creating an new CAS or upgrading the CAS, we need to save it
      repository.writeAnnotationCas(
          jcas.getCas().getJCas(), annotationDocument.getDocument(), user);

      jCases.add(jcas);
    } catch (UIMAException e) {
      error(e.getMessage() + " : " + ExceptionUtils.getRootCauseMessage(e));
    } catch (IOException e) {
      error(e.getMessage());
    }
  }
Esempio n. 11
0
  private void setCurationSegmentBeginEnd()
      throws UIMAException, ClassNotFoundException, IOException {
    JCas jCas = repository.readAnnotationCas(bModel.getDocument(), bModel.getUser());

    final int sentenceAddress =
        getAddr(
            selectSentenceAt(jCas, bModel.getSentenceBeginOffset(), bModel.getSentenceEndOffset()));

    final Sentence sentence = selectByAddr(jCas, Sentence.class, sentenceAddress);
    List<Sentence> followingSentences =
        selectFollowing(jCas, Sentence.class, sentence, bModel.getPreferences().getWindowSize());
    // Check also, when getting the last sentence address in the display window, if this is the
    // last sentence or the ONLY sentence in the document
    Sentence lastSentenceAddressInDisplayWindow =
        followingSentences.size() == 0
            ? sentence
            : followingSentences.get(followingSentences.size() - 1);
    curationSegment.setBegin(sentence.getBegin());
    curationSegment.setEnd(lastSentenceAddressInDisplayWindow.getEnd());
  }
  @Override
  protected String getDocumentData() {
    if (!dirty) {
      return docData;
    }

    dirty = false;

    // Clear the rendered document
    docData = EMPTY_DOC;

    // Check if a document is set
    if (getModelObject() == null) {
      return docData;
    }

    // Get CAS from the repository
    JCas jCas = null;
    try {
      jCas = repository.readAnnotationCas(getModelObject());
    } catch (IOException | DataRetrievalFailureException e) {
      LOG.error("Unable to read annotation document", e);
      error("Unable to read annotation document: " + ExceptionUtils.getRootCauseMessage(e));
    }
    // Generate BRAT object model from CAS
    GetDocumentResponse response = new GetDocumentResponse();
    response.setText(jCas.getDocumentText());

    BratAnnotatorModel bratAnnotatorModel = new BratAnnotatorModel();
    SpanAdapter.renderTokenAndSentence(jCas, response, bratAnnotatorModel);

    Map<String[], Queue<String>> colorQueues = new HashMap<>();
    for (AnnotationLayer layer : bratAnnotatorModel.getAnnotationLayers()) {
      if (layer.getName().equals(Token.class.getName())) {
        continue;
      }
      List<AnnotationFeature> features = annotationService.listAnnotationFeature(layer);
      List<AnnotationFeature> invisibleFeatures = new ArrayList<AnnotationFeature>();
      for (AnnotationFeature feature : features) {
        if (!feature.isVisible()) {
          invisibleFeatures.add(feature);
        }
      }
      features.removeAll(invisibleFeatures);

      ColoringStrategy coloringStrategy =
          ColoringStrategy.getBestStrategy(
              annotationService, layer, bratAnnotatorModel.getPreferences(), colorQueues);

      getAdapter(annotationService, layer)
          .render(jCas, features, response, bratAnnotatorModel, coloringStrategy);
    }

    // Serialize BRAT object model to JSON
    try {
      StringWriter out = new StringWriter();
      JsonGenerator jsonGenerator =
          JSONUtil.getJsonConverter().getObjectMapper().getFactory().createGenerator(out);
      jsonGenerator.writeObject(response);
      docData = out.toString();
    } catch (IOException e) {
      error(ExceptionUtils.getRootCauseMessage(e));
    }

    return docData;
  }
Esempio n. 13
0
  private void loadDocumentAction()
      throws UIMAException, ClassNotFoundException, IOException, BratAnnotationException {
    String username = SecurityContextHolder.getContext().getAuthentication().getName();
    User logedInUser =
        userRepository.get(SecurityContextHolder.getContext().getAuthentication().getName());

    bModel.setUser(logedInUser);

    JCas jCas = null;
    try {
      AnnotationDocument logedInUserAnnotationDocument =
          repository.getAnnotationDocument(bModel.getDocument(), logedInUser);
      jCas = repository.readAnnotationCas(logedInUserAnnotationDocument);
    } catch (IOException e) {
      throw e;
    }
    // Get information to be populated to bratAnnotatorModel from the JCAS of the logged in user
    //
    catch (DataRetrievalFailureException e) {

      jCas = repository.readAnnotationCas(bModel.getDocument(), logedInUser);
      // This is the auto annotation, save it under CORRECTION_USER, Only if it is not created
      // by another annotater
      if (!repository.existsCorrectionCas(bModel.getDocument())) {
        repository.writeCorrectionCas(jCas, bModel.getDocument(), logedInUser);
      }
    } catch (NoResultException e) {
      jCas = repository.readAnnotationCas(bModel.getDocument(), logedInUser);
      // This is the auto annotation, save it under CORRECTION_USER, Only if it is not created
      // by another annotater
      if (!repository.existsCorrectionCas(bModel.getDocument())) {
        repository.writeCorrectionCas(jCas, bModel.getDocument(), logedInUser);
      }
    }

    // (Re)initialize brat model after potential creating / upgrading CAS
    bModel.initForDocument(jCas);

    // Load user preferences
    PreferencesUtil.setAnnotationPreference(
        username, repository, annotationService, bModel, Mode.AUTOMATION);

    // if project is changed, reset some project specific settings
    if (currentprojectId != bModel.getProject().getId()) {
      bModel.initForProject();
    }

    currentprojectId = bModel.getProject().getId();
    currentDocumentId = bModel.getDocument().getId();

    LOG.debug(
        "Configured BratAnnotatorModel for user ["
            + bModel.getUser()
            + "] f:["
            + bModel.getFirstSentenceAddress()
            + "] l:["
            + bModel.getLastSentenceAddress()
            + "] s:["
            + bModel.getSentenceAddress()
            + "]");
  }
Esempio n. 14
0
  public CurationContainer buildCurationContainer(BratAnnotatorModel aBModel)
      throws UIMAException, ClassNotFoundException, IOException, BratAnnotationException {
    CurationContainer curationContainer = new CurationContainer();
    // initialize Variables
    SourceDocument sourceDocument = aBModel.getDocument();
    Map<Integer, Integer> segmentBeginEnd = new HashMap<Integer, Integer>();
    Map<Integer, Integer> segmentNumber = new HashMap<Integer, Integer>();
    Map<String, Map<Integer, Integer>> segmentAdress = new HashMap<String, Map<Integer, Integer>>();
    // get annotation documents

    List<AnnotationDocument> finishedAnnotationDocuments = new ArrayList<AnnotationDocument>();

    for (AnnotationDocument annotationDocument :
        repository.listAnnotationDocuments(aBModel.getDocument())) {
      if (annotationDocument.getState().equals(AnnotationDocumentState.FINISHED)) {
        finishedAnnotationDocuments.add(annotationDocument);
      }
    }

    Map<String, JCas> jCases = new HashMap<String, JCas>();

    AnnotationDocument randomAnnotationDocument = null;
    JCas mergeJCas;

    // get the correction/automation JCas for the logged in user
    if (aBModel.getMode().equals(Mode.AUTOMATION) || aBModel.getMode().equals(Mode.CORRECTION)) {
      jCases = listJcasesforCorrection(randomAnnotationDocument, sourceDocument, aBModel.getMode());
      mergeJCas = getMergeCas(aBModel, sourceDocument, jCases, randomAnnotationDocument);
      String username = jCases.keySet().iterator().next();
      updateSegment(
          aBModel,
          segmentBeginEnd,
          segmentNumber,
          segmentAdress,
          jCases.get(username),
          username,
          aBModel.getPreferences().getWindowSize());

    } else {

      jCases =
          listJcasesforCuration(
              finishedAnnotationDocuments, randomAnnotationDocument, aBModel.getMode());
      mergeJCas = getMergeCas(aBModel, sourceDocument, jCases, randomAnnotationDocument);
      updateSegment(
          aBModel,
          segmentBeginEnd,
          segmentNumber,
          segmentAdress,
          mergeJCas,
          CurationPanel.CURATION_USER,
          aBModel.getPreferences().getCurationWindowSize());
    }

    List<Type> entryTypes = null;

    segmentAdress.put(CurationPanel.CURATION_USER, new HashMap<Integer, Integer>());
    for (Sentence sentence : selectCovered(mergeJCas, Sentence.class, begin, end)) {
      segmentAdress.get(CurationPanel.CURATION_USER).put(sentence.getBegin(), getAddr(sentence));
    }

    if (entryTypes == null) {
      entryTypes = getEntryTypes(mergeJCas, aBModel.getAnnotationLayers(), annotationService);
    }

    // for cross-sentences annotation, update the end of the segment
    if (firstload) {
      updateCrossSentAnnoList(segmentBeginEnd, jCases, entryTypes);
      firstload = false;
    }

    for (Integer begin : segmentBeginEnd.keySet()) {
      Integer end = segmentBeginEnd.get(begin);

      DiffResult diff =
          CasDiff2.doDiffSingle(
              annotationService, aBModel.getProject(), entryTypes, jCases, begin, end);
      SourceListView curationSegment = new SourceListView();
      curationSegment.setBegin(begin);
      curationSegment.setEnd(end);
      if (diff.hasDifferences() || !diff.getIncompleteConfigurationSets().isEmpty()) {
        curationSegment.setSentenceState(SentenceState.DISAGREE);
      } else {
        curationSegment.setSentenceState(SentenceState.AGREE);
      }
      curationSegment.setSentenceNumber(segmentNumber.get(begin));

      for (String username : segmentAdress.keySet()) {
        curationSegment.getSentenceAddress().put(username, segmentAdress.get(username).get(begin));
      }
      curationContainer.getCurationViewByBegin().put(begin, curationSegment);
    }
    return curationContainer;
  }