src/legacy/EstimationBoardApp.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<!-- Copyright (c) 2011  Rally Software Development Corp.  All rights reserved -->
<html>
<head>
    <title>Estimation Board</title>
    <meta name="Name" content="App: Estimation Board"/>
    <meta name="Version" content="2012.01.14"/>
    <meta name="Vendor" content="Rally Software"/>
    <script type="text/javascript" src="/apps/1.33/sdk.js?apiVersion=1.31"></script>

    <script type="text/javascript">
    function EstimationBoard(rallyDataSource, settingsShow, sizes) {
            var cardboard;
            var that = this;
            var checkBoxes = [];

            this._createLayout = function(element) {

                rally.sdk.ui.AppHeader.showPageTools(true);
                rally.sdk.ui.AppHeader.setHelpTopic("236");

                var headerDiv = document.createElement("div");
                element.appendChild(headerDiv);

                var controlDiv = document.createElement("div");
                dojo.addClass(controlDiv, "controlContainer");
                headerDiv.appendChild(controlDiv);

                var checkBoxContainerDiv = document.createElement("div");
                dojo.addClass(checkBoxContainerDiv, "typeFilterContainer");
                controlDiv.appendChild(checkBoxContainerDiv);

                var showSpan = document.createElement("span");
                showSpan.appendChild(document.createTextNode("Show:"));
                checkBoxContainerDiv.appendChild(showSpan);

                var userStoriesSpan = document.createElement("span");
                userStoriesSpan.id = "userStories";
                checkBoxContainerDiv.appendChild(userStoriesSpan);

                var userStoriesCheckBox = new rally.sdk.ui.basic.Checkbox({
                    showLabel: true,
                    label: "User Stories",
                    labelPosition: "after",
                    value: "HierarchicalRequirement",
                    checked: true
                });
                checkBoxes.push(userStoriesCheckBox);
                userStoriesCheckBox.display(userStoriesSpan);

                var defectsSpan = document.createElement("span");
                defectsSpan.id = "defects";
                checkBoxContainerDiv.appendChild(defectsSpan);

                var defectsCheckBox = new rally.sdk.ui.basic.Checkbox({
                    showLabel: true,
                    label: "Defects",
                    labelPosition: "after",
                    value: "Defect"
                });
                checkBoxes.push(defectsCheckBox);
                defectsCheckBox.display(defectsSpan);

                var defectSuitesSpan = document.createElement("span");
                defectSuitesSpan.id = "defectSuites";
                checkBoxContainerDiv.appendChild(defectSuitesSpan);

                var defectSuitesCheckBox = new rally.sdk.ui.basic.Checkbox({
                    showLabel: true,
                    label: "Defect Suites",
                    labelPosition: "after",
                    value: "DefectSuite"
                });
                checkBoxes.push(defectSuitesCheckBox);
                defectSuitesCheckBox.display(defectSuitesSpan);

                var clearDiv = document.createElement("div");
                dojo.addClass(clearDiv, "clearFloats");
                headerDiv.appendChild(clearDiv);

                var kanbanBoard = document.createElement("div");
                kanbanBoard.id = "cardBoard";
                dojo.addClass(kanbanBoard, "cardBoard");
                element.appendChild(kanbanBoard);


                //Wire up events
                dojo.forEach(checkBoxes, function(checkBox) {
                    checkBox.addEventListener("onChange", that._refreshBoard);
                });

            };

            this._numericSort = function(o1, o2) {
                var key1, key2;

                rally.forEach(o1, function(value1, keyorig1) {
                    key1 = parseFloat(keyorig1);
                });
                rally.forEach(o2, function(value2, keyorig2) {
                    key2 = parseFloat(keyorig2);
                });

                if (key1 === key2) {
                    return 0;
                }

                return key1 < key2 ? -1 : 1;
            };

            this._getColumns = function() {
                var columns = [];
                rally.forEach(sizes, function(label, size) {
                    var columnObj = {};
                    columnObj[size] = { displayValue: label };
                    columns.push(columnObj);
                });

                columns = columns.sort(that._numericSort);
                return columns;
            };

            this._getItems = function(callback) {

                //Build types based on checkbox selections
                var panelContext = rally.sdk.util.Context.getPanelContext();
                var queries = [];
                dojo.forEach(checkBoxes, function(checkBox) {
                    if (checkBox.getChecked()) {
                        var queryObj = {key:checkBox.getValue(),
                            type: checkBox.getValue(),
                            fetch: "Name,FormattedID,Owner,ObjectID,Rank,PlanEstimate,Children,Ready,Blocked",
                            query: "(ScheduleState < Accepted)",
                            order: "Rank"
                        };
                        if(panelContext.timeboxFilter) {
                            queryObj.query = "(" + queryObj.query + " AND " + panelContext.timeboxFilter.query.toString() + ")";
                        }
                        if(checkBox.getValue() === 'HierarchicalRequirement') {
                            queryObj.query = "(" + queryObj.query + " AND (Children.ObjectID = null))";
                        }
                        queries.push(queryObj);
                    }
                });

                function bucketItems(results) {
                    var items = [];
                    rally.forEach(queries, function(query) {
                        if (results[query.key]) {
                            items = items.concat(results[query.key]);
                        }
                    });

                    var columns = dojo.clone(cardboard.getColumns());
                    columns.shift();
                    rally.forEach(items, function(item) {
                        item.RealPlanEstimate = item.PlanEstimate;
                        if (item.PlanEstimate === null || item.PlanEstimate === undefined) {
                            item.PlanEstimate = 0; //Show in not estimated field
                        } else {
                            var bucketed = false;
                            rally.forEach(columns, function(column) {
                                if (!bucketed) {
                                    var columnSize = column.getColumnValue();
                                    if (item.PlanEstimate <= columnSize) {
                                        item.PlanEstimate = columnSize;
                                        bucketed = true;
                                    }
                                }
                            });

                            if (!bucketed) {
                                item.PlanEstimate = columns[columns.length - 1].getColumnValue();
                            }
                        }
                    });
                    callback(items);
                }

                rallyDataSource.find(queries, bucketItems);
            };

            this._refreshBoard = function() {
                var columns = that._getColumns();

                var cardboardConfig = {
                    types: [],
                    attribute: "PlanEstimate",
                    columns: columns,
                    maxCardsPerColumn: 200,
                    items: that._getItems,
                    sortAscending: true,
                    order: "Rank",
                    enableRanking: false
                };

                //Build types based on checkbox selections
                dojo.forEach(checkBoxes, function(checkBox) {
                    if (checkBox.getChecked()) {
                        cardboardConfig.types.push(checkBox.getValue());
                    }
                });

                if (!cardboard) {
                    if (cardboardConfig.types.length === 0) {
                        checkBoxes[0].setChecked(true);
                        cardboardConfig.types.push(checkBoxes[0].getValue());
                    }
                    cardboard = new rally.sdk.ui.CardBoard(cardboardConfig, rallyDataSource);
                    cardboard.addEventListener("preUpdate", function(c, args) {
                        if (parseInt(args.fieldsToUpdate.PlanEstimate, 10) === 0) {
                            args.fieldsToUpdate.PlanEstimate = null;
                        }
                    });
                    cardboard.display("cardBoard");
                } else {
                    cardboard.refresh(cardboardConfig);
                }
            };

            this.display = function(element) {
                var settingsDialog = new EstimationBoardSettings(rallyDataSource);

                //Build app layout
                this._createLayout(element);

                //Refresh board
                this._refreshBoard();
            };

            this.refresh = function() {
                this._refreshBoard();
            };
        }
        /**
         Copyright (c) 2011  Rally Software Development Corp.  All rights reserved
         */

        EstimationBoardSettings = function(rallyDataSource, sizes, prefs) {
            rally.sdk.ComponentBase.call(this);

            var that = this;
            var accessors = [], deleteLinkConnections = [];
            var dialog, projectPrefRef, sizesObject;
            var validationDiv = dojo.byId("validationErrors");

            that.show = function() {
                if (dialog) {
                    dialog.show();
                    that._alignSettingsDialog();
                }
            };

            that.hide = function() {
                if (dialog) {
                    dialog.hide();
                }
            };

            that._saveComplete = function() {
                window.location.reload();
            };

            that._getValues = function() {
                var values = {fieldInfos:{}};
                rally.forEach(accessors, function(value) {
                    values.fieldInfos[value.field] = value.get();
                });
                return values;
            };

            that._storeValues = function(callback) {
                var pref;

                function errorCallback(results) {
                    rally.Logger.warn(results);
                }

                if (!projectPrefRef) {
                    pref = {
                        Name: "EstimationBoard/Settings",
                        Value: that._getValues(),
                        Project:"/Project/" + rallyDataSource.projectOid
                    };
                    rallyDataSource.preferences.createAppPreference(pref, callback, errorCallback);
                } else {
                    pref = {
                        _ref : projectPrefRef,
                        Value:that._getValues()
                    };
                    rallyDataSource.preferences.update(pref, callback, errorCallback);
                }
            };

            that.validateSizes = function() {
                var validationErrors = [], uniqueEstimates = [], uniqueColumns = [];
                rally.forEach(accessors, function(value) {
                    if (dojo.trim(value.get().label) === "") {
                        var columnError = "Please enter a value for all your column names.";
                        if (dojo.indexOf(validationErrors, columnError) === -1) {
                            validationErrors.push(columnError);
                        }
                    }
                    if (dojo.indexOf(uniqueColumns, dojo.trim(value.get().label)) === -1) {
                        uniqueColumns.push(dojo.trim(value.get().label));
                    } else {
                        var uniqueColumnError = "Please enter unique values for all your column names.";
                        if (dojo.indexOf(validationErrors, uniqueColumnError) === -1) {
                            validationErrors.push(uniqueColumnError);
                        }
                    }
                    if (dojo.trim(value.get().planEstimate) === "" || isNaN(value.get().planEstimate) || value.get().planEstimate < 0) {
                        var planEstimateError = "Please enter a positive number for all your plan estimates.";
                        if (dojo.indexOf(validationErrors, planEstimateError) === -1) {
                            validationErrors.push(planEstimateError);
                        }
                    }
                    if (dojo.indexOf(uniqueEstimates, dojo.trim(value.get().planEstimate)) === -1) {
                        uniqueEstimates.push(dojo.trim(value.get().planEstimate));
                    } else {
                        var uniqueEstimateError = "Please enter unique numbers for all your plan estimates.";
                        if (dojo.indexOf(validationErrors, uniqueEstimateError) === -1) {
                            validationErrors.push(uniqueEstimateError);
                        }
                    }
                    if (!isNaN(value.get().planEstimate) && (dojo.trim(value.get().planEstimate) >= 1000 || dojo.trim(value.get().planEstimate).split('.')[1] > 100 )) {
                        var tooManyDigitsError = "Please enter a number with a maximum of 3 digits before and 2 digits after the decimal point.";
                        if (dojo.indexOf(validationErrors, tooManyDigitsError) === -1) {
                            validationErrors.push(tooManyDigitsError);
                        }
                    }
                });
                if (validationErrors.length > 0) {
                    validationDiv.innerHTML = validationErrors.join("<br/>");
                    dojo.removeClass(validationDiv, "rly-hide");
                }
                return validationErrors.length === 0;
            };

            that._addControlToRow = function(row, divId, control, containerCss) {
                var td = document.createElement("td");
                var div = document.createElement("div");
                dojo.addClass(div, containerCss);
                td.appendChild(div);
                div.id = divId;
                if (divId.search(/deleteLink/) === -1) {
                    control.display(div);
                } else {
                    dojo.place(control, div);
                }
                row.appendChild(td);
            };

            that.deleteTableRow = function(fieldName) {
                dojo.byId(fieldName).parentNode.removeChild(dojo.byId(fieldName));  //remove size's form row
                dojo.forEach(accessors, function(value, i) {
                    if (value && fieldName === value.field) {
                        accessors.splice(i, 1); //remove size's object from accessors array
                    }
                });
            };

            that._createTableRow = function(size) {
                var fieldName = size.label ? size.label : "new_" + new Date();
                var row = document.createElement("tr");
                row.id = fieldName;

                var labelTextBox = new rally.sdk.ui.basic.TextBox({rememberValue:false, value:size.label});
                that._addControlToRow(row, fieldName + "-labelTextBox", labelTextBox, "labelTextBoxContainer");

                var isNoPlanEstimateRow = size.planEstimate === 0 || size.planEstimate === "0";
                var planEstimateTextBox = new rally.sdk.ui.basic.TextBox({rememberValue:false, value:size.planEstimate, readOnly: isNoPlanEstimateRow});
                that._addControlToRow(row, fieldName + "-planEstimateTextBox", planEstimateTextBox, "planEstimateTextBoxContainer");

                if (!isNoPlanEstimateRow) {
                    var deleteLink = "<a href='' id='" + fieldName + "DeleteLink'>Delete</a>";
                    that._addControlToRow(row, fieldName + "-deleteLink", deleteLink, "deleteLinkContainer");
                }

                var accessor = {
                    field:fieldName,
                    get: function() {
                        var result = {};
                        result.label = labelTextBox.getValue();
                        result.planEstimate = planEstimateTextBox.getValue();
                        return result;
                    },
                    set:function(object) {
                        labelTextBox.setValue(object.label);
                        planEstimateTextBox.setValue(object.planEstimate);
                    }
                };
                accessors.push(accessor);
                return row;
            };

            that.restrictDialogHeight = function() {
                //restrict size of dialog to prevent scrolling issues when a field has A LOT of attributes
                dojo.query(".dijitDialog").forEach(function(node) {
                    dojo.attr(node, "style", {
                        "max-height": "550px",
                        "overflow": "auto"
                    });
                });
            };

            that.displaySaveCancelFeatures = function() {
                var buttonContainer = dojo.query(".buttonContainer")[0];

                var saveButton = new rally.sdk.ui.basic.Button({text:"Save", value:"Save"});
                saveButton.display(buttonContainer, function() {
                    if (that.validateSizes()) {
                        that._storeValues(that._saveComplete);
                    }
                });

                var cancelLink = "<a href='' id='cancelLink'>Cancel</a>";
                dojo.place(cancelLink, buttonContainer);
                dojo.connect(dojo.byId('cancelLink'), "onclick", function(event) {
                    dojo.addClass(validationDiv, "rly-hide");
                    dialog.hide();
                    dojo.stopEvent(event);
                });

            };

            that.getValidEvents = function() {
                return {onHide:"onHide"};
            };

            that.displayDialog = function() {
                if (dialog) {
                    return;
                }

                dojo.byId("settingsDialogDiv").style.visibility = "visible";

                dialog = new rally.sdk.ui.basic.Dialog({
                    id : new Date().toString(),
                    title: "Configure Settings for Estimation Board",
                    draggable:false,
                    closable:false,
                    content: dojo.byId("settingsDialogDiv")
                });
                dialog.addEventListener("onHide", function() {
                    that.fireEvent(that.getValidEvents().onHide, {});
                });
                dojo.addClass(validationDiv, "rly-hide");
                dialog.display();
                that._alignSettingsDialog();
                that.displaySaveCancelFeatures();

                that.restrictDialogHeight();
            };

            that.connectDeleteLinkHandlers = function() {
                dojo.forEach(deleteLinkConnections, dojo.disconnect);
                dojo.forEach(dojo.query(".deleteLinkContainer"), function(deleteContainer) {
                    deleteLinkConnections.push(
                            dojo.connect(deleteContainer.children[0], "onclick", function(event) {
                                var fieldName = event.target.id.replace("DeleteLink", "");
                                that.deleteTableRow(fieldName);
                                dojo.stopEvent(event);
                            })
                    );
                });
                that.displayDialog();
            };

            that.displayUnits = function() {
                function displayRetrievedUnits(results) {
                    if (results && results.units[0]) {
                        var units = results.units[0].IterationEstimateUnitName;
                        dojo.byId("units").innerHTML = "(" + units + ")";
                    }
                    that.connectDeleteLinkHandlers();
                }

                rallyDataSource.find({
                    key: "units",
                    type: "WorkspaceConfiguration",
                    fetch: "IterationEstimateUnitName"}, displayRetrievedUnits);
            };

            that.displayAddLink = function() {
                dojo.byId("addLinkCell").innerHTML = "<a href='' id='addLink'>Add <img src='/slm/analytics/images/plus-196b89-gr.png'></a>";
                dojo.connect(dojo.byId('addLink'), "onclick", function(event) {
                    if (accessors.length < 12) {
                        var row = that._createTableRow({label:"", planEstimate:""});
                        dojo.byId("settingsTableBody").appendChild(row);
                        that.connectDeleteLinkHandlers();
                    } else {
                        validationDiv.innerHTML = "There is a limit of 12 columns.";
                        dojo.removeClass(validationDiv, "rly-hide");
                    }
                    dojo.stopEvent(event);
                });
                that.displayUnits();
            };

            that._alignSettingsDialog = function() {
                var dialogContainer = dojo.query(".dijitDialog");
                if (dialogContainer.length > 0) {
                    dojo.style(dialogContainer[0], 'top', '10px');
                }
            };

            that._setPreferenceValues = function(values) {
                sizesObject = {};
                rally.forEach(values.fieldInfos, function(size) {
                    sizesObject[size.planEstimate] = {label: size.label, planEstimate: size.planEstimate};
                });
            };

            that._setDefaultValues = function() {
                sizesObject = {};
                rally.forEach(sizes, function(sizeValue, sizeKey) {
                    sizesObject[sizeKey] = {label: sizeValue, planEstimate: sizeKey};
                });
            };

            that._retrievePreferences = function(/*function*/callback) {
                var projectPref;
                if (prefs && prefs.length) {
                    dojo.forEach(prefs, function(p) {
                        if (p.Project) {
                            //projectOid is a string need both strings to compare.
                            var projectRef = rally.sdk.util.Ref.getOidFromRef(p.Project) + "";
                            if (projectRef === rallyDataSource.projectOid) {
                                projectPref = p;
                                projectPrefRef = projectPref._ref;
                            }
                        }
                    });
                    if (projectPref) {
                        that._setPreferenceValues(projectPref.Value);
                        callback({projectName:projectPref.Project._refObjectName});
                    }
                } else {
                    that._setDefaultValues();
                    callback({});
                }
            };

            that._numericSort = function(o1, o2) {
                var key1 = parseFloat(o1.planEstimate);
                var key2 = parseFloat(o2.planEstimate);

                if (key1 === key2) {
                    return 0;
                }

                return key1 < key2 ? -1 : 1;
            };

            that.display = function() {
                function createForm() {
                    accessors = [];
                    var rowArr = [];

                    //to ensure correct order, we push objects into an array and then apply a custom numeric sort
                    rally.forEach(sizesObject, function(size1) {
                        rowArr.push(size1);
                    });
                    rowArr = rowArr.sort(that._numericSort);

                    rally.forEach(rowArr, function(size2) {
                        var row = that._createTableRow(size2);
                        dojo.byId("settingsTableBody").appendChild(row);
                    });

                    that.displayAddLink();
                }

                that._retrievePreferences(createForm);
            };

        };

    </script>

    <style type="text/css">
    /*board styles*/
        .appHeaderContainer {
            margin-top: 0;
            margin-bottom: 0;
        }

        .appHeader {
            position: relative;
        }

        .controlContainer {
            margin-top: 10px;
            margin-right: 20px;
            float: right;
        }

        .board {
            clear: both;
        }

        /*settings dialog styles */
        a img {
            border: 0;
        }

        .buttonContainer span,
        .buttonContainer a {
            vertical-align: middle;
        }

        .dijitTooltipContents {
            font-size: 9.5px;
        }

        .labelTextBoxContainer .dijitTextBox {
            width: 110px;
        }

        .planEstimateTextBoxContainer .dijitTextBox {
            width: 50px;
        }

        .rly-hide {
            display: none;
        }

        .tableHeaderRow {
            font-weight: bold;
            text-align: left;
        }

        #addLinkCell img {
            vertical-align: bottom;
        }

        #columnNameTd {
            width: 80px;
        }

        #planEstimateTd {
            width: 55px;
        }

        #settingsDialogDiv {
            visibility: hidden;
        }

        #settingsTable {
            clear: right;
            margin: 10px 25px 10px 25px;
        }

        #units {
            font-weight: normal;
        }

    </style>

    <script type="text/javascript">

        var projectOid = '__PROJECT_OID__';
        projectOid = projectOid.indexOf("__") !== -1 ? "723030" : projectOid;
        var workspaceOid = '__WORKSPACE_OID__';
        workspaceOid = workspaceOid.indexOf("__") !== -1 ? "722746" : workspaceOid;
        var estimationBoard;

        function onLoad() {
            var rallyDataSource = new rally.sdk.data.RallyDataSource(
                    workspaceOid,
                    projectOid,
                    '__PROJECT_SCOPING_UP__',
                    '__PROJECT_SCOPING_DOWN__');
            rallyDataSource.projectOid = projectOid;

            var settings, sizes, prefs;

            //get pref settings exist, use them otherwise use default settings
            function processPref(results) {
                if (results.length) {
                    prefs = results;
                    sizes = {};
                    rally.forEach(results[0].Value.fieldInfos, function(value) {
                        sizes[value.planEstimate] = value.label;
                    });
                } else {
                    sizes = {0:"Not Estimated",
                        1: "Very Small",
                        2: "Small",
                        3: "Medium",
                        5: "Big",
                        8: "Very Big",
                        13: "Huge"};
                }
                createBoard(sizes);
            }

            rallyDataSource.preferences.getAppPreferences(processPref);

            function settingsShow() {
                if (!settings) {
                    settings = new EstimationBoardSettings(rallyDataSource, sizes, prefs);
                    settings.display();
                } else {
                    settings.show();
                }
            }

            rally.sdk.ui.AppHeader.addPageTool({
                key:"showSettings",
                label: "Settings...",
                onClick: settingsShow
            });

            function createBoard(sizes) {
                estimationBoard = new EstimationBoard(rallyDataSource, settingsShow, sizes);
                estimationBoard.display(dojo.body());
            }
        }

        function onDashboardPageTimeboxFilterChanged() {
            estimationBoard.refresh();
        }

        rally.addOnLoad(onLoad);

    </script>
