diff --git a/manage.py b/manage.py
index 1e484c9451..66a67babd4 100755
--- a/manage.py
+++ b/manage.py
@@ -43,12 +43,15 @@ def make_shell_context():
 @manager.command
 def check_settings():
     """Show the settings as re:dash sees them (useful for debugging)."""
-    from types import ModuleType
+    for name, item in settings.all_settings().iteritems():
+        print "{} = {}".format(name, item)
 
-    for name in dir(settings):
-        item = getattr(settings, name)
-        if not callable(item) and not name.startswith("__") and not isinstance(item, ModuleType):
-            print "{} = {}".format(name, item)
+@manager.command
+def send_test_mail():
+    from redash import mail
+    from flask_mail import Message
+
+    mail.send(Message(subject="Test Message from re:dash", recipients=[settings.MAIL_DEFAULT_SENDER], body="Test message."))
 
 
 if __name__ == '__main__':
diff --git a/migrations/0010_create_alerts.py b/migrations/0010_create_alerts.py
new file mode 100644
index 0000000000..111c1256d9
--- /dev/null
+++ b/migrations/0010_create_alerts.py
@@ -0,0 +1,8 @@
+from redash.models import db, Alert, AlertSubscription
+
+if __name__ == '__main__':
+    with db.database.transaction():
+       Alert.create_table()
+       AlertSubscription.create_table()
+
+    db.close_db(None)
diff --git a/rd_ui/.jshintrc b/rd_ui/.jshintrc
index 40377ba25e..42aab37a7f 100644
--- a/rd_ui/.jshintrc
+++ b/rd_ui/.jshintrc
@@ -19,6 +19,7 @@
   "trailing": true,
   "smarttabs": true,
   "globals": {
-    "angular": false
+    "angular": false,
+    "_": false
   }
 }
diff --git a/rd_ui/app/index.html b/rd_ui/app/index.html
index ff20acdb7a..3e491b748c 100644
--- a/rd_ui/app/index.html
+++ b/rd_ui/app/index.html
@@ -73,6 +73,9 @@
                     <li><a href="/queries">Queries</a></li>
                 </ul>
             </li>
+            <li>
+                <a href="/alerts">Alerts</a>
+            </li>
         </ul>
         <form class="navbar-form navbar-left" role="search" ng-submit="searchQueries()">
             <div class="form-group">
@@ -164,6 +167,7 @@
 <script src="/scripts/directives/query_directives.js"></script>
 <script src="/scripts/directives/dashboard_directives.js"></script>
 <script src="/scripts/filters.js"></script>
+<script src="/scripts/controllers/alerts.js"></script>
 <!-- endbuild -->
 
 <script>
diff --git a/rd_ui/app/scripts/app.js b/rd_ui/app/scripts/app.js
index 63a63c8bac..13f4a8e568 100644
--- a/rd_ui/app/scripts/app.js
+++ b/rd_ui/app/scripts/app.js
@@ -80,9 +80,14 @@ angular.module('redash', [
         templateUrl: '/views/admin_status.html',
         controller: 'AdminStatusCtrl'
       });
