rearview 1.0.0-jruby

data/public/rearview-src/js/model/dashboard.js

@@ -0,0 +1,47 @@
+define(
+[
+    'model/base'
+],
+function(
+    Base
+){
+    /**
+     * DashboardModel
+     *
+     * Generic model that represents a dashboard in rearview.
+     **/
+    var DashboardModel = Base.extend({
+        initialize : function(options) {
+            this.category    = ( options ) ? options.category : false;
+            this.dashboardId = ( options ) ? options.dashboardId : null;
+        },
+        url : function() {
+            if ( this.category ) {
+                return ( this.dashboardId ) ? '/dashboards/' + this.dashboardId + '/children.json' : '/dashboards.json';
+            } else {
+                return ( this.get('id') ) ? '/dashboards/' + this.get('id') : '/dashboards.json';
+            }
+        },
+        parse : function(response, options) {
+            response.createdAt = ( response.createdAt ) 
+                               ? this.formatServerDateTime(response.createdAt)
+                               : response.createdAt;
+            
+            response.modifiedAt = ( response.modifiedAt ) 
+                                ? this.formatServerDateTime(response.modifiedAt) 
+                                : response.modifiedAt;
+            return response;
+        },
+        defaults : {
+            'id'         : null,
+            'userId'     : null,
+            'name'       : 'Default',
+            'createdAt'  : null,
+            'modifiedAt' : null,
+            'description': null,
+            'children'   : []
+        }
+    });
+
+    return DashboardModel;
+});

data/public/rearview-src/js/model/monitor.js

@@ -0,0 +1,67 @@
+define(
+[
+    'model/base'
+],
+function(
+    Base
+){
+
+    /**
+     * JobModel
+     *
+     * Generic model that represents a job (monitor) in rearview.
+     **/
+
+    // Example pay load to the rearview API
+    // {
+    //     "id"            : 1,
+    //     "dashboardId"   : 1,
+    //     "userId"        : 1,
+    //     "name"          : "test",
+    //     "jobType"       : "monitor",
+    //     "alertKeys"     : [""],
+    //     "cronExpr"      : "0 * * * * ?",
+    //     "errorTimeout"  : 60,
+    //     "minutes"       : 1,
+    //     "metrics"       : ["stats_counts.cupcake.subscription.create.queued"],
+    //     "monitorExpr"   : "puts @a\nwith_metrics do |a|\n graph_value['queued', a]\nend\n\n",
+    //     "active"        : true,
+    //     "id"            : 1,
+    //     "version"       : 1
+    // }
+    var MonitorModel = Base.extend({
+        url : function() {
+            return ( this.get('id') ) ? '/jobs/' + this.get('id') : '/jobs.json';
+        },
+        parse : function(response, options) {
+            response.createdAt = ( response.createdAt ) 
+                               ? this.formatServerDateTime(response.createdAt)
+                               : response.createdAt;
+            
+            response.modifiedAt = ( response.modifiedAt ) 
+                                ? this.formatServerDateTime(response.modifiedAt) 
+                                : response.modifiedAt;
+            return response;
+        },
+        defaults : {
+            'id'            : null,
+            'dashboardId'   : 1,         // foreign key to dashboard, temp global app = 1
+            'userId'        : null,      // foreign key to user creator
+            'name'          : '',
+            'active'        : true,
+            'jobType'       : 'monitor', // hard coded for now
+            'version'       : 2,
+            'alertKeys'     : [],
+            'cronExpr'      : '',        // "0 * * * * ?"
+            'errorTimeout'  : 60,        // hard coded for now, NOTE : not in design yet
+            'minutes'       : 1,
+            'metrics'       : [],
+            'monitorExpr'   : '',
+            'toDate'        : null,
+            'createdAt'     : null,
+            'modifiedAt'    : null
+        }
+    });
+
+    return MonitorModel;
+});

data/public/rearview-src/js/model/user.js

