path: root/lib/rhbzpage.js

/*jslint onevar: false, browser: true, evil: true, laxbreak: true, undef: true, nomen: true, eqeqeq: true, bitwise: true, maxerr: 1000, immed: false, white: false, plusplus: false, regexp: false, undef: false */
// Released under the MIT/X11 license
// http://www.opensource.org/licenses/mit-license.php
"use strict";
var util = require("util");
var xrpc = require("xmlrpc");
var apiUtils = require("api-utils");
var self = require("self");
var clip = require("clipboard");
var Color = require("color").Color;
var BZPage = require("bzpage").BZPage;
var Request = require("request").Request;
var url = require("url");
var timer = require("timer");
var selection = require("selection");
var tabs = require("tabs");
// var NumberOfFrames = 7;
// var bugURL = "https://bugzilla.redhat.com/show_bug.cgi?id=";

// ====================================================================================
// RHBugzillaPage object

var RHBugzillaPage = function RHBugzillaPage(win, config) {
    // inheritance ... call superobject's constructor
    BZPage.call(this, win, config);

    // For identification of graphics card
    var manuChipStrs = [ [ "ATI Radeon", "ATI", "1002" ],
            [ "ATI Mobility Radeon", "ATI", "1002" ],
            [ "Intel Corporation", "INTEL", "8086" ], [ "NVIDIA", "NV", "10de" ] ];

    // http://en.wikipedia.org/wiki/HSL_color_space
    // when only the value of S is changed
    // stupido!!! the string is value in hex for each color
    this.RHColor = new Color(158, 41, 43); // RGB 158, 41, 43; HSL 359, 1, 39
    this.FedoraColor = new Color(0, 40, 103); // RGB 0, 40, 103; HSL 359, 1, 39
    this.RawhideColor = new Color(0, 119, 0); // or "green", or RGB 0, 119, 0, or
                                                // HSL
    // 120, 0, 23
    this.RHITColor = new Color(102, 0, 102); // RGB 102, 0, 102; HSL 300, 0, 20

    this.RE = {
        Comment: new RegExp("^\\s*#"), // unsused
        BlankLine: new RegExp("^\\s*$"), // unused
        // new line
        // [ 65.631] (--) intel(0): Chipset: "845G"
        Chipset: new RegExp("^\\s*\\[?[ 0-9.]*\\]?\\s*\\(--\\) "+
            "([A-Za-z]+)\\([0-9]?\\): Chipset: (.*)$"),
        ATIgetID: new RegExp("^.*\\(ChipID = 0x([0-9a-fA-F]+)\\).*$"),
        Abrt: new RegExp("^\\s*\\[abrt\\]"),
        signalHandler: new RegExp("^\\s*#[0-9]*\\s*<signal handler called>"),
        frameNo: new RegExp("^\\s*#([0-9]*)\\s")
    };

    this.XMLRPCurl = "https://bugzilla.redhat.com/xmlrpc.cgi";
    // END OF CONSTANTS

    var that = this;
    this.reqCounter = 0;
    this.signaturesCounter = 0;
    this.chipMagicInterestingLine = "";

    this.login = this.getLogin();
    this.password = this.getPassword();

    var ITbutton = this.doc.getElementById("cf_issuetracker");
    this.its = ITbutton ? ITbutton.value.trim() : "";

    // set default assignee on change of the component
    this.doc.getElementById("component").addEventListener("change",
            function() {
                that.component = that.getOptionValue("component");
                that.changeAssignee("default");
            }, false);

    // getBadAttachments
    this.XorgLogAttList = [];
    this.XorgLogAttListIndex = 0;
    this.attachments = this.getAttachments();
    this.markBadAttachments();
    this.setDefaultAssignee();

    // Dig out backtrace
    this.btSnippet = "";

    var parseAbrtBacktraces = config.gJSONData.configData.parseAbrtBacktraces;
    if (parseAbrtBacktraces && this.RE.Abrt.test(this.title)) {
        this.pasteBacktraceInComments();
    }

    // Take care of signature for Fedora bugzappers
    if (config.gJSONData.configData.signature.length > 0) {
        var signatureFedoraString = config.gJSONData.configData.signature;
        this.doc.forms.namedItem("changeform").addEventListener("submit",
                function() {
                    if (this.signaturesCounter < 1) {
                        that.addStuffToTextBox("comment", signatureFedoraString);
                        this.signaturesCounter += 1;
                    }
                }, false);
    }

    this.setBranding();
    this.checkComments();

    // TODO Get compiz bugs as well
    if ((config.gJSONData.configData.PCIIDsURL
            && (config.PCI_ID_Array.length > 0))
            && this.maintCCAddr === "xgl-maint@redhat.com") {
        // Add find chip magic button
        var whiteboard_string = this.doc.getElementById("status_whiteboard").value;
        if (!/card_/.test(whiteboard_string)) {
            this.fillInChipMagic();
        }
    }
}; // END OF RHBugzillaPage CONSTRUCTOR