-      $routeProvider.when('/admin/workers', {
-        templateUrl: '/views/admin_workers.html',
-        controller: 'AdminWorkersCtrl'
+
+      $routeProvider.when('/alerts', {
+        templateUrl: '/views/alerts/list.html',
+        controller: 'AlertsCtrl'
+      });
+      $routeProvider.when('/alerts/:alertId', {
+        templateUrl: '/views/alerts/edit.html',
+        controller: 'AlertCtrl'
       });
 
       $routeProvider.when('/', {
diff --git a/rd_ui/app/scripts/controllers/alerts.js b/rd_ui/app/scripts/controllers/alerts.js
new file mode 100644
index 0000000000..c76cb47314
--- /dev/null
+++ b/rd_ui/app/scripts/controllers/alerts.js
@@ -0,0 +1,171 @@
+(function() {
+
+  var AlertsCtrl = function($scope, Events, Alert) {
+    Events.record(currentUser, "view", "page", "alerts");
+    $scope.$parent.pageTitle = "Alerts";
+
+    $scope.alerts = []
+    Alert.query(function(alerts) {
+      var stateClass = {
+        'ok': 'label label-success',
+        'triggered': 'label label-danger',
+        'unknown': 'label label-warning'
+      };
+      _.each(alerts, function(alert) {
+        alert.class = stateClass[alert.state];
+      })
+      $scope.alerts = alerts;
+
+    });
+
+    $scope.gridConfig = {
+      isPaginationEnabled: true,
+      itemsByPage: 50,
+      maxSize: 8,
+    };
+
+
+    $scope.gridColumns = [
+      {
+        "label": "Name",
+        "map": "name",
+        "cellTemplate": '<a href="/alerts/{{dataRow.id}}">{{dataRow.name}}</a> (<a href="/queries/{{dataRow.query.id}}">query</a>)'
+      },
+      {
+        'label': 'Created By',
+        'map': 'user.name'
+      },
+      {
+        'label': 'State',
+        'cellTemplate': '<span ng-class="dataRow.class">{{dataRow.state | uppercase}}</span> since <span am-time-ago="dataRow.updated_at"></span>'
+      },
+      {
+        'label': 'Created At',
+        'cellTemplate': '<span am-time-ago="dataRow.created_at"></span>'
+      }
+    ];
+  };
+
+  var AlertCtrl = function($scope, $routeParams, growl, Query, Events, Alert) {
+    $scope.$parent.pageTitle = "Alerts";
+
+    $scope.alertId = $routeParams.alertId;
+    if ($scope.alertId === "new") {
+      Events.record(currentUser, 'view', 'page', 'alerts/new');
+    } else {
+      Events.record(currentUser, 'view', 'alert', $scope.alertId);
+    }
+
+    $scope.onQuerySelected = function(item) {
+      $scope.selectedQuery = item;
+      item.getQueryResultPromise().then(function(result) {
+        $scope.queryResult = result;
+        $scope.alert.options.column = result.getColumnNames()[0];
+      });
+    };
+
+    if ($scope.alertId === "new") {
+      $scope.alert = new Alert({options: {}});
+    } else {
+      $scope.alert = Alert.get({id: $scope.alertId}, function(alert) {
+        $scope.onQuerySelected(new Query($scope.alert.query));
+      });
+    }
+
+    $scope.ops = ['greater than', 'less than', 'equals'];
+    $scope.selectedQuery = null;
+
+    $scope.getDefaultName = function() {
+      if (!$scope.alert.query) {
+        return undefined;
+      }
+      return _.template("<%= query.name %>: <%= options.column %> <%= options.op %> <%= options.value %>", $scope.alert);
+    };
+
+    $scope.searchQueries = function (term) {
+      if (!term || term.length < 3) {
+        return;
+      }
+
+      Query.search({q: term}, function(results) {
+        $scope.queries = results;
+      });
+    };
+
+    $scope.saveChanges = function() {
+      if ($scope.alert.name === undefined || $scope.alert.name === '') {
+        $scope.alert.name = $scope.getDefaultName();
+      }
+
+      $scope.alert.$save(function() {
+        growl.addSuccessMessage("Saved.");
+      }, function() {
+        growl.addErrorMessage("Failed saving alert.");
+      });
+    };
+  };
+
+  angular.module('redash.directives').directive('alertSubscribers', ['AlertSubscription', function (AlertSubscription) {
+    return {
+      restrict: 'E',
+      replace: true,
+      templateUrl: '/views/alerts/subscribers.html',
+      scope: {
+        'alertId': '='
+      },
+      controller: function ($scope) {
+        $scope.subscribers = AlertSubscription.query({alertId: $scope.alertId});
+      }
+    }
+  }]);
+
+  angular.module('redash.directives').directive('subscribeButton', ['AlertSubscription', 'growl', function (AlertSubscription, growl) {
+    return {
+      restrict: 'E',
+      replace: true,
+      template: '<button class="btn btn-default btn-xs" ng-click="toggleSubscription()"><i ng-class="class"></i></button>',
+      controller: function ($scope) {
+        var updateClass = function() {
+          if ($scope.subscription) {
+            $scope.class = "fa fa-eye-slash";
+          } else {
+            $scope.class = "fa fa-eye";
+          }
+        }
+
+        $scope.subscribers.$promise.then(function() {
+          $scope.subscription = _.find($scope.subscribers, function(subscription) {
+            return (subscription.user.email == currentUser.email);
+          });
+
+          updateClass();
+        });
+
+        $scope.toggleSubscription = function() {
+          if ($scope.subscription) {
+            $scope.subscription.$delete(function() {
+              $scope.subscribers = _.without($scope.subscribers, $scope.subscription);
+              $scope.subscription = undefined;
+              updateClass();
+            }, function() {
+              growl.addErrorMessage("Failed saving subscription.");
+            });
+          } else {
+            $scope.subscription = new AlertSubscription({alert_id: $scope.alertId});
+            $scope.subscription.$save(function() {
+              $scope.subscribers.push($scope.subscription);
+              updateClass();
+            }, function() {
+              growl.addErrorMessage("Unsubscription failed.");
+            });
+          }
+        }
+      }
+    }
+  }]);
+
+  angular.module('redash.controllers')
+    .controller('AlertsCtrl', ['$scope', 'Events', 'Alert', AlertsCtrl])
+    .controller('AlertCtrl', ['$scope', '$routeParams', 'growl', 'Query', 'Events', 'Alert', AlertCtrl])
+
+})();
\ No newline at end of file
diff --git a/rd_ui/app/scripts/controllers/controllers.js b/rd_ui/app/scripts/controllers/controllers.js
index b9f862dd36..db23b6b94f 100644
--- a/rd_ui/app/scripts/controllers/controllers.js
+++ b/rd_ui/app/scripts/controllers/controllers.js
@@ -23,7 +23,7 @@
       },
       {
         'label': 'Created By',
-        'map': 'user_name'
+        'map': 'user.name'
       },
       {
         'label': 'Created At',
@@ -45,7 +45,6 @@
     Query.search({q: $scope.term }, function(results) {
       $scope.queries = _.map(results, function(query) {
         query.created_at = moment(query.created_at);
-        query.user_name = query.user.name;
         return query;
       });
     });
@@ -93,7 +92,6 @@
       $scope.allQueries = _.map(queries, function (query) {
         query.created_at = moment(query.created_at);
         query.retrieved_at = moment(query.retrieved_at);
-        query.user_name = query.user.name;
         return query;
       });
 
@@ -108,7 +106,7 @@
       },
       {
         'label': 'Created By',
-        'map': 'user_name'
+        'map': 'user.name'
       },
       {
         'label': 'Created At',
diff --git a/rd_ui/app/scripts/ng_smart_table.js b/rd_ui/app/scripts/ng_smart_table.js
index bd5c3c444b..fe160e2602 100644
--- a/rd_ui/app/scripts/ng_smart_table.js
+++ b/rd_ui/app/scripts/ng_smart_table.js
@@ -1,631 +1,662 @@
 /* Column module */
 
-(function (global, angular) {
-    "use strict";
-    var smartTableColumnModule = angular.module('smartTable.column', ['smartTable.templateUrlList']).constant('DefaultColumnConfiguration', {
-        isSortable: true,
-        isEditable: false,
-        type: 'text',
-
-
-        //it is useless to have that empty strings, but it reminds what is available
-        headerTemplateUrl: '',
-        map: '',
-        label: '',
-        sortPredicate: '',
-        formatFunction: '',
-        formatParameter: '',
-        filterPredicate: undefined,
-        cellTemplateUrl: '',
-        headerClass: '',
-        cellClass: ''
-    });
+function getNestedValue (obj, keys) {
+  if (keys.length == 1) {
+    return obj[keys[0]];
+  }
+  return getNestedValue(obj[keys[0]], keys.splice(1));
+}
 
-    function ColumnProvider(DefaultColumnConfiguration, templateUrlList) {
+function getKeyFromObject(obj, key) {
+  var value = obj[key];
 
-        function Column(config) {
-            if (!(this instanceof Column)) {
-                return new Column(config);
-            }
-            angular.extend(this, config);
-        }
+  if ((!_.include(obj, key) && _.string.include(key, '.'))) {
+    var keys = key.split(".");
 
-        this.setDefaultOption = function (option) {
-            angular.extend(Column.prototype, option);
-        };
+    value = getNestedValue(obj, keys);
+  }
 
-        DefaultColumnConfiguration.headerTemplateUrl = templateUrlList.defaultHeader;
-        this.setDefaultOption(DefaultColumnConfiguration);
+  return value;
+}
 
-        this.$get = function () {
-            return Column;
-        };
+(function (global, angular) {
+  "use strict";
+
+  var smartTableColumnModule = angular.module('smartTable.column', ['smartTable.templateUrlList']).constant('DefaultColumnConfiguration', {
+    isSortable: true,
+    isEditable: false,
+    type: 'text',
+
+
+    //it is useless to have that empty strings, but it reminds what is available
+    headerTemplateUrl: '',
+    map: '',
+    label: '',
+    sortPredicate: '',
+    formatFunction: '',
+    formatParameter: '',
+    filterPredicate: undefined,
+    cellTemplateUrl: '',
+    headerClass: '',
+    cellClass: ''
+  });
+
+  function ColumnProvider(DefaultColumnConfiguration, templateUrlList) {
+
+    function Column(config) {
+      if (!(this instanceof Column)) {
+        return new Column(config);
+      }
+      angular.extend(this, config);
     }
 
-    ColumnProvider.$inject = ['DefaultColumnConfiguration', 'templateUrlList'];
-    smartTableColumnModule.provider('Column', ColumnProvider);
-
-    //make it global so it can be tested
-    global.ColumnProvider = ColumnProvider;
-})(window, angular);
-
+    this.setDefaultOption = function (option) {
+      angular.extend(Column.prototype, option);
+    };
 
+    DefaultColumnConfiguration.headerTemplateUrl = templateUrlList.defaultHeader;
+    this.setDefaultOption(DefaultColumnConfiguration);
 
-/* Directives */
-(function (angular) {
-    "use strict";
-    angular.module('smartTable.directives', ['smartTable.templateUrlList', 'smartTable.templates'])
-        .directive('smartTable', ['templateUrlList', 'DefaultTableConfiguration', function (templateList, defaultConfig) {
-            return {
-                restrict: 'EA',
-                scope: {
-                    columnCollection: '=columns',
-                    dataCollection: '=rows',
-                    config: '='
-                },
-                replace: 'true',
-                templateUrl: templateList.smartTable,
-                controller: 'TableCtrl',
-                link: function (scope, element, attr, ctrl) {
-
-                    var templateObject;
-
-                    scope.$watch('config', function (config) {
-                        var newConfig = angular.extend({}, defaultConfig, config),
-                            length = scope.columns !== undefined ? scope.columns.length : 0;
-
-                        ctrl.setGlobalConfig(newConfig);
-
-                        //remove the checkbox column if needed
-                        if (newConfig.selectionMode !== 'multiple' || newConfig.displaySelectionCheckbox !== true) {
-                            for (var i = length - 1; i >= 0; i--) {
-                                if (scope.columns[i].isSelectionColumn === true) {
-                                    ctrl.removeColumn(i);
-                                }
-                            }
-                        } else {
-                            //add selection box column if required
-                            ctrl.insertColumn({cellTemplateUrl: templateList.selectionCheckbox, headerTemplateUrl: templateList.selectAllCheckbox, isSelectionColumn: true}, 0);
-                        }
-                    }, true);
-
-                    //insert columns from column config
-                    //TODO add a way to clean all columns
-                    scope.$watchCollection('columnCollection', function (oldValue, newValue) {
-                        if (scope.columnCollection) {
-                            scope.columns.length = 0;
-                            for (var i = 0, l = scope.columnCollection.length; i < l; i++) {
-
-                                ctrl.insertColumn(scope.columnCollection[i]);
-                            }
-                        } else {
-                            //or guess data Structure
-                            if (scope.dataCollection && scope.dataCollection.length > 0) {
-                                templateObject = scope.dataCollection[0];
-                                angular.forEach(templateObject, function (value, key) {
-                                    if (key[0] != '$') {
-                                        ctrl.insertColumn({label: key, map: key});
-                                    }
-                                });
-                            }
-                        }
-                    }, true);
-
-                    //if item are added or removed into the data model from outside the grid
-                    scope.$watch('dataCollection', function (oldValue, newValue) {
-                        // evme:
-                        // reset sorting when data updates (executing query again)
-                        if (newValue) {
-                            ctrl.resetSort();
-                        }
-                    });
-
-                }
-            };
-        }])
-        //just to be able to select the row
-        .directive('smartTableDataRow', function () {
-
-            return {
-                require: '^smartTable',
-                restrict: 'C',
-                link: function (scope, element, attr, ctrl) {
-
-                    element.bind('click', function () {
-                        scope.$apply(function () {
-                            ctrl.toggleSelection(scope.dataRow);
-                        })
-                    });
-                }
-            };
-        })
-        //header cell with sorting functionality or put a checkbox if this column is a selection column
-        .directive('smartTableHeaderCell',function () {
-            return {
-                restrict: 'C',
-                require: '^smartTable',
-                link: function (scope, element, attr, ctrl) {
-                    element.bind('click', function () {
-                        scope.$apply(function () {
-                            ctrl.sortBy(scope.column);
-                        });
-                    })
-                }
-            };
-        }).directive('smartTableSelectAll', function () {
-            return {
-                restrict: 'C',
-                require: '^smartTable',
-                link: function (scope, element, attr, ctrl) {
-                    element.bind('click', function (event) {
-                        ctrl.toggleSelectionAll(element[0].checked === true);
-                    })
-                }
-            };
-        })
-        //credit to Valentyn shybanov : http://stackoverflow.com/questions/14544741/angularjs-directive-to-stoppropagation
-        .directive('stopEvent', function () {
-            return {
-                restrict: 'A',
-                link: function (scope, element, attr) {
-                    element.bind(attr.stopEvent, function (e) {
-                        e.stopPropagation();
-                    });
-                }
-            }
-        })
-        //the global filter
-        .directive('smartTableGlobalSearch', ['templateUrlList', function (templateList) {
-            return {
-                restrict: 'C',
-                require: '^smartTable',
-                scope: {
-                    columnSpan: '@'
-                },
-                templateUrl: templateList.smartTableGlobalSearch,
-                replace: false,
-                link: function (scope, element, attr, ctrl) {
-
-                    scope.searchValue = undefined;
-
-                    scope.$watch('searchValue', function (value) {
-                        //todo perf improvement only filter on blur ?
-                        ctrl.search(value);
-                    });
-                }
-            }
-        }])
-        //a customisable cell (see templateUrl) and editable
-        //TODO check with the ng-include strategy
-        .directive('smartTableDataCell', ['$filter', '$http', '$templateCache', '$compile', '$parse', function (filter, http, templateCache, compile, parse) {
-            return {
-                restrict: 'C',
-                link: function (scope, element) {
-                    var
-                        column = scope.column,
-                        row = scope.dataRow,
-                        format = filter('format'),
-                        childScope;
-
-                    //can be useful for child directives
-                    scope.formatedValue = format(row[column.map], column.formatFunction, column.formatParameter);
-
-                    function defaultContent() {
-                        //clear content
-                        if (column.isEditable) {
-                            element.html('<div editable-cell="" row="dataRow" column="column" type="column.type"></div>');
-                            compile(element.contents())(scope);
-                        } else {
-                            element.html(scope.formatedValue);
-                        }
-                    }
-
-                    scope.$watch('column.cellTemplateUrl', function (value) {
-
-                        if (value) {
-                            //we have to load the template (and cache it) : a kind of ngInclude
-                            http.get(value, {cache: templateCache}).success(function (response) {
-
-                                //create a scope
-                                childScope = scope.$new();
-                                //compile the element with its new content and new scope
-                                element.html(response);
-                                compile(element.contents())(childScope);
-                            }).error(defaultContent);
-
-                        } else {
-                            defaultContent();
-                        }
-                    });
-                }
-            };
-        }])
-        //directive that allows type to be bound in input
-        .directive('inputType', function () {
-            return {
-                restrict: 'A',
-                priority: 1,
-                link: function (scope, ielement, iattr) {
-                    //force the type to be set before inputDirective is called
-                    var type = scope.$eval(iattr.type);
-                    iattr.$set('type', type);
-                }
-            };
-        })
-        //an editable content in the context of a cell (see row, column)
-        .directive('editableCell', ['templateUrlList', '$parse', function (templateList, parse) {
-            return {
-                restrict: 'EA',
-                require: '^smartTable',
-                templateUrl: templateList.editableCell,
-                scope: {
-                    row: '=',
-                    column: '=',
-                    type: '='
-                },
-                replace: true,
-                link: function (scope, element, attrs, ctrl) {
-                    var form = angular.element(element.children()[1]),
-                        input = angular.element(form.children()[0]);
-
-                    //init values
-                    scope.isEditMode = false;
-                    scope.value = scope.row[scope.column.map];
-
-
-                    scope.submit = function () {
-                        //update model if valid
-                        if (scope.myForm.$valid === true) {
-                            ctrl.updateDataRow(scope.row, scope.column.map, scope.value);
-                            ctrl.sortBy();//it will trigger the refresh...  (ie it will sort, filter, etc with the new value)
-                        }
-                        scope.toggleEditMode();
-                    };
-
-                    scope.toggleEditMode = function () {
-                        scope.value = scope.row[scope.column.map];
-                        scope.isEditMode = scope.isEditMode !== true;
-                    };
-
-                    scope.$watch('isEditMode', function (newValue, oldValue) {
-                        if (newValue) {
-                            input[0].select();
-                            input[0].focus();
-                        }
-                    });
-
-                    input.bind('blur', function () {
-                        scope.$apply(function () {
-                            scope.submit();
-                        });
-                    });
-                }
-            };
-        }]);
-})(angular);
+    this.$get = function () {
+      return Column;
+    };
+  }
 
-/* Filters */
-(function (angular) {
-    "use strict";
-    angular.module('smartTable.filters', []).
-        constant('DefaultFilters', ['currency', 'date', 'json', 'lowercase', 'number', 'uppercase']).
-        filter('format', ['$filter', 'DefaultFilters', function (filter, defaultfilters) {
-            return function (value, formatFunction, filterParameter) {
-
-                var returnFunction;
-
-                if (formatFunction && angular.isFunction(formatFunction)) {
-                    returnFunction = formatFunction;
-                } else {
-                    returnFunction = defaultfilters.indexOf(formatFunction) !== -1 ? filter(formatFunction) : function (value) {
-                        return value;
-                    };
-                }
-                return returnFunction(value, filterParameter);
-            };
-        }]);
-})(angular);
+  ColumnProvider.$inject = ['DefaultColumnConfiguration', 'templateUrlList'];
+  smartTableColumnModule.provider('Column', ColumnProvider);
 
+  //make it global so it can be tested
+  global.ColumnProvider = ColumnProvider;
+})(window, angular);
 
-/*table module */
 
+/* Directives */
 (function (angular) {
-    "use strict";
-    angular.module('smartTable.table', ['smartTable.column', 'smartTable.utilities', 'smartTable.directives', 'smartTable.filters', 'ui.bootstrap.pagination.smartTable'])
-        .constant('DefaultTableConfiguration', {
-            selectionMode: 'none',
-            isGlobalSearchActivated: false,
-            displaySelectionCheckbox: false,
-            isPaginationEnabled: true,
-            itemsByPage: 10,
-            maxSize: 5,
-
-            //just to remind available option
-            sortAlgorithm: '',
-            filterAlgorithm: ''
-        })
-        .controller('TableCtrl', ['$scope', 'Column', '$filter', '$parse', 'ArrayUtility', 'DefaultTableConfiguration', function (scope, Column, filter, parse, arrayUtility, defaultConfig) {
-
-            scope.columns = [];
-            scope.dataCollection = scope.dataCollection || [];
-            scope.displayedCollection = []; //init empty array so that if pagination is enabled, it does not spoil performances
-            scope.numberOfPages = calculateNumberOfPages(scope.dataCollection);
-            scope.currentPage = 1;
-            scope.holder = {isAllSelected: false};
-
-            var predicate = {},
-                lastColumnSort;
-
-            function isAllSelected() {
-                var i,
-                    l = scope.displayedCollection.length;
-                for (i = 0; i < l; i++) {
-                    if (scope.displayedCollection[i].isSelected !== true) {
-                        return false;
-                    }
+  "use strict";
+
+  angular.module('smartTable.directives', ['smartTable.templateUrlList', 'smartTable.templates'])
+    .directive('smartTable', ['templateUrlList', 'DefaultTableConfiguration', function (templateList, defaultConfig) {
+      return {
+        restrict: 'EA',
+        scope: {
+          columnCollection: '=columns',
+          dataCollection: '=rows',
+          config: '='
+        },
+        replace: 'true',
+        templateUrl: templateList.smartTable,
+        controller: 'TableCtrl',
+        link: function (scope, element, attr, ctrl) {
+
+          var templateObject;
+
+          scope.$watch('config', function (config) {
+            var newConfig = angular.extend({}, defaultConfig, config),
+              length = scope.columns !== undefined ? scope.columns.length : 0;
+
+            ctrl.setGlobalConfig(newConfig);
+
+            //remove the checkbox column if needed
+            if (newConfig.selectionMode !== 'multiple' || newConfig.displaySelectionCheckbox !== true) {
+              for (var i = length - 1; i >= 0; i--) {
+                if (scope.columns[i].isSelectionColumn === true) {
+                  ctrl.removeColumn(i);
                 }
-                return true;
+              }
+            } else {
+              //add selection box column if required
+              ctrl.insertColumn({
+                cellTemplateUrl: templateList.selectionCheckbox,
+                headerTemplateUrl: templateList.selectAllCheckbox,
+                isSelectionColumn: true
+              }, 0);
             }
-
-            function calculateNumberOfPages(array) {
-
-                if (!angular.isArray(array)) {
-                    return 1;
-                }
-                if (array.length === 0 || scope.itemsByPage < 1) {
-                    return 1;
-                }
-                return Math.ceil(array.length / scope.itemsByPage);
+          }, true);
+
+          //insert columns from column config
+          //TODO add a way to clean all columns
+          scope.$watchCollection('columnCollection', function (oldValue, newValue) {
+            if (scope.columnCollection) {
+              scope.columns.length = 0;
+              for (var i = 0, l = scope.columnCollection.length; i < l; i++) {
+
+                ctrl.insertColumn(scope.columnCollection[i]);
+              }
+            } else {
+              //or guess data Structure
+              if (scope.dataCollection && scope.dataCollection.length > 0) {
+                templateObject = scope.dataCollection[0];
+                angular.forEach(templateObject, function (value, key) {
+                  if (key[0] != '$') {
+                    ctrl.insertColumn({label: key, map: key});
+                  }
+                });
+              }
             }
-
-            function sortDataRow(array, column) {
-                var sortAlgo = (scope.sortAlgorithm && angular.isFunction(scope.sortAlgorithm)) === true ? scope.sortAlgorithm : filter('orderBy');
-                if (column) {
-                    var predicate = function(o) {
-                        return o[column.sortPredicate];
-                    };
-                    return arrayUtility.sort(array, sortAlgo, predicate, column.reverse);
-                } else {
-                    return array;
-                }
+          }, true);
+
+          //if item are added or removed into the data model from outside the grid
+          scope.$watch('dataCollection', function (oldValue, newValue) {
+            // evme:
+            // reset sorting when data updates (executing query again)
+            if (newValue) {
+              ctrl.resetSort();
             }
+          });
 
-            function selectDataRow(array, selectionMode, index, select) {
-
-                var dataRow, oldValue;
-
-                if ((!angular.isArray(array)) || (selectionMode !== 'multiple' && selectionMode !== 'single')) {
-                    return;
-                }
-
-                if (index >= 0 && index < array.length) {
-                    dataRow = array[index];
-                    if (selectionMode === 'single') {
-                        //unselect all the others
-                        for (var i = 0, l = array.length; i < l; i++) {
-                            oldValue = array[i].isSelected;
-                            array[i].isSelected = false;
-                            if (oldValue === true) {
-                                scope.$emit('selectionChange', {item: array[i]});
-                            }
-                        }
-                    }
-                    dataRow.isSelected = select;
-                    scope.holder.isAllSelected = isAllSelected();
-                    scope.$emit('selectionChange', {item: dataRow});
-                }
+        }
+      };
+    }])
+    //just to be able to select the row
+    .directive('smartTableDataRow', function () {
+
+      return {
+        require: '^smartTable',
+        restrict: 'C',
+        link: function (scope, element, attr, ctrl) {
+
+          element.bind('click', function () {
+            scope.$apply(function () {
+              ctrl.toggleSelection(scope.dataRow);
+            })
+          });
+        }
+      };
+    })
+    //header cell with sorting functionality or put a checkbox if this column is a selection column
+    .directive('smartTableHeaderCell', function () {
+      return {
+        restrict: 'C',
+        require: '^smartTable',
+        link: function (scope, element, attr, ctrl) {
+          element.bind('click', function () {
+            scope.$apply(function () {
+              ctrl.sortBy(scope.column);
+            });
+          })
+        }
+      };
+    }).directive('smartTableSelectAll', function () {
+      return {
+        restrict: 'C',
+        require: '^smartTable',
+        link: function (scope, element, attr, ctrl) {
+          element.bind('click', function (event) {
+            ctrl.toggleSelectionAll(element[0].checked === true);
+          })
+        }
+      };
+    })
+    //credit to Valentyn shybanov : http://stackoverflow.com/questions/14544741/angularjs-directive-to-stoppropagation
+    .directive('stopEvent', function () {
+      return {
+        restrict: 'A',
+        link: function (scope, element, attr) {
+          element.bind(attr.stopEvent, function (e) {
+            e.stopPropagation();
+          });
+        }
+      }
+    })
+    //the global filter
+    .directive('smartTableGlobalSearch', ['templateUrlList', function (templateList) {
+      return {
+        restrict: 'C',
+        require: '^smartTable',
+        scope: {
+          columnSpan: '@'
+        },
+        templateUrl: templateList.smartTableGlobalSearch,
+        replace: false,
+        link: function (scope, element, attr, ctrl) {
+
+          scope.searchValue = undefined;
+
+          scope.$watch('searchValue', function (value) {
+            //todo perf improvement only filter on blur ?
+            ctrl.search(value);
+          });
+        }
+      }
+    }])
+    //a customisable cell (see templateUrl) and editable
+    //TODO check with the ng-include strategy
+    .directive('smartTableDataCell', ['$filter', '$http', '$templateCache', '$compile', '$parse', function (filter, http, templateCache, compile, parse) {
+      return {
+        restrict: 'C',
+        link: function (scope, element) {
+          var
+            column = scope.column,
+            row = scope.dataRow,
+            format = filter('format'),
+            childScope;
+
+          var value = getKeyFromObject(row, column.map);
+
+          //can be useful for child directives
+          scope.formatedValue = format(value, column.formatFunction, column.formatParameter);
+
+          function defaultContent() {
+            //clear content
+            if (column.isEditable) {
+              element.html('<div editable-cell="" row="dataRow" column="column" type="column.type"></div>');
+              compile(element.contents())(scope);
+            } else if (column.cellTemplate) {
+              //create a scope
+              childScope = scope.$new();
+              //compile the element with its new content and new scope
+              element.html(column.cellTemplate);
+              compile(element.contents())(childScope);
+            } else {
+              element.html(scope.formatedValue);
             }
+          }
 
-            /**
-             * set the config (config parameters will be available through scope
-             * @param config
-             */
-            this.setGlobalConfig = function (config) {
-                angular.extend(scope, defaultConfig, config);
-            };
-
-            /**
-             * change the current page displayed
-             * @param page
-             */
-            this.changePage = function (page) {
-                var oldPage = scope.currentPage;
-                if (angular.isNumber(page.page)) {
-                    scope.currentPage = page.page;
-                    scope.displayedCollection = this.pipe(scope.dataCollection);
-                    scope.holder.isAllSelected = isAllSelected();
-                    scope.$emit('changePage', {oldValue: oldPage, newValue: scope.currentPage});
-                }
-            };
-
-            /**
-             * set column as the column used to sort the data (if it is already the case, it will change the reverse value)
-             * @method sortBy
-             * @param column
-             */
-            this.sortBy = function (column) {
-                var index = scope.columns.indexOf(column);
-                if (index !== -1) {
-                    if (column.isSortable === true) {
-                        // reset the last column used
-                        if (lastColumnSort && lastColumnSort !== column) {
-                            lastColumnSort.reverse = 'none';
-                        }
-
-                        column.sortPredicate = column.sortPredicate || column.map;
-                        column.reverse = column.reverse !== true;
-                        lastColumnSort = column;
-                    }
-                }
-
-                scope.displayedCollection = this.pipe(scope.dataCollection);
-            };
+          scope.$watch('column.cellTemplateUrl', function (value) {
 
-            /**
-             * set the filter predicate used for searching
-             * @param input
-             * @param column
-             */
-            this.search = function (input, column) {
-                //update column and global predicate
-                if (column && scope.columns.indexOf(column) !== -1) {
-                    predicate.$ = '';
-                    column.filterPredicate = input;
-                } else {
-                    for (var j = 0, l = scope.columns.length; j < l; j++) {
-                        scope.columns[j].filterPredicate = undefined;
-                    }
-                    predicate.$ = input;
-                }
+            if (value) {
+              //we have to load the template (and cache it) : a kind of ngInclude
+              http.get(value, {cache: templateCache}).success(function (response) {
 
-                for (var j = 0, l = scope.columns.length; j < l; j++) {
-                    predicate[scope.columns[j].map] = scope.columns[j].filterPredicate;
-                }
-                scope.displayedCollection = this.pipe(scope.dataCollection);
-
-            };
+                //create a scope
+                childScope = scope.$new();
+                //compile the element with its new content and new scope
+                element.html(response);
+                compile(element.contents())(childScope);
+              }).error(defaultContent);
 
-            /**
-             * combine sort, search and limitTo operations on an array,
-             * @param array
-             * @returns Array, an array result of the operations on input array
-             */
-            this.pipe = function (array) {
-                var filterAlgo = (scope.filterAlgorithm && angular.isFunction(scope.filterAlgorithm)) === true ? scope.filterAlgorithm : filter('filter'),
-                    output;
-                //filter and sort are commutative
-                output = sortDataRow(arrayUtility.filter(array, filterAlgo, predicate), lastColumnSort);
-                scope.numberOfPages = calculateNumberOfPages(output);
-                return scope.isPaginationEnabled ? arrayUtility.fromTo(output, (scope.currentPage - 1) * scope.itemsByPage, scope.itemsByPage) : output;
-            };
+            } else {
+              defaultContent();
+            }
+          });
+        }
+      };
+    }])
+    //directive that allows type to be bound in input
+    .directive('inputType', function () {
+      return {
+        restrict: 'A',
+        priority: 1,
+        link: function (scope, ielement, iattr) {
+          //force the type to be set before inputDirective is called
+          var type = scope.$eval(iattr.type);
+          iattr.$set('type', type);
+        }
+      };
+    })
+    //an editable content in the context of a cell (see row, column)
+    .directive('editableCell', ['templateUrlList', '$parse', function (templateList, parse) {
+      return {
+        restrict: 'EA',
+        require: '^smartTable',
+        templateUrl: templateList.editableCell,
+        scope: {
+          row: '=',
+          column: '=',
+          type: '='
+        },
+        replace: true,
+        link: function (scope, element, attrs, ctrl) {
+          var form = angular.element(element.children()[1]),
+            input = angular.element(form.children()[0]);
+
+          //init values
+          scope.isEditMode = false;
+          scope.value = scope.row[scope.column.map];
+
+
+          scope.submit = function () {
+            //update model if valid
+            if (scope.myForm.$valid === true) {
+              ctrl.updateDataRow(scope.row, scope.column.map, scope.value);
+              ctrl.sortBy();//it will trigger the refresh...  (ie it will sort, filter, etc with the new value)
+            }
+            scope.toggleEditMode();
+          };
+
+          scope.toggleEditMode = function () {
+            scope.value = scope.row[scope.column.map];
+            scope.isEditMode = scope.isEditMode !== true;
+          };
+
+          scope.$watch('isEditMode', function (newValue, oldValue) {
+            if (newValue) {
+              input[0].select();
+              input[0].focus();
+            }
+          });
 
-            this.resetSort = function() {
-                lastColumnSort = null;
-                predicate = {};
-                this.sortBy();
-            };
+          input.bind('blur', function () {
+            scope.$apply(function () {
+              scope.submit();
+            });
+          });
+        }
+      };
+    }]);
+})(angular);
 
-            /*////////////
-             Column API
-             ///////////*/
+/* Filters */
+(function (angular) {
+  "use strict";
+  angular.module('smartTable.filters', []).
+    constant('DefaultFilters', ['currency', 'date', 'json', 'lowercase', 'number', 'uppercase']).
+    filter('format', ['$filter', 'DefaultFilters', function (filter, defaultfilters) {
+      return function (value, formatFunction, filterParameter) {
+
+        var returnFunction;
+
+        if (formatFunction && angular.isFunction(formatFunction)) {
+          returnFunction = formatFunction;
+        } else {
+          returnFunction = defaultfilters.indexOf(formatFunction) !== -1 ? filter(formatFunction) : function (value) {
+            return value;
+          };
+        }
+        return returnFunction(value, filterParameter);
+      };
+    }]);
+})(angular);
 
 
-            /**
-             * insert a new column in scope.collection at index or push at the end if no index
-             * @param columnConfig column configuration used to instantiate the new Column
-             * @param index where to insert the column (at the end if not specified)
-             */
-            this.insertColumn = function (columnConfig, index) {
-                var column = new Column(columnConfig);
-                arrayUtility.insertAt(scope.columns, index, column);
-            };
+/*table module */
 
-            /**
-             * remove the column at columnIndex from scope.columns
-             * @param columnIndex index of the column to be removed
-             */
-            this.removeColumn = function (columnIndex) {
-                arrayUtility.removeAt(scope.columns, columnIndex);
-            };
+(function (angular) {
+  "use strict";
+  angular.module('smartTable.table', ['smartTable.column', 'smartTable.utilities', 'smartTable.directives', 'smartTable.filters', 'ui.bootstrap.pagination.smartTable'])
+    .constant('DefaultTableConfiguration', {
+      selectionMode: 'none',
+      isGlobalSearchActivated: false,
+      displaySelectionCheckbox: false,
+      isPaginationEnabled: true,
+      itemsByPage: 10,
+      maxSize: 5,
+
+      //just to remind available option
+      sortAlgorithm: '',
+      filterAlgorithm: ''
+    })
+    .controller('TableCtrl', ['$scope', 'Column', '$filter', '$parse', 'ArrayUtility', 'DefaultTableConfiguration', function (scope, Column, filter, parse, arrayUtility, defaultConfig) {
+
+      scope.columns = [];
+      scope.dataCollection = scope.dataCollection || [];
+      scope.displayedCollection = []; //init empty array so that if pagination is enabled, it does not spoil performances
+      scope.numberOfPages = calculateNumberOfPages(scope.dataCollection);
+      scope.currentPage = 1;
+      scope.holder = {isAllSelected: false};
+
+      var predicate = {},
+        lastColumnSort;
+
+      function isAllSelected() {
+        var i,
+          l = scope.displayedCollection.length;
+        for (i = 0; i < l; i++) {
+          if (scope.displayedCollection[i].isSelected !== true) {
+            return false;
+          }
+        }
+        return true;
+      }
 
-            /**
-             * move column located at oldIndex to the newIndex in scope.columns
-             * @param oldIndex index of the column before it is moved
-             * @param newIndex index of the column after the column is moved
-             */
-            this.moveColumn = function (oldIndex, newIndex) {
-                arrayUtility.moveAt(scope.columns, oldIndex, newIndex);
-            };
+      function calculateNumberOfPages(array) {
 
+        if (!angular.isArray(array)) {
+          return 1;
+        }
+        if (array.length === 0 || scope.itemsByPage < 1) {
+          return 1;
+        }
+        return Math.ceil(array.length / scope.itemsByPage);
+      }
+
+      function sortDataRow(array, column) {
+        var sortAlgo = (scope.sortAlgorithm && angular.isFunction(scope.sortAlgorithm)) === true ? scope.sortAlgorithm : filter('orderBy');
+        if (column) {
+          var predicate = function (o) {
+            return getKeyFromObject(o, column.sortPredicate);
+          };
+          return arrayUtility.sort(array, sortAlgo, predicate, column.reverse);
+        } else {
+          return array;
+        }
+      }
 
-            /*///////////
-             ROW API
-             */
+      function selectDataRow(array, selectionMode, index, select) {
 
-            /**
-             * select or unselect the item of the displayedCollection with the selection mode set in the scope
-             * @param dataRow
-             */
-            this.toggleSelection = function (dataRow) {
-                var index = scope.dataCollection.indexOf(dataRow);
-                if (index !== -1) {
-                    selectDataRow(scope.dataCollection, scope.selectionMode, index, dataRow.isSelected !== true);
-                }
-            };
+        var dataRow, oldValue;
 
-            /**
-             * select/unselect all the currently displayed rows
-             * @param value if true select, else unselect
-             */
-            this.toggleSelectionAll = function (value) {
-                var i = 0,
-                    l = scope.displayedCollection.length;
+        if ((!angular.isArray(array)) || (selectionMode !== 'multiple' && selectionMode !== 'single')) {
+          return;
+        }
 
-                if (scope.selectionMode !== 'multiple') {
-                    return;
-                }
-                for (; i < l; i++) {
-                    selectDataRow(scope.displayedCollection, scope.selectionMode, i, value === true);
-                }
-            };
+        if (index >= 0 && index < array.length) {
+          dataRow = array[index];
+          if (selectionMode === 'single') {
+            //unselect all the others
+            for (var i = 0, l = array.length; i < l; i++) {
+              oldValue = array[i].isSelected;
+              array[i].isSelected = false;
+              if (oldValue === true) {
+                scope.$emit('selectionChange', {item: array[i]});
+              }
+            }
+          }
+          dataRow.isSelected = select;
+          scope.holder.isAllSelected = isAllSelected();
+          scope.$emit('selectionChange', {item: dataRow});
+        }
+      }
+
+      /**
+       * set the config (config parameters will be available through scope
+       * @param config
+       */
+      this.setGlobalConfig = function (config) {
+        angular.extend(scope, defaultConfig, config);
+      };
+
+      /**
+       * change the current page displayed
+       * @param page
+       */
+      this.changePage = function (page) {
+        var oldPage = scope.currentPage;
+        if (angular.isNumber(page.page)) {
+          scope.currentPage = page.page;
+          scope.displayedCollection = this.pipe(scope.dataCollection);
+          scope.holder.isAllSelected = isAllSelected();
+          scope.$emit('changePage', {oldValue: oldPage, newValue: scope.currentPage});
+        }
+      };
+
+      /**
+       * set column as the column used to sort the data (if it is already the case, it will change the reverse value)
+       * @method sortBy
+       * @param column
+       */
+      this.sortBy = function (column) {
+        var index = scope.columns.indexOf(column);
+        if (index !== -1) {
+          if (column.isSortable === true) {
+            // reset the last column used
+            if (lastColumnSort && lastColumnSort !== column) {
+              lastColumnSort.reverse = 'none';
+            }
 
-            /**
-             * remove the item at index rowIndex from the displayed collection
-             * @param rowIndex
-             * @returns {*} item just removed or undefined
-             */
-            this.removeDataRow = function (rowIndex) {
-                var toRemove = arrayUtility.removeAt(scope.displayedCollection, rowIndex);
-                arrayUtility.removeAt(scope.dataCollection, scope.dataCollection.indexOf(toRemove));
-            };
+            column.sortPredicate = column.sortPredicate || column.map;
+            column.reverse = column.reverse !== true;
+            lastColumnSort = column;
+          }
+        }
 
-            /**
-             * move an item from oldIndex to newIndex in displayedCollection
-             * @param oldIndex
-             * @param newIndex
-             */
-            this.moveDataRow = function (oldIndex, newIndex) {
-                arrayUtility.moveAt(scope.displayedCollection, oldIndex, newIndex);
-            };
+        scope.displayedCollection = this.pipe(scope.dataCollection);
+      };
+
+      /**
+       * set the filter predicate used for searching
+       * @param input
+       * @param column
+       */
+      this.search = function (input, column) {
+        //update column and global predicate
+        if (column && scope.columns.indexOf(column) !== -1) {
+          predicate.$ = '';
+          column.filterPredicate = input;
+        } else {
+          for (var j = 0, l = scope.columns.length; j < l; j++) {
+            scope.columns[j].filterPredicate = undefined;
+          }
+          predicate.$ = input;
+        }
 
-            /**
-             * update the model, it can be a non existing yet property
-             * @param dataRow the dataRow to update
-             * @param propertyName the property on the dataRow ojbect to update
-             * @param newValue the value to set
-             */
-            this.updateDataRow = function (dataRow, propertyName, newValue) {
-                var index = scope.displayedCollection.indexOf(dataRow),
-                    oldValue;
-                if (index !== -1) {
-                    oldValue = scope.displayedCollection[index][propertyName];
-                    if (oldValue !== newValue) {
-                        scope.displayedCollection[index][propertyName] = newValue;
-                        scope.$emit('updateDataRow', {item: scope.displayedCollection[index]});
-                    }
-                }
-            };
+        for (var j = 0, l = scope.columns.length; j < l; j++) {
+          predicate[scope.columns[j].map] = scope.columns[j].filterPredicate;
+        }
+        scope.displayedCollection = this.pipe(scope.dataCollection);
+
+      };
+
+      /**
+       * combine sort, search and limitTo operations on an array,
+       * @param array
+       * @returns Array, an array result of the operations on input array
+       */
+      this.pipe = function (array) {
+        var filterAlgo = (scope.filterAlgorithm && angular.isFunction(scope.filterAlgorithm)) === true ? scope.filterAlgorithm : filter('filter'),
+          output;
+        //filter and sort are commutative
+        output = sortDataRow(arrayUtility.filter(array, filterAlgo, predicate), lastColumnSort);
+        scope.numberOfPages = calculateNumberOfPages(output);
+        return scope.isPaginationEnabled ? arrayUtility.fromTo(output, (scope.currentPage - 1) * scope.itemsByPage, scope.itemsByPage) : output;
+      };
+
+      this.resetSort = function () {
+        lastColumnSort = null;
+        predicate = {};
+        this.sortBy();
+      };
+
+      /*////////////
+       Column API
+       ///////////*/
+
+
+      /**
+       * insert a new column in scope.collection at index or push at the end if no index
+       * @param columnConfig column configuration used to instantiate the new Column
+       * @param index where to insert the column (at the end if not specified)
+       */
+      this.insertColumn = function (columnConfig, index) {
+        var column = new Column(columnConfig);
+        arrayUtility.insertAt(scope.columns, index, column);
+      };
+
+      /**
+       * remove the column at columnIndex from scope.columns
+       * @param columnIndex index of the column to be removed
+       */
+      this.removeColumn = function (columnIndex) {
+        arrayUtility.removeAt(scope.columns, columnIndex);
+      };
+
+      /**
+       * move column located at oldIndex to the newIndex in scope.columns
+       * @param oldIndex index of the column before it is moved
+       * @param newIndex index of the column after the column is moved
+       */
+      this.moveColumn = function (oldIndex, newIndex) {
+        arrayUtility.moveAt(scope.columns, oldIndex, newIndex);
+      };
+
+
+      /*///////////
+       ROW API
+       */
+
+      /**
+       * select or unselect the item of the displayedCollection with the selection mode set in the scope
+       * @param dataRow
+       */
+      this.toggleSelection = function (dataRow) {
+        var index = scope.dataCollection.indexOf(dataRow);
+        if (index !== -1) {
+          selectDataRow(scope.dataCollection, scope.selectionMode, index, dataRow.isSelected !== true);
+        }
+      };
+
+      /**
+       * select/unselect all the currently displayed rows
+       * @param value if true select, else unselect
+       */
+      this.toggleSelectionAll = function (value) {
+        var i = 0,
+          l = scope.displayedCollection.length;
+
+        if (scope.selectionMode !== 'multiple') {
+          return;
+        }
+        for (; i < l; i++) {
+          selectDataRow(scope.displayedCollection, scope.selectionMode, i, value === true);
+        }
+      };
+
+      /**
+       * remove the item at index rowIndex from the displayed collection
+       * @param rowIndex
+       * @returns {*} item just removed or undefined
+       */
+      this.removeDataRow = function (rowIndex) {
+        var toRemove = arrayUtility.removeAt(scope.displayedCollection, rowIndex);
+        arrayUtility.removeAt(scope.dataCollection, scope.dataCollection.indexOf(toRemove));
+      };
+
+      /**
+       * move an item from oldIndex to newIndex in displayedCollection
+       * @param oldIndex
+       * @param newIndex
+       */
+      this.moveDataRow = function (oldIndex, newIndex) {
+        arrayUtility.moveAt(scope.displayedCollection, oldIndex, newIndex);
+      };
+
+      /**
+       * update the model, it can be a non existing yet property
+       * @param dataRow the dataRow to update
+       * @param propertyName the property on the dataRow ojbect to update
+       * @param newValue the value to set
+       */
+      this.updateDataRow = function (dataRow, propertyName, newValue) {
+        var index = scope.displayedCollection.indexOf(dataRow),
+          oldValue;
+        if (index !== -1) {
+          oldValue = scope.displayedCollection[index][propertyName];
+          if (oldValue !== newValue) {
+            scope.displayedCollection[index][propertyName] = newValue;
+            scope.$emit('updateDataRow', {item: scope.displayedCollection[index]});
+          }
+        }
+      };
 
 
-        }]);
+    }]);
 
 })(angular);
 
 
-
 angular.module('smartTable.templates', ['partials/defaultCell.html', 'partials/defaultHeader.html', 'partials/editableCell.html', 'partials/globalSearchCell.html', 'partials/pagination.html', 'partials/selectAllCheckbox.html', 'partials/selectionCheckbox.html', 'partials/smartTable.html']);
 
-angular.module("partials/defaultCell.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/defaultCell.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/defaultCell.html",
     "{{formatedValue}}");
 }]);
 
-angular.module("partials/defaultHeader.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/defaultHeader.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/defaultHeader.html",
     "<span class=\"header-content\" ng-class=\"{'sort-ascent':column.reverse==true,'sort-descent':column.reverse==false}\">{{column.label}}</span>");
 }]);
 
-angular.module("partials/editableCell.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/editableCell.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/editableCell.html",
     "<div ng-dblclick=\"toggleEditMode($event)\">\n" +
     "    <span ng-hide=\"isEditMode\">{{value | format:column.formatFunction:column.formatParameter}}</span>\n" +
@@ -636,13 +667,13 @@ angular.module("partials/editableCell.html", []).run(["$templateCache", function
     "</div>");
 }]);
 
-angular.module("partials/globalSearchCell.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/globalSearchCell.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/globalSearchCell.html",
     "<label>Search :</label>\n" +
     "<input type=\"text\" ng-model=\"searchValue\"/>");
 }]);
 