@@ -0,0 +1,81 @@
+define(
+[
+    'model/base',
+    'backbone-mediator'
+],
+function(
+    Base
+){
+
+    /**
+     * UserModel
+     *
+     * Generic model that represents a user in rearview.
+     **/
+    var UserModel = Base.extend({
+        
+        url : '/user.json',
+
+        defaults : {
+            id          : null,
+            email       : '',
+            firstName   : '',
+            lastName    : '',
+            lastLogin   : null,
+            createdAt   : null,
+            modifiedAt  : null,
+            preferences : {}
+        },
+
+        parse : function(response, options) {
+            if ( response.createdAt ) {
+                response.createdAt = this.formatServerDateTime(response.createdAt);
+            }
+            if ( response.modifiedAt ) {
+                response.modifiedAt = this.formatServerDateTime(response.modifiedAt);
+            }
+            if ( !response.preferences ) {
+                response.preferences = {};
+
+                if ( !response.preferences.dashboards ) {
+                    response.preferences.dashboards = [];
+                }
+            }
+            
+            return response;
+        },
+        /* a temporary method for converting over
+           application -> dashboard terminology switch */
+        convertApplicationPrefs : function() {
+            var preferences = this.get('preferences');
+
+            if ( preferences.applications ) {
+                preferences.dashboards = preferences.applications;
+                this.set('preferences', preferences);
+                delete preferences.applications;
+                this.save();
+            }
+        },
+
+        updatePrefs : function(preferences) {
+            var existingPreferences = this.get('preferences');
+            this.set('preferences', _.extend(existingPreferences, preferences));
+            this.save();
+        },
+
+        // On fetch success, publish event that user model is set.
+        initialize : function() {
+            _.bindAll(this);
+
+            this.fetch({
+                async   : false,
+                success : function() {
+                    this.convertApplicationPrefs();
+                    Backbone.Mediator.pub('model:user:init', this);
+                }.bind(this)
+            });
+        }
+    });
+
+    return UserModel;
+});

data/public/rearview-src/js/route/index.js

@@ -0,0 +1,47 @@
+define([
+    'backbone',
+    'backbone-mediator'
+],
+function(
+    Backbone
+){
+
+    var IndexRouter = Backbone.Router.extend({
+
+        initialize : function(options) {
+            this.app = options.app;
+        },
+
+        routes : {
+            ''                       : 'ecosystem',
+            'ecosystem'              : 'ecosystem',
+            'dash/:id'               : 'dashboard', // dashboard id
+            'dash/:id/expand/:mid'   : 'dashboard', // dashboard id & monitor id
+            'dash/:id/category/:cid' : 'category'  // dashboard id & child dashboard id
+        },
+
+        category : function(id, cid) {
+            // make sure we capture an integer value
+            id  = ( id ) ? parseInt(id) : id;
+            cid = ( cid ) ? parseInt(cid) : cid;
+
+            if (id) this.app.category(id, cid);
+        },
+
+        dashboard : function(id, mid) {
+            // make sure we capture an integer value
+            id  = ( id ) ? parseInt(id) : id;
+            mid = ( mid ) ? parseInt(mid) : mid;
+
+            if (id) this.app.dashboard(id, mid);
+        },
+
+        ecosystem : function() {
+            this.navigate('ecosystem', { replace : true });
+
+            this.app.ecosystem();
+        }
+    });
+
+    return IndexRouter;
+});

data/public/rearview-src/js/util/highcharts-gray-theme.js