RHBugzillaPage.prototype.toString = function toString () {
    return ("[Object RHBugzillaPage]");
};

RHBugzillaPage.prototype = util.heir(BZPage);
RHBugzillaPage.prototype.constructor = RHBugzillaPage;

/**
 * Find default assignee based on the current component
 *
 * @return String what would be a default assignee if
 * we haven't set it up.
 */
RHBugzillaPage.prototype.getDefaultAssignee = function() {
    return util.filterByRegexp(this.constantData.defaultAssignee,
        this.component).toLowerCase();
};

/**
 * Set default assignee
 *
 * @return none
 * sets this.defaultAssignee property according to defaultAssignee list
 */
RHBugzillaPage.prototype.setDefaultAssignee = function() {
    this.defaultAssignee = this.getDefaultAssignee();
    var defAss = this.defaultAssignee;

    // Add setting default assignee
    if ((defAss.length > 0) && (defAss !== this.getOwner())) {
        this.constantData.defaultAssigneeTrigger = true;
        this.createNewButton("bz_assignee_edit_container",true,"rh-common","setDefaultAssignee");
    }
};

/**
 * Auxiliary function to computer more complicated resolution
 */
RHBugzillaPage.prototype.closeSomeRelease = function() {
    // for RAWHIDE close as RAWHIDE,
    // if active selection -> CURRENTRELEASE
    // and put the release version to
    // "Fixed in Version" textbox
    // otherwise -> NEXTRELEASE
    var verNo = this.getVersion();
    this.selectOption("bug_status", "CLOSED");
    var text = "";
    var resolution = "";

    if (selection.text) {
        text = selection.text.trim();
    }
    if (text.length > 0) {
        resolution = "CURRENTRELEASE";
        this.doc.getElementById("cf_fixed_in").value = text;
    } else if (verNo === 999) {
        resolution = "RAWHIDE";
    } else {
        resolution = "NEXTRELEASE";
    }
    this.centralCommandDispatch("resolution", resolution);
};

/**
 * Additional commands specific for this subclass, overriding superclass one.
 */
RHBugzillaPage.prototype.centralCommandDispatch = function(cmdLabel, cmdParams) {
    console.log("cmdLabel = " + cmdLabel + ", cmdParams = " + cmdParams);
    switch (cmdLabel) {
        // Set up our own commands
        case "closeUpstream":
            this.addClosingUpstream();
            break;
        case "computeResolution":
            this.closeSomeRelease();
            break;
        case "queryStringOurBugzilla":
            this.queryForSelection();
            break;
        case "queryStringUpstreamBugzilla":
            this.queryUpstream();
            break;
        case "sendBugUpstream":
            this.sendBugUpstream();
            break;
        case "markTriaged":
            this.markBugTriaged();
            break;
        case "chipMagic":
            var splitArr = cmdParams.split("\t");
            this.fillInWhiteBoard(splitArr[0], splitArr[1]);
            break;
        // If we don't have it here, call superclass method
        default:
            BZPage.prototype.centralCommandDispatch.call(this, cmdLabel, cmdParams);
            break;
    }
};


/* Bugzilla functions. */

RHBugzillaPage.prototype.ProfessionalProducts = [
    "Red Hat Enterprise Linux",
    "Red Hat Enterprise MRG"
];

/**
 *
 */