</head>
<body>
<div style="display:none">
    <div id="settingsDialogDiv">
        <div id="validationErrors" class="appMessage error"></div>
        <table id="settingsTable" cellspacing="7">
            <tr class="tableHeaderRow">
                <td id="columnNameTd">Column Name</td>
                <td id="planEstimateTd">Plan Estimate <span id="units"></span></td>
            </tr>
            <tbody id="settingsTableBody"></tbody>
            <tr>
                <td id="addLinkCell"></td>
            </tr>
        </table>
    </div>
</div>
<div id="easter"></div>
</body>
<script type="text/javascript">
var willboTracker = { };
willboTracker['$className'] = 'willboTracker';
/*
 * Konami-JS ~
 * :: Now with support for touch events and multiple instances for
 * :: those situations that call for multiple easter eggs!
 * Code: http://konami-js.googlecode.com/
 * Examples: http://www.snaptortoise.com/konami-js
 * Copyright (c) 2009 George Mandis (georgemandis.com, snaptortoise.com)
 * Version: 1.4.2 (9/2/2013)
 * Licensed under the MIT License (http://opensource.org/licenses/MIT)
 * Tested in: Safari 4+, Google Chrome 4+, Firefox 3+, IE7+, Mobile Safari 2.2.1 and Dolphin Browser
 */