-angular.module("partials/pagination.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/pagination.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/pagination.html",
     "<ul class=\"pagination\">\n" +
     "        <li ng-repeat=\"page in pages\" ng-class=\"{active: page.active, disabled: page.disabled}\"><a\n" +
@@ -650,17 +681,17 @@ angular.module("partials/pagination.html", []).run(["$templateCache", function($
     "</ul> ");
 }]);
 
-angular.module("partials/selectAllCheckbox.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/selectAllCheckbox.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/selectAllCheckbox.html",
     "<input class=\"smart-table-select-all\"  type=\"checkbox\" ng-model=\"holder.isAllSelected\"/>");
 }]);
 
-angular.module("partials/selectionCheckbox.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/selectionCheckbox.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/selectionCheckbox.html",
     "<input type=\"checkbox\" ng-model=\"dataRow.isSelected\" stop-event=\"click\"/>");
 }]);
 
-angular.module("partials/smartTable.html", []).run(["$templateCache", function($templateCache) {
+angular.module("partials/smartTable.html", []).run(["$templateCache", function ($templateCache) {
   $templateCache.put("partials/smartTable.html",
     "<table class=\"smart-table\">\n" +
     "    <thead>\n" +
@@ -694,249 +725,248 @@ angular.module("partials/smartTable.html", []).run(["$templateCache", function($
 }]);
 
 (function (angular) {
-    "use strict";
-    angular.module('smartTable.templateUrlList', [])
-        .constant('templateUrlList', {
-            smartTable: 'partials/smartTable.html',
-            smartTableGlobalSearch: 'partials/globalSearchCell.html',
-            editableCell: 'partials/editableCell.html',
-            selectionCheckbox: 'partials/selectionCheckbox.html',
-            selectAllCheckbox: 'partials/selectAllCheckbox.html',
-            defaultHeader: 'partials/defaultHeader.html',
-            pagination: 'partials/pagination.html'
-        });
+  "use strict";
+  angular.module('smartTable.templateUrlList', [])
+    .constant('templateUrlList', {
+      smartTable: 'partials/smartTable.html',
+      smartTableGlobalSearch: 'partials/globalSearchCell.html',
+      editableCell: 'partials/editableCell.html',
+      selectionCheckbox: 'partials/selectionCheckbox.html',
+      selectAllCheckbox: 'partials/selectAllCheckbox.html',
+      defaultHeader: 'partials/defaultHeader.html',
+      pagination: 'partials/pagination.html'
+    });
 })(angular);
 
 
 (function (angular) {
-    "use strict";
-    angular.module('smartTable.utilities', [])
-
-        .factory('ArrayUtility', function () {
-
-            /**
-             * remove the item at index from arrayRef and return the removed item
-             * @param arrayRef
-             * @param index
-             * @returns {*}
-             */
-            var removeAt = function (arrayRef, index) {
-                    if (index >= 0 && index < arrayRef.length) {
-                        return arrayRef.splice(index, 1)[0];
-                    }
-                },
-
-                /**
-                 * insert item in arrayRef at index or a the end if index is wrong
-                 * @param arrayRef
-                 * @param index
-                 * @param item
-                 */
-                insertAt = function (arrayRef, index, item) {
-                    if (index >= 0 && index < arrayRef.length) {
-                        arrayRef.splice(index, 0, item);
-                    } else {
-                        arrayRef.push(item);
-                    }
-                },
-
-                /**
-                 * move the item at oldIndex to newIndex in arrayRef
-                 * @param arrayRef
-                 * @param oldIndex
-                 * @param newIndex
-                 */
-                moveAt = function (arrayRef, oldIndex, newIndex) {
-                    var elementToMove;
-                    if (oldIndex >= 0 && oldIndex < arrayRef.length && newIndex >= 0 && newIndex < arrayRef.length) {
-                        elementToMove = arrayRef.splice(oldIndex, 1)[0];
-                        arrayRef.splice(newIndex, 0, elementToMove);
-                    }
-                },
-
-                /**
-                 * sort arrayRef according to sortAlgorithm following predicate and reverse
-                 * @param arrayRef
-                 * @param sortAlgorithm
-                 * @param predicate
-                 * @param reverse
-                 * @returns {*}
-                 */
-                sort = function (arrayRef, sortAlgorithm, predicate, reverse) {
-
-                    if (!sortAlgorithm || !angular.isFunction(sortAlgorithm)) {
-                        return arrayRef;
-                    } else {
-                        return sortAlgorithm(arrayRef, predicate, reverse === true);//excpet if reverse is true it will take it as false
-                    }
-                },
-
-                /**
-                 * filter arrayRef according with filterAlgorithm and predicate
-                 * @param arrayRef
-                 * @param filterAlgorithm
-                 * @param predicate
-                 * @returns {*}
-                 */
-                filter = function (arrayRef, filterAlgorithm, predicate) {
-                    if (!filterAlgorithm || !angular.isFunction(filterAlgorithm)) {
-                        return arrayRef;
-                    } else {
-                        return filterAlgorithm(arrayRef, predicate);
-                    }
-                },
-
-                /**
-                 * return an array, part of array ref starting at min and the size of length
-                 * @param arrayRef
-                 * @param min
-                 * @param length
-                 * @returns {*}
-                 */
-                fromTo = function (arrayRef, min, length) {
-
-                    var out = [],
-                        limit,
-                        start;
-
-                    if (!angular.isArray(arrayRef)) {
-                        return arrayRef;
-                    }
-
-                    start = Math.max(min, 0);
-                    start = Math.min(start, (arrayRef.length - 1) > 0 ? arrayRef.length - 1 : 0);
-
-                    length = Math.max(0, length);
-                    limit = Math.min(start + length, arrayRef.length);
-
-                    for (var i = start; i < limit; i++) {
-                        out.push(arrayRef[i]);
-                    }
-                    return out;
-                };
+  "use strict";
+  angular.module('smartTable.utilities', [])
+
+    .factory('ArrayUtility', function () {
+
+      /**
+       * remove the item at index from arrayRef and return the removed item
+       * @param arrayRef
+       * @param index
+       * @returns {*}
+       */
+      var removeAt = function (arrayRef, index) {
+          if (index >= 0 && index < arrayRef.length) {
+            return arrayRef.splice(index, 1)[0];
+          }
+        },
+
+        /**
+         * insert item in arrayRef at index or a the end if index is wrong
+         * @param arrayRef
+         * @param index
+         * @param item
+         */
+        insertAt = function (arrayRef, index, item) {
+          if (index >= 0 && index < arrayRef.length) {
+            arrayRef.splice(index, 0, item);
+          } else {
+            arrayRef.push(item);
+          }
+        },
+
+        /**
+         * move the item at oldIndex to newIndex in arrayRef
+         * @param arrayRef
+         * @param oldIndex
+         * @param newIndex
+         */
+        moveAt = function (arrayRef, oldIndex, newIndex) {
+          var elementToMove;
+          if (oldIndex >= 0 && oldIndex < arrayRef.length && newIndex >= 0 && newIndex < arrayRef.length) {
+            elementToMove = arrayRef.splice(oldIndex, 1)[0];
+            arrayRef.splice(newIndex, 0, elementToMove);
+          }
+        },
+
+        /**
+         * sort arrayRef according to sortAlgorithm following predicate and reverse
+         * @param arrayRef
+         * @param sortAlgorithm
+         * @param predicate
+         * @param reverse
+         * @returns {*}
+         */
+        sort = function (arrayRef, sortAlgorithm, predicate, reverse) {
+
+          if (!sortAlgorithm || !angular.isFunction(sortAlgorithm)) {
+            return arrayRef;
+          } else {
+            return sortAlgorithm(arrayRef, predicate, reverse === true);//excpet if reverse is true it will take it as false
+          }
+        },
+
+        /**
+         * filter arrayRef according with filterAlgorithm and predicate
+         * @param arrayRef
+         * @param filterAlgorithm
+         * @param predicate
+         * @returns {*}
+         */
+        filter = function (arrayRef, filterAlgorithm, predicate) {
+          if (!filterAlgorithm || !angular.isFunction(filterAlgorithm)) {
+            return arrayRef;
+          } else {
+            return filterAlgorithm(arrayRef, predicate);
+          }
+        },
+
+        /**
+         * return an array, part of array ref starting at min and the size of length
+         * @param arrayRef
+         * @param min
+         * @param length
+         * @returns {*}
+         */
+        fromTo = function (arrayRef, min, length) {
+
+          var out = [],
+            limit,
+            start;
+
+          if (!angular.isArray(arrayRef)) {
+            return arrayRef;
+          }
+
+          start = Math.max(min, 0);
+          start = Math.min(start, (arrayRef.length - 1) > 0 ? arrayRef.length - 1 : 0);
+
+          length = Math.max(0, length);
+          limit = Math.min(start + length, arrayRef.length);
+
+          for (var i = start; i < limit; i++) {
+            out.push(arrayRef[i]);
+          }
+          return out;
+        };
 
 
-            return {
-                removeAt: removeAt,
-                insertAt: insertAt,
-                moveAt: moveAt,
-                sort: sort,
-                filter: filter,
-                fromTo: fromTo
-            };
-        });
+      return {
+        removeAt: removeAt,
+        insertAt: insertAt,
+        moveAt: moveAt,
+        sort: sort,
+        filter: filter,
+        fromTo: fromTo
+      };
+    });
 })(angular);
 
 
-
 (function (angular) {
-    angular.module('ui.bootstrap.pagination.smartTable', ['smartTable.templateUrlList'])
-
-        .constant('paginationConfig', {
-            boundaryLinks: false,
-            directionLinks: true,
-            firstText: 'First',
-            previousText: '<',
-            nextText: '>',
-            lastText: 'Last'
-        })
-
-        .directive('paginationSmartTable', ['paginationConfig', 'templateUrlList', function (paginationConfig, templateUrlList) {
+  angular.module('ui.bootstrap.pagination.smartTable', ['smartTable.templateUrlList'])
+
+    .constant('paginationConfig', {
+      boundaryLinks: false,
+      directionLinks: true,
+      firstText: 'First',
+      previousText: '<',
+      nextText: '>',
+      lastText: 'Last'
+    })
+
+    .directive('paginationSmartTable', ['paginationConfig', 'templateUrlList', function (paginationConfig, templateUrlList) {
+      return {
+        restrict: 'EA',
+        require: '^smartTable',
+        scope: {
+          numPages: '=',
+          currentPage: '=',
+          maxSize: '='
+        },
+        templateUrl: templateUrlList.pagination,
+        replace: true,
+        link: function (scope, element, attrs, ctrl) {
+
+          // Setup configuration parameters
+          var boundaryLinks = angular.isDefined(attrs.boundaryLinks) ? scope.$eval(attrs.boundaryLinks) : paginationConfig.boundaryLinks;
+          var directionLinks = angular.isDefined(attrs.directionLinks) ? scope.$eval(attrs.directionLinks) : paginationConfig.directionLinks;
+          var firstText = angular.isDefined(attrs.firstText) ? attrs.firstText : paginationConfig.firstText;
+          var previousText = angular.isDefined(attrs.previousText) ? attrs.previousText : paginationConfig.previousText;
+          var nextText = angular.isDefined(attrs.nextText) ? attrs.nextText : paginationConfig.nextText;
+          var lastText = angular.isDefined(attrs.lastText) ? attrs.lastText : paginationConfig.lastText;
+
+          // Create page object used in template
+          function makePage(number, text, isActive, isDisabled) {
             return {
-                restrict: 'EA',
-                require: '^smartTable',
-                scope: {
-                    numPages: '=',
-                    currentPage: '=',
-                    maxSize: '='
-                },
-                templateUrl: templateUrlList.pagination,
-                replace: true,
-                link: function (scope, element, attrs, ctrl) {
-
-                    // Setup configuration parameters
-                    var boundaryLinks = angular.isDefined(attrs.boundaryLinks) ? scope.$eval(attrs.boundaryLinks) : paginationConfig.boundaryLinks;
-                    var directionLinks = angular.isDefined(attrs.directionLinks) ? scope.$eval(attrs.directionLinks) : paginationConfig.directionLinks;
-                    var firstText = angular.isDefined(attrs.firstText) ? attrs.firstText : paginationConfig.firstText;
-                    var previousText = angular.isDefined(attrs.previousText) ? attrs.previousText : paginationConfig.previousText;
-                    var nextText = angular.isDefined(attrs.nextText) ? attrs.nextText : paginationConfig.nextText;
-                    var lastText = angular.isDefined(attrs.lastText) ? attrs.lastText : paginationConfig.lastText;
-
-                    // Create page object used in template
-                    function makePage(number, text, isActive, isDisabled) {
-                        return {
-                            number: number,
-                            text: text,
-                            active: isActive,
-                            disabled: isDisabled
-                        };
-                    }
-
-                    scope.$watch('numPages + currentPage + maxSize', function () {
-                        scope.pages = [];
-
-                        // Default page limits
-                        var startPage = 1, endPage = scope.numPages;
-
-                        // recompute if maxSize
-                        if (scope.maxSize && scope.maxSize < scope.numPages) {
-                            startPage = Math.max(scope.currentPage - Math.floor(scope.maxSize / 2), 1);
-                            endPage = startPage + scope.maxSize - 1;
-
-                            // Adjust if limit is exceeded
-                            if (endPage > scope.numPages) {
-                                endPage = scope.numPages;
-                                startPage = endPage - scope.maxSize + 1;
-                            }
-                        }
-
-                        // Add page number links
-                        for (var number = startPage; number <= endPage; number++) {
-                            var page = makePage(number, number, scope.isActive(number), false);
-                            scope.pages.push(page);
-                        }
-
-                        // Add previous & next links
-                        if (directionLinks) {
-                            var previousPage = makePage(scope.currentPage - 1, previousText, false, scope.noPrevious());
-                            scope.pages.unshift(previousPage);
-
-                            var nextPage = makePage(scope.currentPage + 1, nextText, false, scope.noNext());
-                            scope.pages.push(nextPage);
-                        }
-
-                        // Add first & last links
-                        if (boundaryLinks) {
-                            var firstPage = makePage(1, firstText, false, scope.noPrevious());
-                            scope.pages.unshift(firstPage);
-
-                            var lastPage = makePage(scope.numPages, lastText, false, scope.noNext());
-                            scope.pages.push(lastPage);
-                        }
-
-
-                        if (scope.currentPage > scope.numPages) {
-                            scope.selectPage(scope.numPages);
-                        }
-                    });
-                    scope.noPrevious = function () {
-                        return scope.currentPage === 1;
-                    };
-                    scope.noNext = function () {
-                        return scope.currentPage === scope.numPages;
-                    };
-                    scope.isActive = function (page) {
-                        return scope.currentPage === page;
-                    };
-
-                    scope.selectPage = function (page) {
-                        if (!scope.isActive(page) && page > 0 && page <= scope.numPages) {
-                            scope.currentPage = page;
-                            ctrl.changePage({ page: page });
-                        }
-                    };
-                }
+              number: number,
+              text: text,
+              active: isActive,
+              disabled: isDisabled
             };
-        }]);
+          }
+
+          scope.$watch('numPages + currentPage + maxSize', function () {
+            scope.pages = [];
+
+            // Default page limits
+            var startPage = 1, endPage = scope.numPages;
+
+            // recompute if maxSize
+            if (scope.maxSize && scope.maxSize < scope.numPages) {
+              startPage = Math.max(scope.currentPage - Math.floor(scope.maxSize / 2), 1);
+              endPage = startPage + scope.maxSize - 1;
+
+              // Adjust if limit is exceeded
+              if (endPage > scope.numPages) {
+                endPage = scope.numPages;
+                startPage = endPage - scope.maxSize + 1;
+              }
+            }
+
+            // Add page number links
+            for (var number = startPage; number <= endPage; number++) {
+              var page = makePage(number, number, scope.isActive(number), false);
+              scope.pages.push(page);
+            }
+
+            // Add previous & next links
+            if (directionLinks) {
+              var previousPage = makePage(scope.currentPage - 1, previousText, false, scope.noPrevious());
+              scope.pages.unshift(previousPage);
+
+              var nextPage = makePage(scope.currentPage + 1, nextText, false, scope.noNext());
+              scope.pages.push(nextPage);
+            }
+
+            // Add first & last links
+            if (boundaryLinks) {
+              var firstPage = makePage(1, firstText, false, scope.noPrevious());
+              scope.pages.unshift(firstPage);
+
+              var lastPage = makePage(scope.numPages, lastText, false, scope.noNext());
+              scope.pages.push(lastPage);
+            }
+
+
+            if (scope.currentPage > scope.numPages) {
+              scope.selectPage(scope.numPages);
+            }
+          });
+          scope.noPrevious = function () {
+            return scope.currentPage === 1;
+          };
+          scope.noNext = function () {
+            return scope.currentPage === scope.numPages;
+          };
+          scope.isActive = function (page) {
+            return scope.currentPage === page;
+          };
+
+          scope.selectPage = function (page) {
+            if (!scope.isActive(page) && page > 0 && page <= scope.numPages) {
+              scope.currentPage = page;
+              ctrl.changePage({page: page});
+            }
+          };
+        }
+      };
+    }]);
 })(angular);
 
diff --git a/rd_ui/app/scripts/services/resources.js b/rd_ui/app/scripts/services/resources.js
index da3bb31284..d7b5bd8a93 100644
--- a/rd_ui/app/scripts/services/resources.js
+++ b/rd_ui/app/scripts/services/resources.js
@@ -505,7 +505,32 @@
     var DataSourceResource = $resource('/api/data_sources/:id', {id: '@id'}, actions);
 
     return DataSourceResource;
-  }
+  };
+
+  var AlertSubscription = function ($resource) {
+    var resource = $resource('/api/alerts/:alertId/subscriptions/:userId', {alertId: '@alert_id', userId: '@user.id'});
+    return resource;
+  };
+
+  var Alert = function ($resource, $http) {
+    var actions = {
+      save: {
+        method: 'POST',
+        transformRequest: [function(data) {
+          var newData = _.extend({}, data);
+          if (newData.query_id === undefined) {
+            newData.query_id = newData.query.id;
+            delete newData.query;
+          }
+
+          return newData;
+        }].concat($http.defaults.transformRequest)
+      }
+    };
+    var resource = $resource('/api/alerts/:id', {id: '@id'}, actions);
+
+    return resource;
+  };
 
   var Widget = function ($resource, Query) {
     var WidgetResource = $resource('/api/widgets/:id', {id: '@id'});
@@ -532,5 +557,7 @@
       .factory('QueryResult', ['$resource', '$timeout', '$q', QueryResult])
       .factory('Query', ['$resource', 'QueryResult', 'DataSource', Query])
       .factory('DataSource', ['$resource', DataSource])
+      .factory('Alert', ['$resource', '$http', Alert])
+      .factory('AlertSubscription', ['$resource', AlertSubscription])
       .factory('Widget', ['$resource', 'Query', Widget]);
 })();
diff --git a/rd_ui/app/views/alerts/edit.html b/rd_ui/app/views/alerts/edit.html
new file mode 100644
index 0000000000..b016328327
--- /dev/null
+++ b/rd_ui/app/views/alerts/edit.html
@@ -0,0 +1,58 @@
+<div class="container">
+    <ol class="breadcrumb">
+        <li><a href="/alerts">Alerts</a></li>
+        <li class="active">{{alert.name || getDefaultName() || "New"}}</li>
+    </ol>
+    <div class="row">
+        <div class="col-md-8">
+            <form name="alertForm" ng-submit="saveChanges()" class="form">
+                <div class="form-group">
+                    <label>Query</label>
+                    <ui-select ng-model="alert.query" theme="bootstrap" reset-search-input="false" on-select="onQuerySelected($item)">
+                        <ui-select-match placeholder="Search a query by name">{{$select.selected.name}}</ui-select-match>
+                        <ui-select-choices repeat="q in queries"
+                                           refresh="searchQueries($select.search)"
+                                           refresh-delay="0">
+                            <div ng-bind-html="q.name | highlight: $select.search | trustAsHtml"></div>
+                        </ui-select-choices>
+                    </ui-select>
+                </div>
+
+                <div class="form-group" ng-show="selectedQuery">
+                    <label>Name</label>
+                    <input type="string" placeholder="{{getDefaultName()}}" class="form-control" ng-model="alert.name">
+                </div>
+
+                <div ng-show="queryResult" class="form-horizontal">
+                    <div class="form-group">
+                        <label class="control-label col-md-2">Value column</label>
+                        <div class="col-md-4">
+                            <select ng-options="name for name in queryResult.getColumnNames()" ng-model="alert.options.column" class="form-control"></select>
+                        </div>
+                        <label class="control-label col-md-2">Value</label>
+                        <div class="col-md-4">
+                            <p class="form-control-static">{{queryResult.getData()[0][alert.options.column]}}</p>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label class="control-label col-md-2">Op</label>
+                        <div class="col-md-4">
+                            <select ng-options="name for name in ops" ng-model="alert.options.op" class="form-control"></select>
+                        </div>
+                        <label class="control-label col-md-2">Reference</label>
+                        <div class="col-md-4">
+                            <input type="number" class="form-control" ng-model="alert.options.value" placeholder="reference value" required/>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <button class="btn btn-primary" ng-disabled="!alertForm.$valid">Save</button>
+                </div>
+            </form>
+        </div>
+        <div class="col-md-4" ng-if="alert.id">
+            <alert-subscribers alert-id="alert.id"></alert-subscribers>
+        </div>
+    </div>
+</div>
\ No newline at end of file
diff --git a/rd_ui/app/views/alerts/list.html b/rd_ui/app/views/alerts/list.html
new file mode 100644
index 0000000000..980e0980f7
--- /dev/null
+++ b/rd_ui/app/views/alerts/list.html
@@ -0,0 +1,16 @@
+<div class="container">
+    <ol class="breadcrumb">
+        <li class="active">Alerts</li>
+    </ol>
+    <div class="row">
+        <div class="col-md-12">
+            <p>
+                <a href="/alerts/new" class="btn btn-default"><i class="fa fa-plus"></i> New Alert</a>
+            </p>
+
+            <smart-table rows="alerts" columns="gridColumns"
+                         config="gridConfig"
+                         class="table table-condensed table-hover"></smart-table>
+        </div>
+    </div>
+</div>
\ No newline at end of file
diff --git a/rd_ui/app/views/alerts/subscribers.html b/rd_ui/app/views/alerts/subscribers.html
new file mode 100644
index 0000000000..f6f3d1a8cc
--- /dev/null
+++ b/rd_ui/app/views/alerts/subscribers.html
@@ -0,0 +1,4 @@
+<div>
+    <strong>Subscribers</strong> <subscribe-button alert-id="alertId" subscribers="subscribers"></subscribe-button><br/>
+    <img ng-src="{{s.user.gravatar_url}}" class="img-circle" alt="{{s.user.name}}" ng-repeat="s in subscribers"/>
+</div>
diff --git a/rd_ui/bower.json b/rd_ui/bower.json
index 364ed100d4..36582f6856 100644
--- a/rd_ui/bower.json
+++ b/rd_ui/bower.json
@@ -25,12 +25,12 @@
     "marked": "~0.3.2",
     "bucky": "~0.2.6",
     "pace": "~0.5.1",
-    "angular-ui-select": "0.8.2",
+    "angular-ui-select": "~0.12.0",
     "font-awesome": "~4.2.0",
     "mustache": "~1.0.0",
     "canvg": "gabelerner/canvg",
     "angular-ui-bootstrap-bower": "~0.12.1",
-    "leaflet":"~0.7.3"
+    "leaflet": "~0.7.3"
   },
   "devDependencies": {
     "angular-mocks": "1.2.18",
diff --git a/redash/__init__.py b/redash/__init__.py
index 8cb15e69af..54d20c3449 100644
--- a/redash/__init__.py
+++ b/redash/__init__.py
@@ -2,6 +2,7 @@
 import urlparse
 import redis
 from statsd import StatsClient
+from flask_mail import Mail
 
 from redash import settings
 from redash.query_runner import import_query_runners
@@ -32,6 +33,8 @@ def create_redis_connection():
 
 setup_logging()
 redis_connection = create_redis_connection()
+mail = Mail()
+mail.init_mail(settings.all_settings())
 statsd_client = StatsClient(host=settings.STATSD_HOST, port=settings.STATSD_PORT, prefix=settings.STATSD_PREFIX)
 
 import_query_runners(settings.QUERY_RUNNERS)
diff --git a/redash/admin.py b/redash/admin.py
index 7144b8c7a0..493748eac2 100644
--- a/redash/admin.py
+++ b/redash/admin.py
@@ -53,7 +53,8 @@ def process_formdata(self, valuelist):
 class PgModelConverter(CustomModelConverter):
     def __init__(self, view, additional=None):
         additional = {ArrayField: self.handle_array_field,
-                      DateTimeTZField: self.handle_datetime_tz_field}
+                      DateTimeTZField: self.handle_datetime_tz_field,
+                      }
         super(PgModelConverter, self).__init__(view, additional)
         self.view = view
 
@@ -104,13 +105,8 @@ class DataSourceModelView(BaseModelView):
 def init_admin(app):
     admin = Admin(app, name='re:dash admin')
 
-    views = {
-        models.User: UserModelView(models.User),
-        models.DataSource: DataSourceModelView(models.DataSource)
-    }
+    admin.add_view(UserModelView(models.User))
+    admin.add_view(DataSourceModelView(models.DataSource))
 
-    for m in models.all_models:
-        if m in views:
-            admin.add_view(views[m])
-        else:
-            admin.add_view(BaseModelView(m))
+    for m in (models.QueryResult, models.Query, models.Dashboard, models.Visualization, models.Widget, models.ActivityLog, models.Group, models.Event):
+        admin.add_view(BaseModelView(m))
diff --git a/redash/controllers.py b/redash/controllers.py
index b0c8ac084d..20aafaf77e 100644
--- a/redash/controllers.py
+++ b/redash/controllers.py
@@ -13,8 +13,9 @@
 
 from flask import render_template, send_from_directory, make_response, request, jsonify, redirect, \
     session, url_for, current_app, flash
-from flask.ext.restful import Resource, abort
+from flask.ext.restful import Resource, abort, reqparse
 from flask_login import current_user, login_user, logout_user, login_required
+from funcy import project
 import sqlparse
 
 from redash import statsd_client, models, settings, utils
@@ -33,6 +34,8 @@ def ping():
 
 @app.route('/admin/<anything>')
 @app.route('/dashboard/<anything>')
+@app.route('/alerts')
+@app.route('/alerts/<pk>')
 @app.route('/queries')
 @app.route('/queries/<query_id>')
 @app.route('/queries/<query_id>/<anything>')
@@ -575,6 +578,105 @@ def delete(self, job_id):
 
 api.add_resource(JobAPI, '/api/jobs/<job_id>', endpoint='job')
 
+
+class AlertAPI(BaseResource):
+    def get(self, alert_id):
+        alert = models.Alert.get_by_id(alert_id)
+        return alert.to_dict()
+
+    def post(self, alert_id):
+        req = request.get_json(True)
+        params = project(req, ('options', 'name', 'query_id'))
+        alert = models.Alert.get_by_id(alert_id)
+        if 'query_id' in params:
+            params['query'] = params.pop('query_id')
+
+        alert.update_instance(**params)
+
+        record_event.delay({
+            'user_id': self.current_user.id,
+            'action': 'edit',
+            'timestamp': int(time.time()),
+            'object_id': alert.id,
+            'object_type': 'alert'
+        })
+
+        return alert.to_dict()
+
+
+class AlertListAPI(BaseResource):
+    def post(self):
+        req = request.get_json(True)
+        required_fields = ('options', 'name', 'query_id')
+        for f in required_fields:
+            if f not in req:
+                abort(400)
+
+        alert = models.Alert.create(
+            name=req['name'],
+            query=req['query_id'],
+            user=self.current_user,
+            options=req['options']
+        )
+
+        record_event.delay({
+            'user_id': self.current_user.id,
+            'action': 'create',
+            'timestamp': int(time.time()),
+            'object_id': alert.id,
+            'object_type': 'alert'
+        })
+
+        # TODO: should be in model?
+        models.AlertSubscription.create(alert=alert, user=self.current_user)
+
+        record_event.delay({
+            'user_id': self.current_user.id,
+            'action': 'subscribe',
+            'timestamp': int(time.time()),
+            'object_id': alert.id,
+            'object_type': 'alert'
+        })
+
+        return alert.to_dict()
+
+    def get(self):
+        return [alert.to_dict() for alert in models.Alert.all()]
+
+
+class AlertSubscriptionListResource(BaseResource):
+    def post(self, alert_id):
+        subscription = models.AlertSubscription.create(alert=alert_id, user=self.current_user)
+        record_event.delay({
+            'user_id': self.current_user.id,
+            'action': 'subscribe',
+            'timestamp': int(time.time()),
+            'object_id': alert_id,
+            'object_type': 'alert'
+        })
+        return subscription.to_dict()
+
+    def get(self, alert_id):
+        subscriptions = models.AlertSubscription.all(alert_id)
+        return [s.to_dict() for s in subscriptions]
+
+
+class AlertSubscriptionResource(BaseResource):
+    def delete(self, alert_id, subscriber_id):
+        models.AlertSubscription.unsubscribe(alert_id, subscriber_id)
+        record_event.delay({
+            'user_id': self.current_user.id,
+            'action': 'unsubscribe',
+            'timestamp': int(time.time()),
+            'object_id': alert_id,
+            'object_type': 'alert'
+        })
+
+api.add_resource(AlertAPI, '/api/alerts/<alert_id>', endpoint='alert')
+api.add_resource(AlertSubscriptionListResource, '/api/alerts/<alert_id>/subscriptions', endpoint='alert_subscriptions')
+api.add_resource(AlertSubscriptionResource, '/api/alerts/<alert_id>/subscriptions/<subscriber_id>', endpoint='alert_subscription')
+api.add_resource(AlertListAPI, '/api/alerts', endpoint='alerts')
+
 @app.route('/<path:filename>')
 def send_static(filename):
     if current_app.debug:
@@ -583,7 +685,3 @@ def send_static(filename):
         cache_timeout = None
 
     return send_from_directory(settings.STATIC_ASSETS_PATH, filename, cache_timeout=cache_timeout)
-
-
-if __name__ == '__main__':
-    app.run(debug=True)
diff --git a/redash/models.py b/redash/models.py
index 3f9a43daf7..f10e221f23 100644
--- a/redash/models.py
+++ b/redash/models.py
@@ -77,6 +77,17 @@ def save(self, *args, **kwargs):
         super(BaseModel, self).save(*args, **kwargs)
         self.post_save(created)
 
+    def update_instance(self, **kwargs):
+        for k, v in kwargs.items():
+            # setattr(model_instance, field_name, field_obj.python_value(value))
+            setattr(self, k, v)
+
+        dirty_fields = self.dirty_fields
+        if hasattr(self, 'updated_at'):
+            dirty_fields = dirty_fields + [self.__class__.updated_at]
+
+        self.save(only=dirty_fields)
+
 
 class ModelTimestampsMixin(BaseModel):
     updated_at = DateTimeTZField(default=datetime.datetime.now)
@@ -163,6 +174,7 @@ def to_dict(self):
             'id': self.id,
             'name': self.name,
             'email': self.email,
+            'gravatar_url': self.gravatar_url,
             'updated_at': self.updated_at,
             'created_at': self.created_at
         }
@@ -177,6 +189,11 @@ def pre_save(self, created):
         if not self.api_key:
             self.api_key = generate_token(40)
 
+    @property
+    def gravatar_url(self):
+        email_md5 = hashlib.md5(self.email.lower()).hexdigest()
+        return "https://www.gravatar.com/avatar/%s?s=40" % email_md5
+
     @property
     def permissions(self):
         # TODO: this should be cached.
@@ -280,6 +297,13 @@ def query_runner(self):
     def all(cls):
         return cls.select().order_by(cls.id.asc())
 
+class JSONField(peewee.TextField):
+    def db_value(self, value):
+        return json.dumps(value)
+
+    def python_value(self, value):
+        return json.loads(value)
+
 
 class QueryResult(BaseModel):
     id = peewee.PrimaryKeyField()
@@ -338,13 +362,17 @@ def store_result(cls, data_source_id, query_hash, query, data, run_time, retriev
 
         logging.info("Inserted query (%s) data; id=%s", query_hash, query_result.id)
 
-        updated_count = Query.update(latest_query_data=query_result).\
-            where(Query.query_hash==query_hash, Query.data_source==data_source_id).\
-            execute()
+        sql = "UPDATE queries SET latest_query_data_id = %s WHERE query_hash = %s AND data_source_id = %s RETURNING id"
+        query_ids = [row[0] for row in db.database.execute_sql(sql, params=(query_result.id, query_hash, data_source_id))]
+
+        # TODO: when peewee with update & returning support is released, we can get back to using this code:
+        # updated_count = Query.update(latest_query_data=query_result).\
+        #     where(Query.query_hash==query_hash, Query.data_source==data_source_id).\
+        #     execute()
 
-        logging.info("Updated %s queries with result (%s).", updated_count, query_hash)
+        logging.info("Updated %s queries with result (%s).", len(query_ids), query_hash)
 
-        return query_result
+        return query_result, query_ids
 
     def __unicode__(self):
         return u"%d | %s | %s" % (self.id, self.query_hash, self.retrieved_at)
@@ -527,6 +555,83 @@ def __unicode__(self):
         return unicode(self.id)
 
 
+class Alert(ModelTimestampsMixin, BaseModel):
+    UNKNOWN_STATE = 'unknown'
+    OK_STATE = 'ok'
+    TRIGGERED_STATE = 'triggered'
+
+    id = peewee.PrimaryKeyField()
+    name = peewee.CharField()
+    query = peewee.ForeignKeyField(Query, related_name='alerts')
+    user = peewee.ForeignKeyField(User, related_name='alerts')
+    options = JSONField()
+    state = peewee.CharField(default=UNKNOWN_STATE)
+    last_triggered_at = DateTimeTZField(null=True)
+
+    class Meta:
+        db_table = 'alerts'
+
+    @classmethod
+    def all(cls):
+        return cls.select(Alert, User, Query).join(Query).switch(Alert).join(User)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'query': self.query.to_dict(),
+            'user': self.user.to_dict(),
+            'options': self.options,
+            'state': self.state,
+            'last_triggered_at': self.last_triggered_at,
+            'updated_at': self.updated_at,
+            'created_at': self.created_at
+        }
+
+    def evaluate(self):
+        data = json.loads(self.query.latest_query_data.data)
+        # todo: safe guard for empty
+        value = data['rows'][0][self.options['column']]
+        op = self.options['op']
+
+        if op == 'greater than' and value > self.options['value']:
+            new_state = self.TRIGGERED_STATE
+        elif op == 'less than' and value < self.options['value']:
+            new_state = self.TRIGGERED_STATE
+        elif op == 'equals' and value == self.options['value']:
+            new_state = self.TRIGGERED_STATE
+        else:
+            new_state = self.OK_STATE
+
+        return new_state
+
+    def subscribers(self):
+        return User.select().join(AlertSubscription).where(AlertSubscription.alert==self)
+
+
+class AlertSubscription(ModelTimestampsMixin, BaseModel):
+    user = peewee.ForeignKeyField(User)
+    alert = peewee.ForeignKeyField(Alert)
+
+    class Meta:
+        db_table = 'alert_subscriptions'
+
+    def to_dict(self):
+        return {
+            'user': self.user.to_dict(),
+            'alert_id': self._data['alert']
+        }
+
+    @classmethod
+    def all(cls, alert_id):
+        return AlertSubscription.select(AlertSubscription, User).join(User).where(AlertSubscription.alert==alert_id)
+
+    @classmethod
+    def unsubscribe(cls, alert_id, user_id):
+        query = AlertSubscription.delete().where(AlertSubscription.alert==alert_id).where(AlertSubscription.user==user_id)
+        return query.execute()
+
+
 class Dashboard(ModelTimestampsMixin, BaseModel):
     id = peewee.PrimaryKeyField()
     slug = peewee.CharField(max_length=140, index=True)
@@ -716,7 +821,7 @@ def record(cls, event):
         return event
 
 
-all_models = (DataSource, User, QueryResult, Query, Dashboard, Visualization, Widget, ActivityLog, Group, Event)
+all_models = (DataSource, User, QueryResult, Query, Alert, Dashboard, Visualization, Widget, ActivityLog, Group, Event)
 
 
 def init_db():
diff --git a/redash/settings.py b/redash/settings.py
index e4a93c1f35..70b9ac72a1 100644
--- a/redash/settings.py
+++ b/redash/settings.py
@@ -40,6 +40,17 @@ def parse_boolean(str):
     return json.loads(str.lower())
 
 
+def all_settings():
+    from types import ModuleType
+
+    settings = {}
+    for name, item in globals().iteritems():
+        if not callable(item) and not name.startswith("__") and not isinstance(item, ModuleType):
+            settings[name] = item
+
+    return settings
+
+
 NAME = os.environ.get('REDASH_NAME', 're:dash')
 
 REDIS_URL = os.environ.get('REDASH_REDIS_URL', "redis://localhost:6379/0")
@@ -81,6 +92,19 @@ def parse_boolean(str):
 CLIENT_SIDE_METRICS = parse_boolean(os.environ.get("REDASH_CLIENT_SIDE_METRICS", "false"))
 ANALYTICS = os.environ.get("REDASH_ANALYTICS", "")
 
+# Mail settings:
+MAIL_SERVER = os.environ.get('REDASH_MAIL_SERVER', 'localhost')
+MAIL_PORT = int(os.environ.get('REDASH_MAIL_PORT', 25))
+MAIL_USE_TLS = parse_boolean(os.environ.get('REDASH_MAIL_USE_TLS', 'false'))
+MAIL_USE_SSL = parse_boolean(os.environ.get('REDASH_MAIL_USE_SSL', 'false'))
+MAIL_USERNAME = os.environ.get('REDASH_MAIL_USERNAME', None)
+MAIL_PASSWORD = os.environ.get('REDASH_MAIL_PASSWORD', None)
+MAIL_DEFAULT_SENDER = os.environ.get('REDASH_MAIL_DEFAULT_SENDER', None)
+MAIL_MAX_EMAILS = os.environ.get('REDASH_MAIL_MAX_EMAILS', None)
+MAIL_ASCII_ATTACHMENTS = parse_boolean(os.environ.get('REDASH_MAIL_ASCII_ATTACHMENTS', 'false'))
+
+HOST = ""
+
 # CORS settings for the Query Result API (and possbily future external APIs).
 # In most cases all you need to do is set REDASH_CORS_ACCESS_CONTROL_ALLOW_ORIGIN
 # to the calling domain (or domains in a comma separated list).
diff --git a/redash/tasks.py b/redash/tasks.py
index 9091f02c86..4693957d88 100644
--- a/redash/tasks.py
+++ b/redash/tasks.py
@@ -1,10 +1,11 @@
 import time
 import logging
+from flask.ext.mail import Message
 import redis
 from celery import Task
 from celery.result import AsyncResult
 from celery.utils.log import get_task_logger
-from redash import redis_connection, models, statsd_client, settings, utils
+from redash import redis_connection, models, statsd_client, settings, utils, mail
 from redash.utils import gen_query_hash
 from redash.worker import celery
 from redash.query_runner import get_query_runner
@@ -222,7 +223,7 @@ def cleanup_query_results():
 @celery.task(base=BaseTask)
 def refresh_schemas():
     """
-    Refershs the datasources schema.
+    Refreshs the datasources schema.
     """
 
     for ds in models.DataSource.all():
@@ -230,6 +231,39 @@ def refresh_schemas():
         ds.get_schema(refresh=True)
 
 
+@celery.task(bind=True, base=BaseTask)
+def check_alerts_for_query(self, query_id):
+    from redash.wsgi import app
+
+    logger.debug("Checking query %d for alerts", query_id)
+    query = models.Query.get_by_id(query_id)
+    for alert in query.alerts:
+        alert.query = query
+        new_state = alert.evaluate()
+        if new_state != alert.state:
+            logger.info("Alert %d new state: %s", alert.id, new_state)
+            old_state = alert.state
+            alert.update_instance(state=new_state)
+
+            if old_state == models.Alert.UNKNOWN_STATE and new_state == models.Alert.OK_STATE:
+                logger.debug("Skipping notification (previous state was unknown and now it's ok).")
+                continue
+
+            # message = Message
+            recipients = [s.email for s in alert.subscribers()]
+            logger.debug("Notifying: %s", recipients)
+            html = """
+            Check <a href="{host}/alerts/{alert_id}">alert</a> / check <a href="{host}/queries/{query_id}">query</a>.
+            """.format(host=settings.HOST, alert_id=alert.id, query_id=query.id)
+
+            with app.app_context():
+                message = Message(recipients=recipients,
+                                  subject="[{1}] {0}".format(alert.name, new_state.upper()),
+                                  html=html)
+
+                mail.send(message)
+
+
 @celery.task(bind=True, base=BaseTask, track_started=True)
 def execute_query(self, query, data_source_id, metadata):
     start_time = time.time()
@@ -271,7 +305,9 @@ def execute_query(self, query, data_source_id, metadata):
     redis_connection.delete(QueryTask._job_lock_id(query_hash, data_source.id))
 
     if not error:
-        query_result = models.QueryResult.store_result(data_source.id, query_hash, query, data, run_time, utils.utcnow())
+        query_result, updated_query_ids = models.QueryResult.store_result(data_source.id, query_hash, query, data, run_time, utils.utcnow())
+        for query_id in updated_query_ids:
+            check_alerts_for_query.delay(query_id)
     else:
         raise Exception(error)
 
diff --git a/redash/wsgi.py b/redash/wsgi.py
index 56d2180b1b..c8f461bf31 100644
--- a/redash/wsgi.py
+++ b/redash/wsgi.py
@@ -3,7 +3,7 @@
 from werkzeug.wrappers import Response
 from flask.ext.restful import Api
 
-from redash import settings, utils
+from redash import settings, utils, mail
 from redash.models import db
 from redash.admin import init_admin
 
@@ -22,7 +22,9 @@
 # configure our database
 settings.DATABASE_CONFIG.update({'threadlocals': True})
 app.config['DATABASE'] = settings.DATABASE_CONFIG
+app.config.update(settings.all_settings())
 db.init_app(app)
+mail.init_app(app)
 
 from redash.authentication import setup_authentication
 setup_authentication(app)
diff --git a/requirements.txt b/requirements.txt
index 355e2deea7..9aafa2e3c6 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,6 +3,7 @@ Flask-Admin==1.1.0
 Flask-RESTful==0.2.10
 Flask-Login==0.2.11
 Flask-OAuth==0.12
+flask-mail==0.9.1
 passlib==1.6.2
 Jinja2==2.7.2
 MarkupSafe==0.18
@@ -29,4 +30,5 @@ click==3.3
 RestrictedPython==3.6.0
 wtf-peewee==0.2.3
 pysaml2==2.4.0
-pycrypto==2.6.1
\ No newline at end of file
+pycrypto==2.6.1
+funcy==1.5
diff --git a/tests/test_models.py b/tests/test_models.py
index 0b0ec734f9..fb6abc94c4 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -164,7 +164,7 @@ def test_archive_query_sets_flag(self):
     def test_archived_query_doesnt_return_in_all(self):
         query = query_factory.create(schedule="1")
         yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
-        query_result = models.QueryResult.store_result(query.data_source.id, query.query_hash, query.query, "1",
+        query_result, _ = models.QueryResult.store_result(query.data_source.id, query.query_hash, query.query, "1",
                                                        123, yesterday)
 
         query.latest_query_data = query_result
@@ -329,7 +329,7 @@ def setUp(self):
         self.data = "data"
 
     def test_stores_the_result(self):
-        query_result = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query,
+        query_result, _ = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query,
                                                           self.data, self.runtime, self.utcnow)
 
         self.assertEqual(query_result.data, self.data)
@@ -344,7 +344,7 @@ def test_updates_existing_queries(self):
         query2 = query_factory.create(query=self.query, data_source=self.data_source)
         query3 = query_factory.create(query=self.query, data_source=self.data_source)
 
-        query_result = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
+        query_result, _ = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
                                                        self.runtime, self.utcnow)
 
         self.assertEqual(models.Query.get_by_id(query1.id)._data['latest_query_data'], query_result.id)
@@ -356,7 +356,7 @@ def test_doesnt_update_queries_with_different_hash(self):
         query2 = query_factory.create(query=self.query, data_source=self.data_source)
         query3 = query_factory.create(query=self.query + "123", data_source=self.data_source)
 
-        query_result = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
+        query_result, _ = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
                                                        self.runtime, self.utcnow)
 
         self.assertEqual(models.Query.get_by_id(query1.id)._data['latest_query_data'], query_result.id)
@@ -368,7 +368,7 @@ def test_doesnt_update_queries_with_different_data_source(self):
         query2 = query_factory.create(query=self.query, data_source=self.data_source)
         query3 = query_factory.create(query=self.query, data_source=data_source_factory.create())
 
-        query_result = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
+        query_result, _ = models.QueryResult.store_result(self.data_source.id, self.query_hash, self.query, self.data,
                                                        self.runtime, self.utcnow)
 
         self.assertEqual(models.Query.get_by_id(query1.id)._data['latest_query_data'], query_result.id)