RHBugzillaPage.prototype.pasteBacktraceInComments = function() {
    // FIXME This paragraph looks suspicous ... what is it?
    // Does it belong to this function?
    var notedLabel = this.doc.querySelector("label[for='newcc']");
    while (notedLabel.firstChild) {
        var node = notedLabel.removeChild(notedLabel.firstChild);
        notedLabel.parentNode.insertBefore(node, notedLabel);
    }
    notedLabel.parentNode.removeChild(notedLabel);

    var abrtQueryURL = "https://bugzilla.redhat.com/buglist.cgi?"
        + "cmdtype=dorem&remaction=run&namedcmd=all%20NEW%20abrt%20crashes&sharer_id=74116";

    var mainTitle = this.doc
            .getElementsByClassName("bz_alias_short_desc_container")[0];
    var abrtButton = this.doc.createElement("a");
    abrtButton.setAttribute("accesskey", "a");
    abrtButton.setAttribute("href", abrtQueryURL);
    abrtButton.textContent = "Abrt bugs";
    mainTitle.appendChild(abrtButton);

    if (this.idContainsWord("cf_devel_whiteboard", 'btparsed')) {
        this.addStuffToTextBox('status_whiteboard', 'btparsed');
    }

    if (!(this.isTriaged() || this.idContainsWord("status_whiteboard",
            'btparsed'))) {
        var btAttachments = this.attachments
                .filter(function(att, idx, arr) {
                    return (/backtrace/.test(att[0]));
                });
        // TODO we need to go through all backtrace attachments, but
        // just the first one will do for now, we would need to do async
        // parsing
        btAttachments.forEach(function(x) {
            attURL = "https://bugzilla.redhat.com/attachment.cgi?id="
                    + x[1];
            if (!this.btSnippet) {
                var that = this;
                Request({
                    url: attURL,
                    onComplete: function() {
                        that.btSnippet = that.parseBacktrace(this.response.text);
                        if (that.btSnippet) {
                            that.addStuffToTextBox("comment", that.btSnippet);
                            that.addStuffToTextBox("status_whiteboard",
                                    "btparsed");
                        }
                    }
                }).get();
            }
        }, this);
    }
};

/**
 *
 */
RHBugzillaPage.prototype.markBadAttachments = function() {
    var badMIMEArray = [ "application/octet-stream", "text/x-log", "undefined" ];

    var badAttachments = this.attachments.filter(function(att, idx, arr) {
        return (util.isInList(att[2], badMIMEArray));
    });

    if (badAttachments.length > 0) {
        var titleElement = this.doc
                .getElementsByClassName("bz_alias_short_desc_container")[0];
        titleElement.style.backgroundColor = "olive";
        titleElement.appendChild(this.createFixAllButton(badAttachments));
        badAttachments.forEach(function(x, i, a) {
            this.addTextLink(x);
        }, this);
    }
};

/**
 * Is this bug a RHEL bug?
 *
 * @return Boolean true if it is a RHEL bug
 */
RHBugzillaPage.prototype.isEnterprise = function() {
    var prod = this.product;
    var result = this.ProfessionalProducts.some(function(elem,idx,arr) {
        return new RegExp(elem).test(prod);
    });
    return result;
};

/**
 * Find out whether the bug is needed an attention of bugZappers
 *
 * @return Boolean whether the bug has been triaged or not
 */
RHBugzillaPage.prototype.isTriaged = function() {
    // First excceptions
    if (this.version > 7 && this.version < 12) {
        return this.doc.getElementById("bug_status").value.toUpperCase() !== "NEW";
    } else { // and then the rule
        return this.hasKeyword("Triaged");
    }
};

/**
 * Set branding colours to easily distinguish between Fedora and RHEL bugs
 *
 * @param brand String with product of the current bug
 * @param version String with the version of the bug
 * @param its String with the IsueTracker numbers
 * @return none
 */
