App.html

<!DOCTYPE html>
<html>

<head>
    <title>Revisions by User</title>

    <script type="text/javascript" src="/apps/2.1/sdk.js"></script>

    <script type="text/javascript">

        Rally.onReady(function () {
            Ext.define('CustomApp', {
                extend: 'Rally.app.App',
                componentCls: 'app',
                _subscriptions: [],
                _subscriptionRevHistory: null,
                _revisions: null,
                items: [
                    { xtype: 'container', itemId: 'selector_box' },
                    { xtype: 'container', itemId: 'display_box' }
                ],

                getSelectorBox: function () {
                    return this.down('#selector_box');
                },
                getDisplayBox: function () {
                    return this.down('#display_box');
                },
                getStartDate: function () {
                    return this.down('#startDate').getValue();
                },
                getEndDate: function () {
                    if (this.down('#endDate').getValue()) {
                        //add a day since the datepicker gives us the new day at midnight.
                        return Rally.util.DateTime.add(this.down('#endDate').getValue(), 'day', 1);
                    }
                    return null;
                },

                getUpdateButton: function () {
                    return this.down('#updateButton');
                },

                addPickers: function() {
                    this.getSelectorBox().removeAll();
                    var defaultToDate = new Date();
                    defaultToDate.setDate(defaultToDate.getDate() - 7);

                    this.getSelectorBox().add({
                        xtype: 'container',
                        layout: 'hbox',
                        margin: '10 0 0 0',
                        items: [{
                            xtype: 'rallydatefield',
                            itemId: 'startDate',
                            value:  defaultToDate,
                            fieldLabel: 'Date from',
                            labelAlign: 'right',
                            labelWidth: 100,
                            width: 275,
                            labelSeparator: ''

                        }, {
                            xtype: 'rallydatefield',
                            itemId: 'endDate',
                            value: new Date(),
                            fieldLabel: 'to',
                            labelAlign: 'right',
                            labelWidth: 25,
                            width: 225,
                            labelSeparator: ''
                        }, {
                            xtype: 'rallybutton',
                            itemId: 'updateButton',
                            text: 'Get Revisions',
                            margin: '0 10 0 10',
                            listeners: {
                                click: this.updateView,
                                scope: this
                            }
                        }, {
                            xtype: 'rallybutton',
                            itemId: 'exportButton',
                            text: 'Export',
                            margin: '0 10 0 0',
                            listeners: {
                                click: this.exportCSV,
                                scope: this
                            }
                        }, {
                            xtype: 'component',
                            html: 'Select dates. Click "Get Revisions". Click again if no data.',
                            style: {
                                display: 'inline-block',
                                backgroundColor: 'lemonchiffon',
                                fontSize: '150%'
                            }
                        }]
                    });
                },

                updateView: function() {
                    this.getDisplayBox().removeAll();
                    if (this._subscriptionRevHistory)
                        this.loadRevisions();
                    else {
                        Rally.ui.notify.Notifier.showError({
                            message: "Couldn't get revision history model. Please refresh the page to try again."
                        });
                    }
                },

                getRevisionsByDate: function () {
                    var promises = [];
                    var revisions = this._subscriptionRevHistory.get('Revisions');
                    var startDateString = this.getStartDate().toISOString();
                    var endDateString = this.getEndDate().toISOString();
                    revisions.store = this._subscriptionRevHistory.getCollection('Revisions', {
                        fetch: ['User', 'Description', 'CreationDate', 'RevisionNumber'],
                        filters: [{
                            property: 'CreationDate',
                            operator: '>=',
                            value: startDateString
                            }, {
                            property: 'CreationDate',
                            operator: '<=',
                            value: endDateString
                        }]
                    });
                    promises.push(revisions.store.load());
                    return Deft.Promise.all(promises);
                },

                loadRevisions: function() {
                    var that = this;
                    this.setLoading(true);

                    this.getRevisionsByDate().then({
                        success: function (results) {
                            that._revisions = results[0];
                            that._makeGrid(results);
                        },
                        failure: function () {
                            console.log("oh noes!");
                            Rally.ui.notify.Notifier.showError({
                                message: "Revisions request timed out. Please click Get Revisions again."
                            });
                        }
                    }).always(function(){this.setLoading(false);}, this);
                },

                exportCSV: function() {
                    var clean = function (val) {
                        var quotedString;
                        if (val) {
                            quotedString = '"' + val.toString().replace(",", ";") + '"';
                        } else {
                            quotedString = '""';
                        }
                        return quotedString;
                    };
                    var csvFile = '"User", "Revision Number", "Date", "Description"\n';
                    var filename = 'revisions.csv';
                    for (var i = 0; i < this._revisions.length; i++) {
                        csvFile += clean(this._revisions[i].data.User._refObjectName) + ",";
                        csvFile += clean(this._revisions[i].data.RevisionNumber) + ",";
                        csvFile += clean(this._revisions[i].data.CreationDate.toDateString()) + ",";
                        csvFile += clean(this._revisions[i].data.Description) + "\n";
                    }
                    var blob = new Blob([csvFile], { type: 'text/csv;charset=utf-8;' });
                    if (navigator.msSaveBlob) { // IE 10+
                        navigator.msSaveBlob(blob, filename);
                    } else {
                        var link = document.createElement("a");
                        if (link.download !== undefined) { // feature detection
                            // Browsers that support HTML5 download attribute
                            var url = URL.createObjectURL(blob);
                            link.setAttribute("href", url);
                            link.setAttribute("download", filename);
                            link.style.visibility = 'hidden';
                            document.body.appendChild(link);
                            link.click();
                            document.body.removeChild(link);
                        }
                    }
                },

                launch: function () {
                    var that = this;
                    var subStore = Ext.create('Rally.data.wsapi.Store', {
                        model: 'Subscription',
                        fetch: ['ObjectID', 'RevisionHistory', 'Revisions', 'Description', 'User'],
                        autoLoad: true
                    });

                    this.addPickers();
                    this.setLoading(true);
                    this.getUpdateButton().setDisabled(true);

                    subStore.load().then({
                        success: this._getRevHistoryModel,
                        failure: function() {
                            Rally.ui.notify.Notifier.showError({
                                message: "Couldn't get revision history model. Please refresh the page."
                            });
                        },
                        scope: this
                    }).then({
                        success: this._onRevHistoryModelCreated,
                        failure: function() {
                            Rally.ui.notify.Notifier.showError({
                                message: "Couldn't get revision history. Please refresh the page."
                            });
                        },
                        scope: this
                    }).then({
                        success: this._onRevHistoryModelLoaded,
                        scope: this
                    }).always(function(){
                        this.setLoading(false);
                        this.getUpdateButton().setDisabled(false);
                    }, this);;
                },

                _getRevHistoryModel: function (subs) {
                    this._subscriptions = subs;
                    return Rally.data.ModelFactory.getModel({
                        type: 'RevisionHistory'
                    });
                },

                _onRevHistoryModelCreated: function (model) {
                    var promises = [];
                    var subscription = this._subscriptions[0];
                    var ref = subscription.get('RevisionHistory')._ref;
                    promises.push(model.load(Rally.util.Ref.getOidFromRef(ref)));
                    return Deft.Promise.all(promises);
                },

                _onRevHistoryModelLoaded: function (histories) {
                    this._subscriptionRevHistory = histories[0];
                },

                _makeGrid: function (revs) {
                    this.getDisplayBox().removeAll();
                    this.getDisplayBox().add({
                        xtype: 'rallygrid',
                        showPagingToolbar: true,
                        showRowActionsColumn: false,
                        editable: false,
                        store: Ext.create('Rally.data.custom.Store', {
                            data: revs[0]
                        }),
                        columnCfgs: [{
                            text: 'User',
                            dataIndex: 'User',
                            renderer: function (value) {
                                return value._refObjectName;
                            }
                        },
                        {
                            text: 'Revision number',
                            dataIndex: 'RevisionNumber',
                            renderer: function (value) {
                                return value
                            }
                        },
                        {
                            text: 'Date',
                            dataIndex: 'CreationDate',
                            renderer: function (value) {
                                return value.toDateString();
                            }
                        },
                        {
                            text: 'Description',
                            dataIndex: 'Description',
                            flex: 1,
                            renderer: function (value) {
                                return value
                            }
                        }
                        ]
                    });

                }

            });

            Rally.launchApp('CustomApp', {
                name: "App: Subscription Revisions by Date Range",
                parentRepos: ""
            });

        });
    </script>
</head>

<body></body>

</html>