Example usage for org.apache.commons.configuration Configuration setProperty

List of usage examples for org.apache.commons.configuration Configuration setProperty

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.configuration.*
  5. Configuration
  6. setProperty

Introduction

In this page you can find the example usage for org.apache.commons.configuration Configuration setProperty.

Prototype

void setProperty(String key, Object value);

Source Link

Document

Set a property, this will replace any previously set values.

Usage

From source file:org.zaproxy.zap.extension.ascanrules.CommandInjectionPluginUnitTest.java

private static Configuration configWithSleepRule(String value) {
    Configuration config = new ZapXmlConfiguration();
    config.setProperty(RuleConfigParam.RULE_COMMON_SLEEP_TIME, value);
    return config;
}

From source file:org.zaproxy.zap.extension.authentication.ExtensionAuthentication.java

@Override
public void exportContextData(Context ctx, Configuration config) {
    config.setProperty(AuthenticationMethod.CONTEXT_CONFIG_AUTH_TYPE,
            ctx.getAuthenticationMethod().getType().getUniqueIdentifier());
    if (ctx.getAuthenticationMethod().getLoggedInIndicatorPattern() != null) {
        config.setProperty(AuthenticationMethod.CONTEXT_CONFIG_AUTH_LOGGEDIN,
                ctx.getAuthenticationMethod().getLoggedInIndicatorPattern().toString());
    }/* w  w  w  .  j a v a2  s . c o  m*/
    if (ctx.getAuthenticationMethod().getLoggedOutIndicatorPattern() != null) {
        config.setProperty(AuthenticationMethod.CONTEXT_CONFIG_AUTH_LOGGEDOUT,
                ctx.getAuthenticationMethod().getLoggedOutIndicatorPattern().toString());
    }
    ctx.getAuthenticationMethod().getType().exportData(config, ctx.getAuthenticationMethod());

}

From source file:org.zaproxy.zap.extension.authorization.ExtensionAuthorization.java

@Override
public void exportContextData(Context ctx, Configuration config) {
    config.setProperty(AuthorizationDetectionMethod.CONTEXT_CONFIG_AUTH_TYPE,
            ctx.getAuthorizationDetectionMethod().getMethodUniqueIdentifier());
    ctx.getAuthorizationDetectionMethod().exportMethodData(config);
}

From source file:org.zaproxy.zap.extension.forceduser.ExtensionForcedUser.java

@Override
public void exportContextData(Context ctx, Configuration config) {
    User user = getForcedUser(ctx.getIndex());
    if (user != null) {
        config.setProperty("context.forceduser", user.getId());
    } else {//from w  w  w.j  a  v  a 2s.c o m
        config.setProperty("context.forceduser", -1);
    }
}

From source file:org.zaproxy.zap.extension.pscan.PluginPassiveScanner.java

public void saveTo(Configuration conf) {
    conf.setProperty("pscans." + getClass().getCanonicalName() + ".enabled", this.isEnabled());
    conf.setProperty("pscans." + getClass().getCanonicalName() + ".level", this.getLevel(true).name());
}

From source file:org.zaproxy.zap.extension.sessions.ExtensionSessionManagement.java

@Override
public void exportContextData(Context ctx, Configuration config) {
    config.setProperty(CONTEXT_CONFIG_SESSION_TYPE,
            ctx.getSessionManagementMethod().getType().getUniqueIdentifier());
}

From source file:revaligner.service.FileAligner.java

private void reformatTargetFile(com.aspose.words.Document doc_trg) throws Exception {
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    normalizeSpaceAfterESM(doc_trg, Locale.makeLocale(this.targetlanguage));
    DeleteCommentsAndShapeAltText(doc_trg);

    convertMoveToIDTracks(doc_trg);//from   w w  w. j  a v  a 2 s.c  o  m
    while (doc_trg.getRevisions().getCount() != 0) {
        Revision rev = doc_trg.getRevisions().get(0);
        rev.reject();
    }
}

From source file:revaligner.service.FileAligner.java