RHBugzillaPage.prototype.setBranding = function() {
    var brandColor = {};
    var TriagedColor = {};

    if (this.isEnterprise()) {
        if (this.its && (this.its.length > 0)) {
            brandColor = this.RHITColor;
        } else {
            brandColor = this.RHColor;
        }
    } else if (new RegExp("Fedora").test(this.product)) {
        if (this.version === 999) {
            brandColor = this.RawhideColor;
        } else {
            brandColor = this.FedoraColor;
        }
    }

    // Comment each of the following lines to get only partial branding
    this.doc.getElementsByTagName("body")[0].style.background = brandColor
            .toString()
            + " none";
    this.doc.getElementById("titles").style.background = brandColor.toString()
            + " none";

    // Remove "Bug" from the title of the bug page, so we have more space with
    // plenty of tabs
    var titleElem = this.doc.getElementsByTagName("title")[0];

    titleElem.textContent = titleElem.textContent.slice(4);
    var bodyTitleParent = this.doc.getElementById("summary_alias_container").parentNode;
    var bodyTitleElem = bodyTitleParent.getElementsByTagName("b")[0];
    bodyTitleElem.textContent = bodyTitleElem.textContent.slice(4);

    // Make background-color of the body of bug salmon pink
    // for security bugs.
    if (this.hasKeyword("Security")) {
        this.doc.getElementById("bugzilla-body").style.background = this.SalmonPink
                .toString() + ' none';
    }

    // Make it visible whether the bug has been triaged
    if (this.isTriaged()) {
        this.doc.getElementById("bz_field_status").style.background = brandColor
                .lightColor().toString()
                + " none";
    }

    // we should make visible whether maintCCAddr is in CCList
    if (util.isInList(this.maintCCAddr, this.CCList)) {
        var ccEditBoxElem = this.doc.getElementById("cc_edit_area_showhide");
        // ccEditBoxElem.textContent = "*"+ccEditBoxElem.textContent;
        ccEditBoxElem.style.color = "navy";
        ccEditBoxElem.style.fontWeight = "bolder";
        ccEditBoxElem.style.textDecoration = "underline";
    }

    // mark suspicious components
    var compElems;
    if (this.suspiciousComponents
            && util.isInList(this.component, this.suspiciousComponents)
            && (compElems = this.doc
                    .getElementById("bz_component_edit_container"))) {
        compElems.style.background = "red none";
    }
};

/**
 * Given line to be parsed, find out which chipset it is and fill in the
 * whiteboard
 *
 * @param iLine String with the whole unparsed "interesting line"
 * @param driverStr String with the driver name
 * @return None
 */
RHBugzillaPage.prototype.fillInWhiteBoard = function(iLine, driverStr) {
    var that = this;

    function groupIDs(manStr, cardStrID) {
        var outStr = util.filterByRegexp(config.chipIDsGroupings, manStr + "," + cardStrID);
        if (outStr.length === 0) {
            outStr = "UNGROUPED_" + manStr + "/" + cardStrID;
        }
        return outStr;
    }

    /**
     * Given PCI IDs for manufacturer and card ID return chipset string
     *
     * @param manufacturerNo String with manufacturer PCI ID
     * @param cardNo String with card PCI ID
     * @return Array with chip string and optinoal variants
     */
    function checkChipStringFromID(manufacturerNo, cardNo) {
        var soughtID = (manufacturerNo + "," + cardNo).toUpperCase();
        var outList = config.PCI_ID_Array[soughtID];
        if (outList) {
            return outList;
        } else {
            return "";
        }
    }

    var outStr = "";
    var cardIDStr = "";
    var cardIDArr = [];

    chipSwitchboard: if (driverStr === "RADEON") {
        var cardID = iLine.replace(this.RE.ATIgetID, "$1");
        cardIDArr = checkChipStringFromID("1002", cardID);
        if (cardIDArr.length > 0) {
            cardIDStr = cardIDArr[0];
            if (cardIDArr[1]) {
                optionStr = cardIDArr[1];
                outStr = groupIDs(driverStr, cardIDStr) + "/" + optionStr;
            } else {
                outStr = groupIDs(driverStr, cardIDStr);
                optionStr = "";
            }
        } else {
            outStr = "**** FULLSTRING: " + iLine;
        }
    } else {
        // Intel Corporation, NVIDIA
        cardIDArr = manuChipStrs.filter(function(el, ind, arr) {
            return new RegExp(el[0], "i").test(iLine);
        });
        if (cardIDArr && (cardIDArr.length > 0)) {
            cardIDArr = cardIDArr[0];
        } else {
            outStr = iLine;
            break chipSwitchboard;
        }
        // cardIDArr [0] = RE, [1] = ("RADEON","INTEL","NOUVEAU"), [2] = manu
        // PCIID
        iLine = iLine.replace(new RegExp(cardIDArr[0], "i")).trim();
        // nVidia developers opted-out from grouping
        if (driverStr === "INTEL") {
            outStr = groupIDs(cardIDArr[1], iLine);
        } else {
            outStr = iLine;
        }
    }
    this.addStuffToTextBox("status_whiteboard", ("card_" + outStr).trim());
    this.doc.getElementById("chipmagic").style.display = "none";
};