@@ -0,0 +1,266 @@
+/**
+ * Gray theme for Highcharts JS
+ * @author Torstein Hønsi
+ * @amd author Ian Quattlebaum
+ */
+define(['jquery', 'highcharts'], function (jQuery, Highcharts) {
+	Highcharts.theme = {
+		colors: ["#DDDF0D", "#7798BF", "#55BF3B", "#DF5353", "#aaeeee", "#ff0066", "#eeaaee",
+			"#55BF3B", "#DF5353", "#7798BF", "#aaeeee"],
+		chart: {
+			backgroundColor: {
+				linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+				stops: [
+					[0, 'rgb(96, 96, 96)'],
+					[1, 'rgb(16, 16, 16)']
+				]
+			},
+			borderWidth: 0,
+			borderRadius: 15,
+			plotBackgroundColor: null,
+			plotShadow: false,
+			plotBorderWidth: 0
+		},
+		title: {
+			style: {
+				color: '#FFF',
+				font: '16px Lucida Grande, Lucida Sans Unicode, Verdana, Arial, Helvetica, sans-serif'
+			}
+		},
+		subtitle: {
+			style: {
+				color: '#DDD',
+				font: '12px Lucida Grande, Lucida Sans Unicode, Verdana, Arial, Helvetica, sans-serif'
+			}
+		},
+		xAxis: {
+			gridLineWidth: 0,
+			lineColor: '#999',
+			tickColor: '#999',
+			labels: {
+				style: {
+					color: '#999',
+					fontWeight: 'bold'
+				}
+			},
+			title: {
+				style: {
+					color: '#AAA',
+					font: 'bold 12px Lucida Grande, Lucida Sans Unicode, Verdana, Arial, Helvetica, sans-serif'
+				}
+			}
+		},
+		yAxis: {
+			alternateGridColor: null,
+			minorTickInterval: null,
+			gridLineColor: 'rgba(255, 255, 255, .1)',
+			lineWidth: 0,
+			tickWidth: 0,
+			labels: {
+				style: {
+					color: '#999',
+					fontWeight: 'bold'
+				}
+			},
+			title: {
+				style: {
+					color: '#AAA',
+					font: 'bold 12px Lucida Grande, Lucida Sans Unicode, Verdana, Arial, Helvetica, sans-serif'
+				}
+			}
+		},
+		legend: {
+			itemStyle: {
+				color: '#CCC'
+			},
+			itemHoverStyle: {
+				color: '#FFF'
+			},
+			itemHiddenStyle: {
+				color: '#333'
+			}
+		},
+		labels: {
+			style: {
+				color: '#CCC'
+			}
+		},
+		tooltip: {
+			backgroundColor: {
+				linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+				stops: [
+					[0, 'rgba(96, 96, 96, .8)'],
+					[1, 'rgba(16, 16, 16, .8)']
+				]
+			},
+			borderWidth: 0,
+			style: {
+				color: '#FFF'
+			}
+		},
+
+
+		plotOptions: {
+			line: {
+				dataLabels: {
+					color: '#CCC'
+				},
+				marker: {
+					lineColor: '#333'
+				}
+			},
+			spline: {
+				marker: {
+					lineColor: '#333'
+				}
+			},
+			scatter: {
+				marker: {
+					lineColor: '#333'
+				}
+			},
+			candlestick: {
+				lineColor: 'white'
+			}
+		},
+
+		toolbar: {
+			itemStyle: {
+				color: '#CCC'
+			}
+		},
+
+		navigation: {
+			buttonOptions: {
+				backgroundColor: {
+					linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+					stops: [
+						[0.4, '#606060'],
+						[0.6, '#333333']
+					]
+				},
+				borderColor: '#000000',
+				symbolStroke: '#C0C0C0',
+				hoverSymbolStroke: '#FFFFFF'
+			}
+		},
+
+		exporting: {
+			buttons: {
+				exportButton: {
+					symbolFill: '#55BE3B'
+				},
+				printButton: {
+					symbolFill: '#7797BE'
+				}
+			}
+		},
+
+		// scroll charts
+		rangeSelector: {
+			buttonTheme: {
+				fill: {
+					linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+					stops: [
+						[0.4, '#888'],
+						[0.6, '#555']
+					]
+				},
+				stroke: '#000000',
+				style: {
+					color: '#CCC',
+					fontWeight: 'bold'
+				},
+				states: {
+					hover: {
+						fill: {
+							linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+							stops: [
+								[0.4, '#BBB'],
+								[0.6, '#888']
+							]
+						},
+						stroke: '#000000',
+						style: {
+							color: 'white'
+						}
+					},
+					select: {
+						fill: {
+							linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+							stops: [
+								[0.1, '#000'],
+								[0.3, '#333']
+							]
+						},
+						stroke: '#000000',
+						style: {
+							color: 'yellow'
+						}
+					}
+				}
+			},
+			inputStyle: {
+				backgroundColor: '#333',
+				color: 'silver'
+			},
+			labelStyle: {
+				color: 'silver'
+			}
+		},
+
+		navigator: {
+			handles: {
+				backgroundColor: '#666',
+				borderColor: '#AAA'
+			},
+			outlineColor: '#CCC',
+			maskFill: 'rgba(16, 16, 16, 0.5)',
+			series: {
+				color: '#7798BF',
+				lineColor: '#A6C7ED'
+			}
+		},
+
+		scrollbar: {
+			barBackgroundColor: {
+					linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+					stops: [
+						[0.4, '#888'],
+						[0.6, '#555']
+					]
+				},
+			barBorderColor: '#CCC',
+			buttonArrowColor: '#CCC',
+			buttonBackgroundColor: {
+					linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+					stops: [
+						[0.4, '#888'],
+						[0.6, '#555']
+					]
+				},
+			buttonBorderColor: '#CCC',
+			rifleColor: '#FFF',
+			trackBackgroundColor: {
+				linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+				stops: [
+					[0, '#000'],
+					[1, '#333']
+				]
+			},
+			trackBorderColor: '#666'
+		},
+
+		// special colors for some of the demo examples
+		legendBackgroundColor: 'rgba(48, 48, 48, 0.8)',
+		legendBackgroundColorSolid: 'rgb(70, 70, 70)',
+		dataLabelsColor: '#444',
+		textColor: '#E0E0E0',
+		maskColor: 'rgba(255,255,255,0.3)'
+	};
+
+	// Apply the theme
+	Highcharts.setOptions(Highcharts.theme);
+
+	return Highcharts.theme;
+});

data/public/rearview-src/js/util/templar.js