private void mergeParagraphsInDocuemnt(com.aspose.words.Document doc) throws Exception {
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    Paragraph prev_para = null;/*from  w w  w.j  av a2s  .c o m*/
    Paragraph sample = new Paragraph(doc);

    Shape shape = null;
    boolean isStillSplitting = false;
    boolean ismoveaway = false;
    boolean ismoveto = false;
    int toskip = 0;
    List<Paragraph> toremove = new ArrayList();
    for (int i = 0; i < doc.getChildNodes(0, true).getCount(); i++) {
        com.aspose.words.Node node = doc.getChildNodes(0, true).get(i);
        if (node.getNodeType() == 18) {
            shape = (Shape) node;
        } else if (node.getNodeType() == 13) {
            ismoveaway = true;
        } else if (node.getNodeType() == 14) {
            ismoveaway = false;
        } else if (node.getNodeType() == 15) {
            ismoveto = true;
        } else if (node.getNodeType() == 16) {
            ismoveto = false;
        } else if (node.getNodeType() == 8) {
            if (toskip > 0) {
                toskip--;
            } else {
                Paragraph para = (Paragraph) node;
                if ((para.isEndOfSection()) && ((para.isInsertRevision()) || (para.isDeleteRevision()))) {
                    this.isSectionBreakDeletedORInserted = true;
                }
                if ((para.isInCell()) && (para.getPreviousSibling() == null)) {
                    prev_para = null;
                    isStillSplitting = false;
                }
                if ((shape != null) && (shape.getChildNodes(8, true).getCount() > 0)
                        && (shape.getChildNodes(8, true).get(0) == para)) {
                    prev_para = null;
                    isStillSplitting = false;
                }
                if (prev_para != null) {
                    if (isStillSplitting) {
                        if ((prev_para.isInsertRevision()) || (ismoveto)) {
                            if (extractionSupportImpl.isExtractable(getParaText(para))) {
                                para.appendChild(new Run(doc, "&parains;"));
                            }
                        } else {
                            isStillSplitting = false;
                        }
                    } else if (((prev_para.isInsertRevision()) || (ismoveto))
                            && (!isWholeParaInserted(prev_para))) {
                        if (extractionSupportImpl.isExtractable(getParaText(para))) {
                            para.appendChild(new Run(doc, "&parains;"));
                        }
                        isStillSplitting = true;
                    }
                    if ((para.isEndOfCell()) || (para.isEndOfHeaderFooter()) || (para.isEndOfSection())) {
                        isStillSplitting = false;
                    }
                    if ((shape != null) && (shape.getChildNodes(8, true).getCount() > 0) && (shape
                            .getChildNodes(8, true).get(shape.getChildNodes(8, true).getCount() - 1) == para)) {
                        isStillSplitting = false;
                    }
                    if (((prev_para.isDeleteRevision()) || (ismoveaway)) && (!isWholeParaDeleted(prev_para))) {
                        if ((para.getChildNodes(21, true).getCount() != 0) || (para.isDeleteRevision())) {
                            prev_para.appendChild(new Run(doc, "&paradel;"));
                            i++;
                            for (int j = 0; j < para.getChildNodes().getCount(); j++) {
                                com.aspose.words.Node nd = para.getChildNodes().get(j);
                                if ((nd.getNodeType() != 21) || (!((Run) nd).isDeleteRevision())
                                        || (!((Run) nd).getText().contains(ControlChar.PAGE_BREAK))) {
                                    prev_para.appendChild(nd.deepClone(true));
                                    i++;
                                }
                            }
                            if (para.getChildNodes(14, true).getCount() != 0) {
                                ismoveaway = false;
                            }
                        }
                        prev_para.setDeleteRevision(para.getDeleteRevision());
                        prev_para.setInsertRevision(para.getInsertRevision());
                        if (!para.isInsertRevision()) {
                            for (int z = 0; z < para.getChildNodes().getCount(); z++) {
                                com.aspose.words.Node temp_nd = para.getChildNodes().get(z);
                                if (temp_nd.getNodeType() == 15) {
                                    ismoveto = true;
                                } else if (temp_nd.getNodeType() == 16) {
                                    ismoveto = false;
                                }
                            }
                            para.remove();
                            i--;
                        } else {
                            toremove.add(para);
                            prev_para = para;
                        }
                    } else if ((prev_para.isDeleteRevision()) && (isWholeParaDeleted(prev_para))) {
                        prev_para.setDeleteRevision(sample.getDeleteRevision());
                        prev_para = para;
                    } else if ((para.isEndOfCell()) || (para.isEndOfHeaderFooter())) {
                        para.setDeleteRevision(sample.getDeleteRevision());
                        prev_para = null;
                    } else if ((shape != null) && (shape.getChildNodes(8, true).getCount() > 0) && (shape
                            .getChildNodes(8, true).get(shape.getChildNodes(8, true).getCount() - 1) == para)) {
                        para.setDeleteRevision(sample.getDeleteRevision());
                        prev_para = null;
                    } else {
                        prev_para = para;
                    }
                } else {
                    if ((isStillSplitting) && (extractionSupportImpl.isExtractable(getParaText(para)))) {
                        para.appendChild(new Run(doc, "&parains;"));
                        i++;
                    }
                    if (para.isInsertRevision()) {
                        if ((extractionSupportImpl.isExtractable(getParaText(para)))
                                && (!isWholeParaInserted(para))) {
                            isStillSplitting = true;
                        }
                    } else {
                        isStillSplitting = false;
                    }
                    if ((para.isEndOfCell()) || (para.isEndOfHeaderFooter())) {
                        if ((para.getNextSibling() == null) && (para.getPreviousSibling() == null)
                                && (para.isDeleteRevision()) && (isWholeParaDeleted(para))) {
                            para.setDeleteRevision(sample.getDeleteRevision());
                        }
                        prev_para = null;
                    } else if ((shape != null) && (shape.getChildNodes(8, true).getCount() > 0) && (shape
                            .getChildNodes(8, true).get(shape.getChildNodes(8, true).getCount() - 1) == para)) {
                        if ((para.getNextSibling() == null) && (para.getPreviousSibling() == null)
                                && (para.isDeleteRevision()) && (isWholeParaDeleted(para))) {
                            para.setDeleteRevision(sample.getDeleteRevision());
                        }
                        prev_para = null;
                    } else {
                        prev_para = para;
                    }
                }
            }
        } else if (node.getNodeType() == 5) {
            Table tb = (Table) node;
            if (isWholeTableDeleted(tb, doc)) {
                toskip = tb.getChildNodes(8, true).getCount();
            }
        }
    }
    for (Paragraph p : toremove) {
        if (p != null) {
            p.removeAllChildren();
        }
    }
    doc.save("C:\\Program Files (x86)\\pa\\paprjs\\testprj23\\test.docx");
}

From source file:revaligner.service.FileAligner.java