/**
 * Get attached Xorg.0.log, parse it and find the value of chip. Does not fill
 * the whiteboard itself, just adds button to do so,paramList so that slow
 * XMLHttpRequest is done in advance.
 *
 * @return None
 */
RHBugzillaPage.prototype.fillInChipMagic = function () {
    var that = this;
    var XorgLogURL = "";
    var XorgLogAttID = "";
    var XorgLogFound = false;
    var attURL = "", interestingLine = "";
    var interestingArray = [];


    // Find out Xorg.0.log attachment URL
    this.XorgLogAttList = this.attachments.filter(function (value, index, array) {
        // Xorg.0.log must be text, otherwise we cannot parse it
        return (/[xX].*log/.test(value[0]) && /text/.test(value[2]));
    });
    if (this.XorgLogAttList.length === 0) {
        return;
    }

    XorgLogAttID = this.XorgLogAttList[this.XorgLogAttListIndex][1];
    attURL = "https://bugzilla.redhat.com/attachment.cgi?id="+XorgLogAttID;
    var that = this;

    // parse Xorg.0.log
    Request({
        url: attURL,
        onComplete: function () {
            var interestingLineArr = this.response.text.split("\n").
                filter(function (v,i,a) {
                    return that.RE.Chipset.test(v);
            });
            if (interestingLineArr.length >0) {
                // TODO we are parsing only the first found line; is it alright?
                interestingArray = that.RE.Chipset.exec(interestingLineArr[0]);
                interestingLine = interestingArray[2].
                    replace(/[\s"]+/g," ").trim();
                // Persuade createNewButton to have mercy and to actually add
                // non-default button
                that.constantData.chipMagicTrigger = true;
                that.chipMagicInterestingLine = interestingLine+"\t"+interestingArray[1]
                    .toUpperCase();
                that.createNewButton("status_whiteboard", true, "rh-xorg", "chipMagic");
            }
        }
    }).get();
    this.XorgLogAttListIndex++;
};

RHBugzillaPage.prototype.getSelectionOrClipboard = function getSelectionOrClipboard () {
    var text = selection.text;
    if (!text) {
        text = clip.get();
    }
    return text;
};

/**
 * Opens a new tab with a query for the given text in the selected component
 *
 * @param text to be searched for
 * @param component String with the component name (maybe latter regexp?)
 * @param product (optional) string with the product name, if undefined,
 *        search in all products
 * @return None
 *
 */
RHBugzillaPage.prototype.queryInNewTab = function(text, component, product) {
    var urlStr = "https://bugzilla.redhat.com/buglist.cgi?query_format=advanced";
    if (product) {
        urlStr += "&product=" + product.trim();
    }
    if (component) {
        urlStr += "&field0-0-0=component&type0-0-0=substring&value0-0-0="
                + component.trim();
    }
    // using more complicated query tables here, because they can be more easily
    // edited
    // for further investigative searches
    if (text) {
        text = encodeURIComponent(text.trim());
        var searchText = "&field1-0-0=longdesc&type1-0-0=substring&value1-0-0="
                + text
                + "&field1-0-1=attach_data.thedata&type1-0-1=substring&value1-0-1="
                + text
                + "&field1-0-2=status_whiteboard&type1-0-2=substring&value1-0-2="
                + text;
        urlStr += searchText;
        tabs.open({
            url: urlStr,
            inBackground: true,
            onOpen: function (t) {
                t.activate();
            }
        });
    }
};

/**
 * Get the text to search for and prepare other things for the real executive
 * function this.queryInNewTab, and run it.
 */
RHBugzillaPage.prototype.queryForSelection = function() {
    var text = this.getSelectionOrClipboard();
    if (text) {
        this.queryInNewTab(text, this.component);
    }
};

/**
 * Search simple query in the upstream bugzilla appropriate for the component.
 */
RHBugzillaPage.prototype.queryUpstream = function() {
    console.log("Querying upstream!");
    var text = this.getSelectionOrClipboard();
    if (text) {
        text = encodeURIComponent(text.trim());
        var queryUpstreamBugsURLArray = self.data.load("queryUpstreamBug.json");
        var urlBase = util.filterByRegexp(queryUpstreamBugsURLArray, this.component);
        tabs.open({
            url: urlBase + text,
            inBackground: true,
            onOpen: function (t) {
                t.activate();
            }
        });
    }
};

/**
 *
 */
RHBugzillaPage.prototype.sendBugUpstream = function() {
    var that = this;
    var urlStr = util.filterByRegexp(JSON.parse(self.data.load("newUpstreamBug.json")), this
            .getOptionValue("component"));

    var ret = tabs.open({
        url: urlStr,
        inBackground: true,
        onOpen: function (tab) {
            var otherDoc = tab.contentDocument;
            var otherElems = otherDoc.forms.namedItem("Create").elements;
            otherElems.namedItem("short_desc").value = that.doc
                    .getElementById("short_desc_nonedit_display").textContent
                    .trim();
            otherElems.namedItem("comment").value = that.collectComments();
            ret.focus();
        }
    });
};

/**
 * Parse the row with the attachment
 *
 * @param DOM element to be parsed
 * @return array with string name of the attachment, integer its id number,
 *         string of MIME type, integer of size in kilobytes, and the whole
 *         element itself
 */
RHBugzillaPage.prototype.parseAttachmentLine = function(inElem) {
    var MIMEtype = "";
    var size = 0;

    // Skip over obsolete attachments
    if (inElem.getElementsByClassName("bz_obsolete").length > 0) {
        return ( []);
    }

    // getting name of the attachment
    // FIXME probably could use url.URL object
    var attName = inElem.getElementsByTagName("b")[0].textContent.trim();

    var aHrefsArr = inElem.getElementsByTagName("a");
    var aHref = Array.filter(aHrefsArr, function(x) {
        return x.textContent.trim() === "Details";
    })[0];
    var id = parseInt(aHref.getAttribute("href").replace(
            /^.*attachment.cgi\?id=/, ""), 10);

    // getting MIME type and size
    var stringArray = inElem.getElementsByClassName("bz_attach_extra_info")[0].textContent
            .replace(/[\n ()]+/g, " ").trim().split(", ");
    size = parseInt(stringArray[0], 10);
    MIMEtype = stringArray[1].split(" ")[0];

    return [ attName, id, MIMEtype, size, inElem ];
};

/**
 * Add accesskey to the particular element
 *
 * @param rootElement Element to which the new text object will be attached
 * @param beforeText Text before the accesskey character
 * @param accKey what will be the accesskey itself
 * @param afterText text after the accesskey character
 * @return modified element with the fixed accesskey
 */
RHBugzillaPage.prototype.fixElement = function(elem, beforeText, accKey, afterText) {
    elem.setAttribute("accesskey", accKey.toLowerCase());
    elem.innerHTML = beforeText + "<b><u>" + accKey + "</u></b>" + afterText;
    return elem;
};

/**
 * Return string with the ID for the external_id SELECT for external bugzilla
 *
 * @param URLhostname String hostname of the external bugzilla
 * @return String with the string for the external_id SELECT
 */
RHBugzillaPage.prototype.getBugzillaName = function(URLhostname) {
    var bugzillaID = "";
    var bzLabelNames = JSON.parse(self.data.load("bugzillalabelNames.json"));
    if (bzLabelNames[URLhostname]) {
        bugzillaID = bzLabelNames[URLhostname];
    } else {
        bugzillaID = "";
    }
    return bugzillaID;
};

/**
 * Callback function for the XMLRPC request
 *
 * @param ret Object with xmlhttprequest response with attributes:
 * + status -- int return code
 * + statusText
 * + responseHeaders
 * + responseText
 */
RHBugzillaPage.prototype.fixingMIMECallBack = function() {
    var that = this;
    console.log("fixingMIMECallBack / that.doc = " + that.doc);
    console.log("fixingMIMECallBack / that.win = " + that.win);
    if (--this.reqCounter <= 0) {
        timer.setTimeout(function () {
            that.win.location.reload(true);
        }, 1000);
    }
};

/**
 * The worker function -- call XMLRPC to fix MIME type of the particular
 * attachment
 *
 * @param id Integer with the attachment id to be fixed
 * @param type String with the new MIME type, optional defaults to "text/plain"
 * @param email Boolean whether email should be sent to appropriate person;
 *            option, defaults to false
 *
 * updateAttachMimeType($data_ref, $username, $password)
 *
 * Update the attachment mime type of an attachment. The first argument is a
 * data hash containing information on the new MIME type and the attachment id
 * that you want to act on.
 *
 * $data_ref = { "attach_id" => "<Attachment ID>", # Attachment ID to perform
 * MIME type change on. "mime_type" => "<New MIME Type Value>", # Legal MIME
 * type value that you want to change the attachment to. "nomail" => 0, #
 * OPTIONAL Flag that is either 1 or 0 if you want email to be sent or not for
 * this change };
 *
 */
RHBugzillaPage.prototype.fixAttachById = function(id, type, email) {
    if (type === undefined) {
        type = "text/plain";
    }
    if (email === undefined) {
        email = false;
    }

    var that = this;
    var msg = new xrpc.XMLRPCMessage("bugzilla.updateAttachMimeType");
    msg.addParameter( {
        'attach_id' : id,
        'mime_type' : type,
        'nomail' : !email
    });
    msg.addParameter(this.login);
    msg.addParameter(this.password);

    // https://bugzilla.redhat.com/\
    // docs/en/html/api/extensions/compat_xmlrpc/code/webservice.html
    // test on https://bugzilla.redhat.com/show_bug.cgi?id=485145
    Require({
        url: this.XMLRPCurl,
        onComplete: function() {
            that.fixingMIMECallBack.call(that);
        },
        data: msg.xml(),
        contentType: "text/xml",
    });
//    util.httpPOST(this.XMLRPCurl, msg.xml(), this.fixingMIMECallBack,
//    		this, "text/xml", "text/xml");
    this.reqCounter++;
};

/**
 * Create a button for fixing all bad attachments.
 *
 * @param list Array of all bad attachmentss
 * @return button fixing all bad Attachments
 */
RHBugzillaPage.prototype.createFixAllButton = function(list) {
    if (!xrpc.XMLRPCMessage) {
        return;
    }
    var that = this;
    var elem = this.doc.createElement("a");
    elem.setAttribute("href", "");
    elem.setAttribute("accesskey", "f");
    elem.innerHTML = "<b>F</b>ix all";
    elem.addEventListener("click", function() {
        Array.forEach(list, function(x) {
            this.fixAttachById(x[1]);
        }, that);
    }, false);
    return elem;
};

/**
 * Add a link to the bad attachment for fixing it.
 *
 * @param
 * <TR> DOM jQuery element with a bad attachment
 * @return none
 */
RHBugzillaPage.prototype.addTextLink = function(row) {
    var that = this;
    var elemS = row[4].getElementsByTagName("td");
    var elem = elemS[elemS.length - 1];
    elem.innerHTML += "<br/><a href=''>Text</a>";
    elem.addEventListener("click", function(x) {
        that.fixAttachById(row[1], "text/plain");
    }, false);
};

/**
 * Add information about the upstream bug upstream, and closing it.
 *
 * @param evt Event which called this handler
 * @return none
 */
RHBugzillaPage.prototype.addClosingUpstream = function() {
    var refs = this.doc.getElementById("external_bugs_table")
            .getElementsByTagName("tr");
    // that's a bad id, if there is a one. :)
    var inputBox = this.doc.getElementById("inputbox");
    var externalBugID = 0;
    var wholeURL = "";

    // FIXME Hopefully unfinished and even less tested
    // Fix missing ID on the external_id SELECT
    this.doc.getElementsByName("external_id")[0].setAttribute("id",
            "external_id");

    if (inputBox.value.match(/^http.*/)) {
        wholeURL = inputBox.value;
        var helpURL = new url.URL(wholeURL);
        var paramsArr = helpURL.path.replace(/^\?/, '').split('&');
        // get convert URL parameters to an Object
        var params = {}, s = [];
        paramsArr.forEach(function(par, idx, arr) {
            s = par.split('=');
            params[s[0]] = s[1];
        });
        if (params.id) {
            externalBugID = parseInt(params.id, 10);
            inputBox.value = externalBugID;
        }
        // get host and bugzillaName
        var bugzillaName = this.getBugzillaName(helpURL.hostname);
        this.selectOption("external_id", bugzillaName);
    } else if (!isNaN(inputBox.value)) {
        externalBugID = parseInt(inputBox.value, 10);
        var bugzillaHostname = this.doc.getElementById("external_id").value;
        wholeURL = bugzillaHostname+"show_bug.cgi?id="+externalBugID;
    } else {
        // no inputBox.value -- maybe there is an external bug from
        // the previous commit?
    }

    // FIXME THis is not good, we don't have a feedback for other commands,
    // not to be run, if this fails.

    // It is not good to close bug as UPSTREAM, if there is no reference
    // to the upstream bug.
    if ((externalBugID > 0) || (refs.length > 2)) {
        var msgStr = this.commentStrings.sentUpstreamString;
        msgStr = msgStr.replace("§§§", wholeURL);
        this.centralCommandDispatch("comment",msgStr);
        this.centralCommandDispatch("status", "CLOSED");
        this.centralCommandDispatch("resolution", "UPSTREAM");
    } else {
        console.log("No external bug specified among the External References!");
    }
};

RHBugzillaPage.prototype.markBugTriaged = function() {
    // Now we lie completely, we just set keyword Triaged,
    // this is not just plain ASSIGNED, but
    // modified according to
    // https://fedoraproject.org/wiki/BugZappers/Meetings/Minutes-2009-Oct-27
    // and
    // http://meetbot.fedoraproject.org/fedora-meeting/2009-11-24\
    // /fedora-meeting.2009-11-24-15.11.log.html
    // and
    // http://meetbot.fedoraproject.org/fedora-meeting/2009-11-24\
    // /fedora-meeting.2009-11-24-15.11.log.html
    // for F13 and later, ASSIGNED is "add Triaged keyword" (as well)
    // for <F13 it is "add both" (ASSIGNED status and Triaged keyword)
    var ver = this.getVersion();
    console.log("Marking bug as Triaged!");
    if ((!this.isEnterprise()) && (ver <= 12)) {
        this.selectOption("bug_status", "ASSIGNED");
    }
    this.addStuffToTextBox("keywords","Triaged");
};

/**
 *
 */
RHBugzillaPage.prototype.parseBacktrace = function(ret) {
    var splitArray = ret.split("\n");
    var i = 0, ii = splitArray.length;
    var outStr = "", curLine = "", numStr = "";
    var lineCounter = 0, endLineNo = 0;

    while (i < ii) {
        if (this.RE.signalHandler.test(splitArray[i])) {
            break;
        }
        i++;
    }

    if (i < ii) {
        lineCounter = parseInt(this.RE.frameNo.exec(splitArray[i])[1], 10);
        endLineNo = lineCounter + NumberOfFrames;
        curLine = splitArray[i];
        while ((lineCounter < endLineNo) && (curLine.trim().length > 0)
                && (i < ii)) {
            outStr += curLine + '\n';
            numStr = this.RE.frameNo.exec(curLine);
            if (numStr) {
                lineCounter = parseInt(numStr[1], 10);
            }
            i++;
            curLine = splitArray[i];
        }
    }
    return outStr;
};

// exports.RHBugzillaPage = apiUtils.publicConstructor(RHBugzillaPage);
exports.RHBugzillaPage = RHBugzillaPage;