var Konami=function(a){var b={addEvent:function(a,b,c,d){a.addEventListener?a.addEventListener(b,c,!1):a.attachEvent&&(a["e"+b+c]=c,a[b+c]=function(){a["e"+b+c](window.event,d)},a.attachEvent("on"+b,a[b+c]))},input:"",pattern:"38384040373937396665",load:function(a){this.addEvent(document,"keydown",function(c,d){return d&&(b=d),b.input+=c?c.keyCode:event.keyCode,b.input.length>b.pattern.length&&(b.input=b.input.substr(b.input.length-b.pattern.length)),b.input==b.pattern?(b.code(a),b.input="",c.preventDefault(),!1):void 0},this),this.iphone.load(a)},code:function(a){window.location=a},iphone:{start_x:0,start_y:0,stop_x:0,stop_y:0,tap:!1,capture:!1,orig_keys:"",keys:["UP","UP","DOWN","DOWN","LEFT","RIGHT","LEFT","RIGHT","TAP","TAP"],code:function(a){b.code(a)},load:function(a){this.orig_keys=this.keys,b.addEvent(document,"touchmove",function(a){if(1==a.touches.length&&1==b.iphone.capture){var c=a.touches[0];b.iphone.stop_x=c.pageX,b.iphone.stop_y=c.pageY,b.iphone.tap=!1,b.iphone.capture=!1,b.iphone.check_direction()}}),b.addEvent(document,"touchend",function(){1==b.iphone.tap&&b.iphone.check_direction(a)},!1),b.addEvent(document,"touchstart",function(a){b.iphone.start_x=a.changedTouches[0].pageX,b.iphone.start_y=a.changedTouches[0].pageY,b.iphone.tap=!0,b.iphone.capture=!0})},check_direction:function(a){x_magnitude=Math.abs(this.start_x-this.stop_x),y_magnitude=Math.abs(this.start_y-this.stop_y),x=this.start_x-this.stop_x<0?"RIGHT":"LEFT",y=this.start_y-this.stop_y<0?"DOWN":"UP",result=x_magnitude>y_magnitude?x:y,result=1==this.tap?"TAP":result,result==this.keys[0]&&(this.keys=this.keys.slice(1,this.keys.length)),0==this.keys.length&&(this.keys=this.orig_keys,this.code(a))}}};return"string"==typeof a&&b.load(a),"function"==typeof a&&(b.code=a,b.load()),b};