@@ -0,0 +1,178 @@
+(function(factory){
+    if (typeof define === 'function' && define.amd) {
+        define(['underscore', 'backbone', 'backbone-localStorage'], factory);
+    } else {
+        factory(_, Backbone);
+    }
+})(function (_, Backbone){
+    var config = {
+        url     : 'public/templates/', // template path
+        ext     : '.hbs',              // template file extension
+        version : '0.0.1',             // version number
+        cache   : true,                // turn local storage caching on/off
+        storage : new Backbone.LocalStorage('Templar') // default local storage plugin
+    };
+
+    Backbone.Templar = function( templatePaths, options ) {
+        // if no options are passed
+        var options           = ( typeof options === 'undefined' ) ? {} : options,
+            templateExtension = ( options.ext ) ? options.ext : config.ext,
+            baseUrlPath       = ( options.url ) ? options.url : config.url,
+            version           = ( options.version ) ? options.version : config.version,
+            cache             = ( typeof options.cache !== 'undefined' ) ? options.cache : config.cache,
+            storage           = ( options.storage ) ? options.storage : config.storage;
+
+        // -- public methods
+        this.render = function( options ) {
+            // set up defaults
+            if ( !options.path ) throw new Error('A template path is required.');
+            options.el = ( options.el ) ? options.el : document.body;
+            TemplarCollection._render( options );
+        }
+
+        this.add = function() {
+            // set up defaults
+            if ( !options.path ) throw new Error('A template path is required.');
+            TemplarCollection._add( options );
+        }
+
+        var TemplarCollection = new(Backbone.Collection.extend({
+
+            initialize : function() {
+                this._loadTemplates();
+            },
+
+            templates : templatePaths,
+
+            model : Backbone.Model.extend({
+                // Note: template file extension is an attribute set in config defaulting to .hbs
+                defaults : function() {
+                    return {
+                        path    : null,    
+                        content : null,     // the stringified content of the template
+                        version : version
+                    };
+                },
+
+                url : function() {
+                    var path = ( ( this.get('path') && ( this.get('path') !== 'undefined' ) )
+                             ? this.get('path')
+                             : '' );
+
+                    return baseUrlPath + path + templateExtension;
+                },
+
+                parse : function(response) {
+                    return {
+                        content : response
+                    };
+                }
+            }),
+
+            localStorage : storage,
+
+            // -- private methods
+            _loadTemplates : function() {
+                var self = this;
+                var templates = this.localStorage.findAll();
+                
+                // check for version change
+                if ( templates.length > 0 && templates[0].version !== version ) {
+                    cache = false; // destroy cached versions and reload new version of templates
+                }
+
+                if ( cache ) {
+                    for (var i = 0; i < templates.length; i++) {
+                        this.add(templates[i]);
+                    }
+                } else {
+                    // if our cache setting is turned off, never remember our templates
+                    // basically a dev mode flag for debugging templates
+                    _.each(templates, function(model) {
+                        self.localStorage.destroy(model);
+                    });
+                }
+
+                if ( this.templates ) {
+                    for (var i = 0; i < this.templates.length; i++) {
+                        this._add({
+                            path : this.templates[i]
+                        });
+                    }
+                }
+            },
+
+            _createModel : function(pathString) {
+                var templateModel = new this.model({
+                    path : pathString
+                });
+
+                return templateModel;
+            },
+
+            _add : function(options, cb) {
+                var templateCheck = this.where({ path : options.path });
+                
+                //if there is already an existing stored template
+                if( templateCheck.length == 0 ) {
+                    // grab the template from the file system
+                    templateModel = this._createModel(options.path);
+
+                    $.ajax({
+                        url      : baseUrlPath + options.path + templateExtension,
+                        async    : false,
+                        success  : function(response) {
+                            templateModel.set({
+                                'content' : response,
+                                'path'    : options.path
+                            });
+                        }
+                    });
+
+                    // store template model in localStorage
+                    this.add( templateModel );
+                    this.create( templateModel.toJSON() );
+                    
+                    if( typeof cb === 'function' ) {
+                        cb();
+                    }
+                }
+            },
+
+            _compile : function(content, el, append, data, cb) {
+                var append  = ( append ) ? append : false,
+                    compile = Handlebars.compile(content);
+
+                if (append) {
+                    el.append(compile(data));
+                } else {
+                    el.html(compile(data));
+                }
+                // run a callback if provided through options.cb
+                if( typeof cb === 'function' ) {
+                    cb();
+                }
+            },
+
+            _render : function( options ) {
+                var self = this;
+                var templateCheck = this.where({ 
+                                        'path'    : options.path,
+                                        'version' : version
+                                    });
+
+                //if there is already an existing stored template
+                if( templateCheck.length > 0 ) {
+                    this._compile(templateCheck[0].get('content'), options.el, options.append, options.data, options.cb);
+
+                } else {
+                    this._add(options, _.bind(function() { 
+                        self._compile( templateModel.get('content'), options.el, options.append, options.data, options.cb )
+                    }, this));
+                }
+             }
+        }));  
+    }  
+
+    return Backbone.Templar;
+});