public String[] createAlignedXML() throws Exception {
    System.out.println("creating aligned xml....");

    String[] res = new String[1];

    this.txlftrgsegmap = new LinkedHashMap();
    this.alignedfile = (this.prjfolder + File.separator + "rev_aligned.xml");
    this.reformattedtargetmapfile = (this.prjfolder + File.separator + "target_reformatted" + File.separator
            + ".mp");
    StringBuffer sbmp = new StringBuffer();
    if (new File(this.alignedfile).exists()) {
        new File(this.alignedfile).delete();
    }/*from   w  w w.j a  v  a2s .com*/
    SegmenterFactory factory = new SegmenterFactory();
    Configuration segconfig = createConfigForSegmenter(false, this.sourcelanguage);
    Segmenter segmenter = factory.getSegmenter("trados", Locale.makeLocale(this.sourcelanguage), segconfig);

    org.dom4j.Document document = DocumentHelper.createDocument();
    org.dom4j.Element root = document.addElement("alinger");
    org.dom4j.Element head = root.addElement("head");
    head.addAttribute("src_lang", this.sourcelanguage);
    head.addAttribute("trg_lang", this.targetlanguage);
    head.addAttribute("creator", this.creatorid);
    org.dom4j.Element aligned = root.addElement("aligned");
    org.dom4j.Element orphans = root.addElement("orphans");

    org.dom4j.Document document_source_formatted_nonSeg = XmlParser
            .parseXmlFile(this.reformattedsourcetxlf_nonSeg);
    org.dom4j.Element root_source_formatted_nonSeg = document_source_formatted_nonSeg.getRootElement();
    List list_source_formatted_nonSeg = root_source_formatted_nonSeg.selectNodes("//*[name() = 'trans-unit']");

    org.dom4j.Document document_target_nonSeg = XmlParser.parseXmlFile(this.reformattedtargettxlf_nonSeg);
    org.dom4j.Element root_target_nonSeg = document_target_nonSeg.getRootElement();

    List list_target_nonSeg = root_target_nonSeg.selectNodes("//*[name() = 'trans-unit']");

    org.dom4j.Document document_target_seg = XmlParser.parseXmlFile(this.reformattedtargettxlf_seg);
    org.dom4j.Element root_target_seg = document_target_seg.getRootElement();

    List list_target_seg = root_target_seg.selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");
    int trg_para_count = 0;

    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    Workbook wb = new Workbook();
    Cells cells = wb.getWorksheets().get(0).getCells();
    int cnt = 0;

    boolean issrcfirsthf = true;
    boolean istrgfirsthf = true;
    int gcount = -1;
    for (int i = 0; i < list_source_formatted_nonSeg.size(); i++) {
        org.dom4j.Element src_txlf = ((org.dom4j.Element) list_source_formatted_nonSeg.get(i))
                .element("source");
        String merged_text = getTxlfElementText_withFakeTC(src_txlf);
        if (extractionSupportImpl
                .isExtractable(merged_text.replace("&amp;paradel;", "").replace("&amp;parains;", ""))) {
            gcount++;

            org.dom4j.Element group = aligned.addElement("group");
            group.addAttribute("id", Integer.toString(gcount));

            merged_text = trimText(merged_text, true)[0];

            org.dom4j.Element merged_src_text = group.addElement("text");

            merged_src_text.setText(merged_text.replace("&amp;paradel;", "").replace("&amp;parains;", ""));

            String[] split_merged_text = merged_text.replaceAll("(&amp;paradel;)+", "&amp;paradel;")
                    .replaceAll("^&amp;paradel;", "").replaceAll("&amp;paradel;$", "").split("&amp;paradel;");
            List<String> segmentsGroup = segmentStringWithRevs(
                    merged_text.replaceAll("(&amp;paradel;)+", "&amp;paradel;").replace("&amp;parains;", ""),
                    this.sourcelanguage);

            List<List<String>> resegmentedGroup = new ArrayList();
            resegmentedGroup.add(new ArrayList());
            int idx = 0;
            String orgs;
            String[] newsegs;
            for (int s = 0; s < segmentsGroup.size(); s++) {
                orgs = (String) segmentsGroup.get(s);
                if (orgs.contains("&amp;paradel;")) {
                    newsegs = orgs.split("&amp;paradel;");
                    for (int ss = 0; ss < newsegs.length; ss++) {
                        String sss = newsegs[ss];
                        if (!sss.trim().equals("")) {
                            ((List) resegmentedGroup.get(idx)).add(fixMissingTags(sss));
                        }
                        if ((((List) resegmentedGroup.get(idx)).size() != 0) && (ss != newsegs.length - 1)) {
                            resegmentedGroup.add(new ArrayList());
                            idx++;
                        }
                    }
                    if (orgs.trim().endsWith("&amp;paradel;")) {
                        resegmentedGroup.add(new ArrayList());
                        idx++;
                    }
                } else {
                    ((List) resegmentedGroup.get(idx)).add(fixMissingTags(orgs));
                }
            }
            if (split_merged_text.length > resegmentedGroup.size()) {
                System.out.println(i);
                System.out.println("merged_text: " + merged_text);
                for (String smt : split_merged_text) {
                    System.out.println("split_merged_text: " + smt);
                }
                for (List<String> smts : resegmentedGroup) {
                    System.out.println("resegmentedGroup: " + smts);
                }
                for (String smtss : segmentsGroup) {
                    System.out.println("segmentedGroup: " + smtss);
                }
            }
            for (int j = 0; j < split_merged_text.length; j++) {
                if (!split_merged_text[j].replaceAll("<(/)*ins>|<(/)*del>", "").trim().equals("")) {
                    split_merged_text[j] = fixMissingTags(split_merged_text[j]);

                    org.dom4j.Element unit = group.addElement("unit");
                    unit.addAttribute("id", Integer.toString(j));
                    unit.addAttribute("alignsegs", "false");

                    org.dom4j.Element src = unit.addElement("src_para");
                    org.dom4j.Element src_text = src.addElement("text");
                    boolean ishf = split_merged_text[j].contains("&amp;hf;");
                    if (!ishf) {
                        issrcfirsthf = false;
                    }
                    boolean isAddedPara = split_merged_text[j].contains("&amp;parains;");
                    src.addAttribute("added", "" + isAddedPara);
                    String[] trim_result = trimText(
                            split_merged_text[j].replace("&amp;parains;", "").replace("&amp;hf;", ""), false);
                    src.addAttribute("lefttrim", trim_result[1]);
                    src.addAttribute("righttrim", trim_result[2]);
                    split_merged_text[j] = trim_result[0];

                    int src_tctype_para = TrackChangeHelper.getTrackChangeType(split_merged_text[j]);
                    src.addAttribute("tctype", TrackChangeType.getName(src_tctype_para));
                    String rejected_src = split_merged_text[j].replaceAll("(?s)<ins>.*?</ins>", "")
                            .replace("<del>", "").replace("</del>", "");
                    if ((!extractionSupportImpl.isExtractable(rejected_src)) || (ishf)) {
                        unit.addAttribute("locked", "true");
                    } else {
                        unit.addAttribute("locked", "false");
                    }
                    src_text.setText(split_merged_text[j]);

                    cells.get(cnt, 0).setHtmlString("<html>" + split_merged_text[j].replace("ins>", "u>")
                            .replace("del>", "strike>").replace("<br> ", "&#8629;<br>") + "</html>");

                    org.dom4j.Element src_segs = src.addElement("segments");
                    List<String> segments = (List) resegmentedGroup.get(j);
                    for (int z = 0; z < segments.size(); z++) {
                        String segment_text = trimText((String) segments.get(z), false)[0];
                        org.dom4j.Element src_seg = src_segs.addElement("src_seg");
                        src_seg.addAttribute("id", Integer.toString(z));
                        src_seg.addAttribute("needreview", "false");
                        src_seg.addAttribute("ignored", "false");
                        int tctype_seg = TrackChangeHelper.getTrackChangeType(segment_text);
                        src_seg.addAttribute("tctype", TrackChangeType.getName(tctype_seg));
                        String accepted_t = segment_text.replaceAll("(?s)<del>.*?</del>", "")
                                .replace("<ins>", "").replace("</ins>", "");
                        src_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl.isExtractable(accepted_t)));

                        String rejected_s = segment_text.replaceAll("(?s)<ins>.*?</ins>", "")
                                .replace("<del>", "").replace("</del>", "");
                        if ((!extractionSupportImpl.isExtractable(rejected_s)) || (ishf)) {
                            src_seg.addAttribute("locked", "true");
                        } else {
                            src_seg.addAttribute("locked", "false");
                        }
                        src_seg.setText(segment_text);
                    }
                    org.dom4j.Element trg = unit.addElement("trg_para");
                    if ((src_tctype_para != 1) && (!isAddedPara) && (!ishf)
                            && (trg_para_count < list_target_nonSeg.size())) {
                        trg.addAttribute("id", Integer.toString(gcount) + " - " + Integer.toString(j));
                        org.dom4j.Element trg_text = trg.addElement("text");
                        org.dom4j.Element trg_txlf = ((org.dom4j.Element) list_target_nonSeg
                                .get(trg_para_count)).element("source");
                        org.dom4j.Element trg_txlf_seg = (org.dom4j.Element) list_target_seg
                                .get(trg_para_count);
                        while (trg_txlf.getText().contains("&hf;")) {
                            trg_para_count++;
                            trg_txlf = ((org.dom4j.Element) list_target_nonSeg.get(trg_para_count))
                                    .element("source");
                            trg_txlf_seg = (org.dom4j.Element) list_target_seg.get(trg_para_count);
                        }
                        istrgfirsthf = false;

                        String trg_formatted_text = getTxlfElementText_normal(trg_txlf);
                        trg_text.setText(trg_formatted_text.replace("&amp;hf;", ""));

                        cells.get(cnt, 1)
                                .setHtmlString("<html>"
                                        + trg_formatted_text.replace("ins>", "u>").replace("del>", "strike>")
                                                .replace("&amp;hf;", "").replace("<br> ", "&#8629;<br>")
                                        + "</html>");
                        cnt++;

                        org.dom4j.Element trg_segs = trg.addElement("segments");
                        List<String> trgsegs = segmentStringWithRevs(trg_formatted_text, this.targetlanguage);
                        List<org.dom4j.Element> srcsegs = src_segs.elements("src_seg");
                        int trg_tmp_cnt = 0;
                        for (int z = 0; trg_tmp_cnt < trgsegs.size(); z++) {
                            org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
                            trg_seg.addAttribute("id", Integer.toString(z));
                            trg_seg.addAttribute("edited", "false");
                            if ((z < srcsegs.size()) && (((org.dom4j.Element) srcsegs.get(z))
                                    .attributeValue("tctype").equals(TrackChangeType.getName(1)))) {
                                trg_seg.addAttribute("isExtractable", "false");
                                trg_seg.setText("");
                            } else {
                                String trgsegtext = ((String) trgsegs.get(trg_tmp_cnt)).replace("&amp;hf;", "")
                                        .trim();
                                trg_seg.addAttribute("isExtractable",
                                        Boolean.toString(extractionSupportImpl.isExtractable(trgsegtext)));
                                trg_seg.setText(trgsegtext);

                                String mapid = Integer.toString(gcount) + " - " + Integer.toString(j) + " - "
                                        + Integer.toString(z);
                                List t = ((org.dom4j.Element) trg_txlf_seg.elements("trans-unit")
                                        .get(trg_tmp_cnt)).content();

                                sbmp.append(mapid + "\t" + trg_para_count + "\t" + trg_tmp_cnt + "\n");

                                trg_tmp_cnt++;
                            }
                        }
                        trg_para_count++;
                    } else {
                        trg.addAttribute("id", Integer.toString(gcount) + " - " + Integer.toString(j));
                        org.dom4j.Element trg_text = trg.addElement("text");
                        trg_text.setText("");
                        trg.addElement("segments");
                        cnt++;
                    }
                    int trgcnt = trg.element("segments").elements("trg_seg").size();
                    int srccnt = src.element("segments").elements("src_seg").size();
                    if (trgcnt < srccnt) {
                        for (int x = 1; x <= srccnt - trgcnt; x++) {
                            org.dom4j.Element trg_seg = trg.element("segments").addElement("trg_seg");
                            trg_seg.addAttribute("id", Integer.toString(trgcnt + x - 1));
                            trg_seg.addAttribute("edited", "false");
                            trg_seg.addAttribute("isExtractable", "false");
                            trg_seg.setText("");
                        }
                    }
                }
            }
        }
    }
    int unitcnt = list_source_formatted_nonSeg.size();
    for (int i = trg_para_count; i < list_target_nonSeg.size(); i++) {
        org.dom4j.Element trg_txlf = ((org.dom4j.Element) list_target_nonSeg.get(trg_para_count))
                .element("source");
        org.dom4j.Element trg_txlf_seg = (org.dom4j.Element) list_target_seg.get(trg_para_count);
        if (!trg_txlf.getText().contains("&hf;")) {
            org.dom4j.Element group = aligned.addElement("group");
            group.addAttribute("id", Integer.toString(unitcnt));
            group.addElement("text").setText("");

            org.dom4j.Element unit = group.addElement("unit");
            unit.addAttribute("id", "0");
            unit.addAttribute("alignsegs", "false");
            unit.addAttribute("locked", "false");

            org.dom4j.Element trg = unit.addElement("trg_para");
            trg.addAttribute("id", Integer.toString(unitcnt) + " - 0");
            org.dom4j.Element trg_text = trg.addElement("text");

            String trg_formatted_text = getTxlfElementText_normal(trg_txlf);
            trg_text.setText(trg_formatted_text.replace("&amp;hf;", ""));

            org.dom4j.Element trg_segs = trg.addElement("segments");
            List<String> trgsegs = segmentStringWithRevs(trg_formatted_text.replace("&amp;hf;", ""),
                    this.targetlanguage);
            for (int z = 0; z < trgsegs.size(); z++) {
                org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
                trg_seg.addAttribute("id", Integer.toString(z));
                trg_seg.addAttribute("edited", "false");
                trg_seg.addAttribute("isExtractable",
                        Boolean.toString(extractionSupportImpl.isExtractable((String) trgsegs.get(z))));

                trg_seg.setText(((String) trgsegs.get(z)).trim());

                String mapid = Integer.toString(unitcnt) + " - 0 - " + Integer.toString(z);
                List t = ((org.dom4j.Element) trg_txlf_seg.elements("trans-unit").get(z)).content();

                sbmp.append(mapid + "\t" + trg_para_count + "\t" + z + "\n");
            }
            trg_para_count++;
            unitcnt++;
        }
    }
    wb.save(this.prjfolder + File.separator + "verifySegsPop.xlsx");

    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.alignedfile)), "UTF8");
    document.write(writer);
    writer.close();

    OutputStreamWriter writermp = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.reformattedtargetmapfile)), "UTF8");
    writermp.write(sbmp.toString());
    writermp.close();

    return res;
}