new Konami(function() {

    if (window.top.location.hash.indexOf('dashboard') < 0 || navigator.userAgent.indexOf('Chrome') < 0){
        return;
    } else {
        var messageBus = window.top.Rally.environment.getMessageBus();
        messageBus.publish.apply(messageBus, ['rally.clientmetrics.message.action', {description: 'Hungry Willbo launched', component: willboTracker}]);
        messageBus.publish.apply(messageBus, ['rally.clientmetrics.message.loadbegin', {description: 'Hungry Willbo played', component: willboTracker}]);
        console.log("If you are interested in learning more on altering Rally Apps for your own purpose feel free to click this link");
        console.log("http://www.rallydev.com/community/developer/how-customize-rally-new-app");
        document.getElementById('cardBoard').style.display = 'none';
        document.getElementById('easter').innerHTML = "<button onClick='killEasterEgg()'>Quit</button><br /><iframe width='100%' height='800px' src='/slm/js-lib/app-catalog/build/html/legacy/HungryWillboApp.html'></iframe>";
        document.getElementsByTagName('iframe')[0].focus();
    }
});
var killEasterEgg = function(){
    //get high score off of child window
    var highestScore = '0 - (0 steps)';
    if (window.frames[0].window.highScore && window.frames[0].window.highSteps) {
        highestScore = window.frames[0].window.highScore + '-(' + window.frames[0].window.highSteps + ' steps)';
    }
    var messageBus = window.top.Rally.environment.getMessageBus();
    messageBus.publish.apply(messageBus, ['rally.clientmetrics.message.loadend', {description: 'Hungry Willbo played', component: willboTracker, willboHighScore: highestScore}]);
    document.getElementById('cardBoard').style.display = 'block';
    document.getElementById('easter').innerHTML = '';
}
</script>
</html>