From source file:revaligner.service.FileAligner.java

public void createAlignedXML_auto(String prjid) throws Exception {
    System.out.println("creating aligned xml with nbAligner....");

    this.alignedfile = (this.prjfolder + File.separator + "rev_aligned.xml");
    this.reformattedtargetmapfile = (this.prjfolder + File.separator + "target_reformatted" + File.separator
            + ".mp");
    HashMap<String, String> srcidmap = new HashMap();

    this.nbalignerfolder = (this.prjfolder + File.separator + "nbaligner");
    if (!new File(this.nbalignerfolder).exists()) {
        new File(this.nbalignerfolder).mkdir();
    }//from  w  ww  .  j  ava2s .  c  o m
    FileUtils.cleanDirectory(new File(this.nbalignerfolder));
    String nbsourcefolder = this.nbalignerfolder + File.separator + this.sourcelanguage;
    new File(nbsourcefolder).mkdir();
    org.dom4j.Document nbsource = DocumentHelper.createDocument();
    org.dom4j.Element root_src = nbsource.addElement("txml");
    root_src.addAttribute("locale", this.sourcelanguage);
    root_src.addAttribute("version", "1.0");
    root_src.addAttribute("segtype", "sentence");
    org.dom4j.Element translatable_src = root_src.addElement("translatable");
    translatable_src.addAttribute("blockId", "1");
    String nbtargetfolder = this.nbalignerfolder + File.separator + this.targetlanguage;
    new File(nbtargetfolder).mkdir();
    org.dom4j.Document nbtarget = DocumentHelper.createDocument();
    org.dom4j.Element root_trg = nbtarget.addElement("txml");
    root_trg.addAttribute("locale", this.targetlanguage);
    root_trg.addAttribute("version", "1.0");
    root_trg.addAttribute("segtype", "sentence");
    org.dom4j.Element translatable_trg = root_trg.addElement("translatable");
    translatable_trg.addAttribute("blockId", "0");
    if (new File(this.alignedfile).exists()) {
        new File(this.alignedfile).delete();
    }
    SegmenterFactory factory = new SegmenterFactory();
    Configuration segconfig = createConfigForSegmenter(false, this.sourcelanguage);
    Segmenter segmenter = factory.getSegmenter("trados", Locale.makeLocale(this.sourcelanguage), segconfig);

    org.dom4j.Document document = DocumentHelper.createDocument();
    org.dom4j.Element root = document.addElement("alinger");
    org.dom4j.Element head = root.addElement("head");
    head.addAttribute("src_lang", this.sourcelanguage);
    head.addAttribute("trg_lang", this.targetlanguage);
    head.addAttribute("creator", this.creatorid);
    org.dom4j.Element aligned = root.addElement("aligned");
    org.dom4j.Element orphans = root.addElement("orphans");

    org.dom4j.Document document_source_formatted_nonSeg = XmlParser
            .parseXmlFile(this.reformattedsourcetxlf_nonSeg);
    org.dom4j.Element root_source_formatted_nonSeg = document_source_formatted_nonSeg.getRootElement();
    List list_source_formatted_nonSeg = root_source_formatted_nonSeg.selectNodes("//*[name() = 'trans-unit']");

    org.dom4j.Document document_target_nonSeg = XmlParser.parseXmlFile(this.reformattedtargettxlf_nonSeg);
    org.dom4j.Element root_target_nonSeg = document_target_nonSeg.getRootElement();

    List list_target_nonSeg = root_target_nonSeg.selectNodes("//*[name() = 'trans-unit']");

    org.dom4j.Document document_target_seg = XmlParser.parseXmlFile(this.reformattedtargettxlf_seg);
    org.dom4j.Element root_target_seg = document_target_seg.getRootElement();

    List list_target_seg = root_target_seg.selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");

    ExtractionSupportImpl extractionSupportImpl_src = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.sourcelanguage));
    Configuration config_src = new BaseConfiguration();
    config_src.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl_src.setConfiguration(config_src);

    ExtractionSupportImpl extractionSupportImpl_trg = new ExtractionSupportImpl(
            Locale.makeLocale(this.targetlanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config_trg = new BaseConfiguration();
    config_trg.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl_trg.setConfiguration(config_trg);

    boolean issrcfirsthf = true;
    boolean istrgfirsthf = true;
    int gcount = -1;
    int segmentId = 0;
    for (int i = 0; i < list_source_formatted_nonSeg.size(); i++) {
        org.dom4j.Element src_txlf = ((org.dom4j.Element) list_source_formatted_nonSeg.get(i))
                .element("source");
        String merged_text = getTxlfElementText_withFakeTC(src_txlf);
        if (extractionSupportImpl_src
                .isExtractable(merged_text.replace("&amp;paradel;", "").replace("&amp;parains;", ""))) {
            gcount++;

            org.dom4j.Element group = aligned.addElement("group");
            group.addAttribute("id", Integer.toString(gcount));

            merged_text = trimText(merged_text, true)[0];
            org.dom4j.Element merged_src_text = group.addElement("text");

            merged_src_text.setText(merged_text.replace("&amp;paradel;", "").replace("&amp;parains;", ""));

            String[] split_merged_text = merged_text.replaceAll("(&amp;paradel;)+", "&amp;paradel;")
                    .replaceAll("^&amp;paradel;", "").replaceAll("&amp;paradel;$", "").split("&amp;paradel;");
            List<String> segmentsGroup = segmentStringWithRevs(
                    merged_text.replaceAll("(&amp;paradel;)+", "&amp;paradel;").replace("&amp;parains;", ""),
                    this.sourcelanguage);
            List<List<String>> resegmentedGroup = new ArrayList();
            resegmentedGroup.add(new ArrayList());
            int idx = 0;
            String orgs;
            String[] newsegs;
            for (int s = 0; s < segmentsGroup.size(); s++) {
                orgs = (String) segmentsGroup.get(s);
                if (orgs.contains("&amp;paradel;")) {
                    newsegs = orgs.split("&amp;paradel;");
                    for (int ss = 0; ss < newsegs.length; ss++) {
                        String sss = newsegs[ss];
                        if (!sss.trim().equals("")) {
                            ((List) resegmentedGroup.get(idx)).add(fixMissingTags(sss));
                        }
                        if ((((List) resegmentedGroup.get(idx)).size() != 0) && (ss != newsegs.length - 1)) {
                            resegmentedGroup.add(new ArrayList());
                            idx++;
                        }
                    }
                    if (orgs.trim().endsWith("&amp;paradel;")) {
                        resegmentedGroup.add(new ArrayList());
                        idx++;
                    }
                } else {
                    ((List) resegmentedGroup.get(idx)).add(fixMissingTags(orgs));
                }
            }
            if (split_merged_text.length > resegmentedGroup.size()) {
                System.out.println(i);
                System.out.println("merged_text: " + merged_text);
                for (String smt : split_merged_text) {
                    System.out.println("split_merged_text: " + smt);
                }
                for (List<String> smts : resegmentedGroup) {
                    System.out.println("resegmentedGroup: " + smts);
                }
                for (String smtss : segmentsGroup) {
                    System.out.println("segmentedGroup: " + smtss);
                }
            }
            for (int j = 0; j < split_merged_text.length; j++) {
                if (!split_merged_text[j].replaceAll("<(/)*ins>|<(/)*del>", "").trim().equals("")) {
                    split_merged_text[j] = fixMissingTags(split_merged_text[j]);

                    Element unit = group.addElement("unit");
                    unit.addAttribute("id", Integer.toString(j));
                    unit.addAttribute("alignsegs", "false");

                    Element src = unit.addElement("src_para");
                    org.dom4j.Element src_text = src.addElement("text");
                    boolean isAddedPara = split_merged_text[j].contains("&amp;parains;");
                    src.addAttribute("added", "" + isAddedPara);
                    String[] trim_result = trimText(split_merged_text[j].replace("&amp;parains;", ""), false);
                    src.addAttribute("lefttrim", trim_result[1]);
                    src.addAttribute("righttrim", trim_result[2]);
                    split_merged_text[j] = trim_result[0];

                    int src_tctype_para = TrackChangeHelper.getTrackChangeType(split_merged_text[j]);
                    src.addAttribute("tctype", TrackChangeType.getName(src_tctype_para));
                    String rejected_src = split_merged_text[j].replaceAll("(?s)<ins>.*?</ins>", "")
                            .replace("<del>", "").replace("</del>", "");
                    if (!extractionSupportImpl_src.isExtractable(rejected_src)) {
                        unit.addAttribute("locked", "true");
                    } else {
                        unit.addAttribute("locked", "false");
                    }
                    src_text.setText(split_merged_text[j]);

                    org.dom4j.Element src_segs = src.addElement("segments");
                    List<String> segments = (List) resegmentedGroup.get(j);
                    for (int z = 0; z < segments.size(); z++) {
                        String segment_text = trimText((String) segments.get(z), false)[0];
                        org.dom4j.Element src_seg = src_segs.addElement("src_seg");
                        src_seg.addAttribute("id", Integer.toString(z));
                        src_seg.addAttribute("needreview", "false");
                        src_seg.addAttribute("ignored", "false");
                        int tctype_seg = TrackChangeHelper.getTrackChangeType(segment_text);
                        src_seg.addAttribute("tctype", TrackChangeType.getName(tctype_seg));
                        String accepted_t = segment_text.replaceAll("(?s)<del>.*?</del>", "")
                                .replace("<ins>", "").replace("</ins>", "");
                        src_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl_src.isExtractable(accepted_t)));

                        String rejected_s = segment_text.replaceAll("(?s)<ins>.*?</ins>", "")
                                .replace("<del>", "").replace("</del>", "");
                        if (!extractionSupportImpl_src.isExtractable(rejected_s)) {
                            src_seg.addAttribute("locked", "true");
                        } else {
                            src_seg.addAttribute("locked", "false");

                            org.dom4j.Element segment_src = translatable_src.addElement("segment");
                            segment_src.addAttribute("segmentId", Integer.toString(segmentId));

                            srcidmap.put(i + " - " + j + " - " + z, Integer.toString(segmentId));

                            segmentId++;
                            segment_src.addElement("source").setText(rejected_s);
                        }
                        src_seg.setText(segment_text);
                    }
                }
            }
        }
    }
    segmentId = 0;
    for (int i = 0; i < list_target_nonSeg.size(); i++) {
        org.dom4j.Element trg_txlf = ((org.dom4j.Element) list_target_nonSeg.get(i)).element("source");

        String trg_formatted_text = getTxlfElementText_normal(trg_txlf);
        List<String> trgsegs = segmentStringWithRevs(trg_formatted_text, this.targetlanguage);
        for (int j = 0; j < trgsegs.size(); j++) {
            String trgseg = ((String) trgsegs.get(j)).trim().replaceAll("(\\s)+", " ");
            if (extractionSupportImpl_trg.isExtractable(trgseg)) {
                org.dom4j.Element segment_trg = translatable_trg.addElement("segment");
                segment_trg.addAttribute("segmentId", Integer.toString(segmentId));
                segmentId++;
                segment_trg.addElement("source").setText(trgseg);
            }
        }
    }
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(
                    new FileOutputStream(nbsourcefolder + File.separator + this.sourcelanguage + ".txml")),
            "UTF8");
    nbsource.write(writer);
    writer.close();

    writer = new OutputStreamWriter(
            new BufferedOutputStream(
                    new FileOutputStream(nbtargetfolder + File.separator + this.targetlanguage + ".txml")),
            "UTF8");
    nbtarget.write(writer);
    writer.close();

    String pahtexe = "\\\\10.2.50.190\\AutoAlignerCLI\\AutoAlignerCLI.exe";

    ProcessBuilder pb = new ProcessBuilder(
            new String[] { pahtexe, "-i", this.nbalignerfolder, "-o", this.nbalignerfolder, "-lang_pairs",
                    this.sourcelanguage + "_" + this.targetlanguage, "-lang_detect", "normal", "-identicals",
                    "-match_filenames", "-txml_or_xmx_output", "-docnames_output", "-disallow_src_merging" });
    pb.redirectErrorStream(true);

    Process p = pb.start();
    InputStreamReader isr = new InputStreamReader(p.getInputStream());
    BufferedReader br = new BufferedReader(isr);

    boolean sentESTTime = false;
    boolean alignstart = false;
    String lineRead;
    while ((lineRead = br.readLine()) != null) {
        System.out.println(lineRead);
        if (lineRead.contains("Aligning...")) {
            alignstart = true;
        } else {
            if ((lineRead.contains("Estimated Time to Completion:")) && (alignstart)) {
                this.estimateNBAlignerCompTime = lineRead.replace("Estimated Time to Completion: ", "")
                        .replace(" Minute(s)", "");
            }
            if ((!this.estimateNBAlignerCompTime.equals("")) && (!sentESTTime)) {
                sentESTTime = true;
                try {
                    int minutes = 200 + Integer.parseInt(this.estimateNBAlignerCompTime);
                    setAlignProgress(prjid, minutes);
                    this.estimateNBAlignerCompTime = "";
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
    p.waitFor();

    for (File file : new File(this.nbalignerfolder).listFiles()) {
        if (file.getName().endsWith(".zip")) {
            UnzipFile.UnZipIt(file.getAbsolutePath(), this.nbalignerfolder);
        }
    }
    String alignedtxml = "";
    for (File file : new File(this.nbalignerfolder).listFiles()) {
        if (file.getName().endsWith(".txml")) {
            alignedtxml = file.getAbsolutePath();
        }
    }
    if (alignedtxml.equals("")) {
        throw new Exception("file didn't aligned by nbaligner");
    }
    HashMap<String, String[]> alignedtrgs = new HashMap();
    List<String[]> missingtrgs = new ArrayList();
    int src_idx = -1;

    org.dom4j.Document alignedtxmldoc = XmlParser.parseXmlFile(alignedtxml);
    org.dom4j.Element root_alignedtxmldoc = alignedtxmldoc.getRootElement();
    for (int i = 0; i < root_alignedtxmldoc.elements("translatable").size(); i++) {
        org.dom4j.Element translatable = (org.dom4j.Element) root_alignedtxmldoc.elements("translatable")
                .get(i);
        for (int j = 0; j < translatable.elements("segment").size(); j++) {
            org.dom4j.Element segment = (org.dom4j.Element) translatable.elements("segment").get(j);
            org.dom4j.Element source = segment.element("source");
            org.dom4j.Element target = segment.element("target");
            if ((source != null) && (!source.getTextTrim().equals(""))) {
                src_idx++;
                if ((target != null) && (!target.getTextTrim().equals(""))) {
                    String matchscore = target.attributeValue("score");
                    int trg_idx = Integer.parseInt(target.attributeValue("sent_no"));
                    if (matchscore.equals("0")) {
                        alignedtrgs.put(Integer.toString(src_idx),
                                new String[] { target.getTextTrim(), "1", Integer.toString(trg_idx) });
                    } else if (target.attribute("original_segments_count") != null) {
                        int merged_cnt = Integer.parseInt(target.attributeValue("original_segments_count"));
                        String trg_idx_str = Integer.toString(trg_idx) + " - "
                                + Integer.toString(trg_idx + merged_cnt - 1);
                        alignedtrgs.put(Integer.toString(src_idx),
                                new String[] { target.getTextTrim(), matchscore, trg_idx_str });
                    } else {
                        alignedtrgs.put(Integer.toString(src_idx),
                                new String[] { target.getTextTrim(), matchscore, Integer.toString(trg_idx) });
                    }
                }
            } else if ((target != null) && (!target.getTextTrim().equals(""))) {
                String matchscore = target.attributeValue("score");
                int trg_idx = Integer.parseInt(target.attributeValue("sent_no"));

                missingtrgs.add(new String[] { target.getTextTrim(), Integer.toString(trg_idx) });
            }
        }
    }
    int null_idx = 0;
    List<org.dom4j.Element> groups = aligned.elements("group");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);
        List<org.dom4j.Element> units = group.elements("unit");
        for (int j = 0; j < units.size(); j++) {
            org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
            org.dom4j.Element src_para = unit.element("src_para");
            org.dom4j.Element src_para_segs = src_para.element("segments");
            org.dom4j.Element trg_para = unit.addElement("trg_para");
            org.dom4j.Element trg_para_segs = trg_para.addElement("segments");
            List<org.dom4j.Element> src_segs = src_para_segs.elements("src_seg");
            for (int z = 0; z < src_segs.size(); z++) {
                org.dom4j.Element src_seg = (org.dom4j.Element) src_segs.get(z);
                org.dom4j.Element trg_seg = trg_para_segs.addElement("trg_seg");

                String mapid = Integer.toString(i) + " - " + Integer.toString(j) + " - " + Integer.toString(z);
                trg_seg.addAttribute("edited", "false");
                String trgsegtext = "";
                if (srcidmap.containsKey(mapid)) {
                    String sourceidintxml = (String) srcidmap.get(mapid);
                    if (alignedtrgs.containsKey(sourceidintxml)) {
                        src_seg.addAttribute("locked", "true");
                        trgsegtext = ((String[]) alignedtrgs.get(sourceidintxml))[0];
                        String score = ((String[]) alignedtrgs.get(sourceidintxml))[1];
                        String targetidintxml = ((String[]) alignedtrgs.get(sourceidintxml))[2];
                        if (Integer.parseInt(score) < needreviewthreshhold) {
                            src_seg.addAttribute("needreview", "true");
                        }
                        trg_seg.addAttribute("id", targetidintxml);
                        trg_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl_trg.isExtractable(trgsegtext)));
                    } else {
                        trg_seg.addAttribute("id", "n - " + null_idx);
                        null_idx++;
                        trg_seg.addAttribute("isExtractable", "false");
                    }
                } else {
                    trg_seg.addAttribute("id", "n - " + null_idx);
                    null_idx++;
                    trg_seg.addAttribute("isExtractable", "false");
                }
                trg_seg.setText(trgsegtext);
            }
        }
    }
    org.dom4j.Element orp_unit = orphans.addElement("unit");
    orp_unit.addAttribute("id", "0");
    org.dom4j.Element orp_trg_para = orp_unit.addElement("trg_para");
    org.dom4j.Element orp_segments = orp_trg_para.addElement("segments");
    for (int i = 0; i < missingtrgs.size(); i++) {
        String orptrgtext = ((String[]) missingtrgs.get(i))[0];
        String orptrgid = ((String[]) missingtrgs.get(i))[1];
        org.dom4j.Element orp_trg_seg = orp_segments.addElement("trg_seg");
        orp_trg_seg.addAttribute("id", orptrgid);
        orp_trg_seg.addAttribute("edited", "false");
        orp_trg_seg.addAttribute("isExtractable",
                Boolean.toString(extractionSupportImpl_trg.isExtractable(orptrgtext)));
        orp_trg_seg.setText(orptrgtext);
    }
    OutputStreamWriter oswriter = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.alignedfile)), "UTF8");
    document.write(oswriter);
    oswriter.close();
}