angleGrinder.forms.min.js

(function() {
    var forms;
    angular.module("ui.bootstrap.datepicker").config([ "$provide", function($provide) {
        return $provide.decorator("daypickerDirective", function($delegate) {
            var directive, oldCompile;
            directive = $delegate[0];
            oldCompile = directive.compile;
            directive.compile = function() {
                var link;
                link = oldCompile.apply(this, arguments);
                return function(scope) {
                    link.apply(this, arguments);
                    return scope.$watch("rows", function() {
                        return angular.forEach(scope.rows, function(row) {
                            if (_.every(row, function(dt) {
                                return dt.secondary;
                            })) {
                                return _.map(row, function(dt) {
                                    return dt.hide = true;
                                });
                            }
                        });
                    });
                };
            };
            return $delegate;
        });
    } ]);
    forms = angular.module("angleGrinder.forms", [ "ui.bootstrap", "xeditable", "angleGrinder.common" ]);
    forms.run([ "datepickerConfig", "datepickerPopupConfig", function(datepickerConfig, datepickerPopupConfig) {
        datepickerConfig.showWeeks = false;
        datepickerConfig.formatDay = "d";
        return datepickerPopupConfig.showButtonBar = false;
    } ]);
    forms.run([ "$templateCache", function($templateCache) {
        $templateCache.put("template/pagination/pagination.html", '<div class="pagination">\n  <ul>\n    <li ng-class="{disabled: noPrevious(), previous: align}">\n      <a href ng-click="selectPage(page - 1)">{{getText(\'previous\')}}</a>\n    </li>\n\n    <li ng-repeat="page in pages" ng-class="{active: page.active, disabled: page.disabled}">\n      <a ng-click="selectPage(page.number)">{{page.text}}</a>\n    </li>\n\n    <li ng-class="{disabled: noNext(), next: align}">\n      <a href ng-click="selectPage(page + 1)">{{getText(\'next\')}}</a>\n    </li>\n  </ul>\n</div>');
        $templateCache.put("template/datepicker/day.html", '<table role="grid" aria-labelledby="{{uniqueId}}-title" aria-activedescendant="{{activeDateId}}">\n  <thead>\n    <tr>\n      <th style="cursor: pointer;" ng-click="move(-1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-left"></i></span></th>\n      <th style="cursor: pointer;" ng-click="toggleMode()" colspan="{{5 + showWeeks}}">\n        <span id="{{uniqueId}}-title" role="heading" aria-live="assertive" aria-atomic="true" tabindex="-1" style="width:100%;"><strong>{{title}}</strong></span>\n      </th>\n      <th style="cursor: pointer;" ng-click="move(1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-right"></i></span></th>\n    </tr>\n    <tr>\n      <th ng-show="showWeeks" class="text-center"></th>\n      <th ng-repeat="label in labels track by $index" class="text-center"><small aria-label="{{label.full}}">{{label.abbr}}</small></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr ng-repeat="row in rows track by $index">\n      <td ng-show="showWeeks" class="text-center h6"><em>{{ weekNumbers[$index] }}</em></td>\n\n      <td ng-hide="dt.hide" style="width: 30px; cursor: pointer;" ng-click="select(dt.date)" ng-repeat="dt in row track by dt.date" class="text-center" role="gridcell" id="{{dt.uid}}" aria-disabled="{{!!dt.disabled}}">\n        <span ng-class="{\'label label-info\': dt.selected, \'label label-default\': isActive(dt), \'muted\': dt.secondary, \'text-info\': dt.current}"\n              ng-disabled="dt.disabled" tabindex="-1">\n          {{dt.label}}\n        </span>\n      </td>\n    </tr>\n  </tbody>\n</table>');
        $templateCache.put("template/datepicker/month.html", '<table role="grid" aria-labelledby="{{uniqueId}}-title" aria-activedescendant="{{activeDateId}}">\n  <thead>\n    <tr>\n      <th style="cursor: pointer;" ng-click="move(-1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-left"></i></span></th>\n      <th style="cursor: pointer;" ng-click="toggleMode()"><span id="{{uniqueId}}-title" role="heading" aria-live="assertive" aria-atomic="true" type="button" tabindex="-1" style="width:100%;"><strong>{{title}}</strong></span></th>\n      <th style="cursor: pointer;" ng-click="move(1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-right"></i></span></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr ng-repeat="row in rows track by $index">\n      <td style="width: 100px; cursor: pointer;" ng-click="select(dt.date)" ng-repeat="dt in row track by dt.date" class="text-center" role="gridcell" id="{{dt.uid}}" aria-disabled="{{!!dt.disabled}}">\n        <span ng-class="{\'label label-info\': dt.selected, \'label label-default\': isActive(dt), \'text-info\': dt.current}"\n              ng-disabled="dt.disabled" tabindex="-1">\n          {{dt.label}}\n        </span>\n      </td>\n    </tr>\n  </tbody>\n</table>');
        return $templateCache.put("template/datepicker/year.html", '<table role="grid" aria-labelledby="{{uniqueId}}-title" aria-activedescendant="{{activeDateId}}">\n  <thead>\n    <tr>\n      <th style="cursor: pointer;" ng-click="move(-1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-left"></i></span></th>\n      <th style="cursor: pointer;" ng-click="toggleMode()" colspan="3"><span id="{{uniqueId}}-title" role="heading" aria-live="assertive" aria-atomic="true" tabindex="-1" style="width:100%;"><strong>{{title}}</strong></span></th>\n      <th style="cursor: pointer;" ng-click="move(1)"><span tabindex="-1"><i class="glyphicon glyphicon-chevron-right"></i></span></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr ng-repeat="row in rows track by $index">\n      <td style="width: 50px; cursor: pointer;" ng-click="select(dt.date)" ng-repeat="dt in row track by dt.date" class="text-center" role="gridcell" id="{{dt.uid}}" aria-disabled="{{!!dt.disabled}}">\n        <span ng-class="{\'label label-info\': dt.selected, \'label label-default\': isActive(dt), \'text-info\': dt.current}"\n              ng-disabled="dt.disabled" tabindex="-1">\n          {{dt.label}}\n        </span>\n      </td>\n    </tr>\n  </tbody>\n</table>');
    } ]);
}).call(this);

(function() {
    var app;
    app = angular.module("angleGrinder.forms");
    app.directive("editableCustom", [ "editableDirectiveFactory", function(editableDirectiveFactory) {
        var compile, result;
        result = editableDirectiveFactory({
            "directiveName": "editableCustom"
        });
        compile = result.compile;
        result.compile = function(element) {
            var link, templateEl, tpl;
            templateEl = element.next("[editable-custom-template]");
            tpl = templateEl.html();
            templateEl.remove();
            compile.apply(this, arguments);
            link = result.link;
            return function(scope, element, attrs, ctrl) {
                var eCtrl;
                eCtrl = ctrl[0];
                eCtrl.inputTpl = tpl;
                return link.apply(this, arguments);
            };
        };
        return result;
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("editableDatepicker", [ "editableDirectiveFactory", function(editableDirectiveFactory) {
        return editableDirectiveFactory({
            "directiveName": "editableDatepicker",
            "inputTpl": '<input type="text" ng-model="$data" datepicker-popup="MM/dd/yyyy" is-open="opened">',
            "render": function() {
                var div;
                this.parent.render.call(this);
                div = angular.element('<div class="input-prepend"></div>');
                this.inputEl.wrap(div);
                return this.inputEl.after('<button type="button" class="btn btn-default" ng-click="open($event)">\n  <i class="icon-calendar"></i>\n</button>');
            },
            "init": function() {
                this.parent.init.call(this);
                this.scope.opened = false;
                return this.scope.open = function(_this) {
                    return function($event) {
                        $event.preventDefault();
                        $event.stopPropagation();
                        return _this.scope.opened = true;
                    };
                }(this);
            }
        });
    } ]);
}).call(this);

(function() {
    var app;
    app = angular.module("angleGrinder.forms");
    app.directive("editableFormButtons", [ "$parse", function($parse) {
        return {
            "restrict": "A",
            "scope": true,
            "link": function(scope, element, attrs) {
                return scope.form = $parse(attrs.editableFormButtons)(scope);
            },
            "template": '<div class="buttons">\n  <button type="button" class="btn btn-default"\n          ng-click="form.$show()"\n          ng-if="!form.$visible">\n    Edit\n  </button>\n\n  <span ng-if="form.$visible">\n    <button type="submit" class="btn btn-primary"\n            ng-disabled="form.$invalid || form.$waiting">\n      Save\n    </button>\n\n    <button type="button" class="btn btn-default"\n            ng-disabled="form.$waiting"\n            ng-click="form.$cancel()">\n      Cancel\n    </button>\n  </span>\n</div>'
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("editableSelect2", [ "editableDirectiveFactory", function(editableDirectiveFactory) {
        return editableDirectiveFactory({
            "directiveName": "editableSelect2",
            "inputTpl": '<input type="hidden" ng-model="$data" />'
        });
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.config([ "$provide", function($provide) {
        return $provide.decorator("editableDirectiveFactory", [ "$delegate", "validationMessages", function($delegate, validationMessages) {
            var errorsFor;
            errorsFor = function(model) {
                var callback;
                callback = function(result, invalid, error) {
                    if (invalid) {
                        result.push(validationMessages[error]);
                    }
                    return result;
                };
                return _.reduce(model.$error, callback, []).join(", ");
            };
            return function() {
                var directive, link;
                directive = $delegate.apply(this, arguments);
                link = directive.link;
                directive.compile = function(element, attrs) {
                    return function(scope, element, attrs, ctrl) {
                        var form, name, viewValue;
                        link.apply(this, arguments);
                        form = ctrl[1];
                        name = attrs.eName;
                        if (form != null && name != null) {
                            viewValue = function() {
                                var _ref;
                                return (_ref = form[name]) != null ? _ref.$viewValue : void 0;
                            };
                            return scope.$watch(viewValue, function() {
                                var model;
                                model = form[name];
                                if (model != null ? model.$invalid : void 0) {
                                    form.$setError(name, errorsFor(model));
                                }
                                if (model != null ? model.$valid : void 0) {
                                    return form.$setError(name, "");
                                }
                            });
                        }
                    };
                };
                return directive;
            };
        } ]);
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agDeleteButton", function() {
        return {
            "restrict": "E",
            "replace": true,
            "scope": {
                "whenConfirmed": "&"
            },
            "controller": [ "$scope", function($scope) {
                $scope.confirmation = false;
                $scope.showConfirmation = function() {
                    return $scope.confirmation = true;
                };
                return $scope.doDelete = function() {
                    var promise;
                    $scope.confirmation = false;
                    promise = $scope.whenConfirmed();
                    $scope.deleting = true;
                    return promise != null ? typeof promise["finally"] === "function" ? promise["finally"](function() {
                        return $scope.deleting = false;
                    }) : void 0 : void 0;
                };
            } ],
            "template": '<button type="button"\n        class="btn ag-delete-button"\n        ng-class="{ true: \'btn-warning\', false: \'btn-danger\' }[confirmation]"\n        ng-disabled="deleting"\n        ng-mouseleave="confirmation = false"\n        ng-click="confirmation ? doDelete() : showConfirmation()">\n  <i class="icon-trash"></i>\n\n  <ng-switch on="confirmation">\n    <span ng-switch-default>Delete</span>\n    <span ng-switch-when="true">Are you sure?</span>\n  </ng-switch>\n\n  <span ng-if="deleting">...</span>\n</button>'
        };
    });
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agSubmit", [ "$parse", "$log", "serverValidationErrorsHandler", function($parse, $log, serverValidationErrorsHandler) {
        return {
            "restrict": "A",
            "require": "form",
            "compile": function(element, attrs) {
                var markAsSubmitted, onSubmit;
                onSubmit = $parse(attrs.agSubmit);
                markAsSubmitted = function(form) {
                    var nestedForm, nestedForms, _i, _len, _results;
                    form.$submitted = true;
                    nestedForms = _.filter(_.values(form), function(input) {
                        return input instanceof form.constructor;
                    });
                    _results = [];
                    for (_i = 0, _len = nestedForms.length; _i < _len; _i++) {
                        nestedForm = nestedForms[_i];
                        _results.push(markAsSubmitted(nestedForm));
                    }
                    return _results;
                };
                return function(scope, element, attrs, formCtrl) {
                    return element.on("submit", function(event) {
                        var promise, resource, result;
                        $log.debug("[forms] submitting form", formCtrl.$name, element, formCtrl);
                        scope.$apply(function() {
                            return markAsSubmitted(formCtrl);
                        });
                        if (formCtrl.$invalid) {
                            return;
                        }
                        result = _.flatten([ onSubmit(scope, {
                            "$event": event
                        }) ]);
                        promise = result[0], resource = result[1];
                        if (promise && angular.isObject(promise)) {
                            formCtrl.$saving = true;
                            promise["finally"](function() {
                                return formCtrl.$saving = false;
                            });
                            promise.then(function() {
                                formCtrl.$setPristine();
                                return formCtrl.$submitted = false;
                            });
                            return promise["catch"](function(response) {
                                if (!angular.isFunction(resource != null ? resource.resourceName : void 0)) {
                                    return;
                                }
                                return serverValidationErrorsHandler(formCtrl, response, resource.resourceName());
                            });
                        }
                    });
                };
            }
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agSubmitButton", function() {
        return {
            "restrict": "E",
            "replace": true,
            "scope": true,
            "require": "^form",
            "link": function(scope, element, attrs, formCtrl) {
                var isSaving;
                isSaving = function() {
                    return formCtrl.$saving;
                };
                return scope.$watch(isSaving, function(saving) {
                    return scope.saving = saving;
                });
            },
            "template": '<button type="submit" class="btn btn-primary"\n        ng-disabled="saving">\n  <i class="icon-ok icon-white"></i> Save<span ng-show="saving">...</span>\n</button>'
        };
    });
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agDatepicker", [ "$compile", function($compile) {
        return {
            "restrict": "A",
            "replace": true,
            "scope": true,
            "transclude": true,
            "controller": [ "$scope", "$rootScope", function($scope, $rootScope) {
                $scope.opened = false;
                $scope.open = function($event) {
                    $event.preventDefault();
                    $event.stopPropagation();
                    $scope.opened = true;
                    return $rootScope.$broadcast("ag:closeOtherPickers", $scope.$id);
                };
                return $rootScope.$on("ag:closeOtherPickers", function(event, otherId) {
                    if ($scope.$id !== otherId) {
                        return $scope.opened = false;
                    }
                });
            } ],
            "compile": function(element, attrs, transclude) {
                return function(scope, element) {
                    return transclude(scope, function(clone) {
                        clone.attr("datepicker-popup", "MM/dd/yyyy");
                        clone.attr("is-open", "opened");
                        return $compile(clone)(scope, function(clone) {
                            return element.prepend(clone);
                        });
                    });
                };
            },
            "template": '<div class="input-append ag-datepicker">\n\n  <button type="button" class="btn btn-default" ng-click="open($event)">\n    <i class="icon-calendar"></i>\n  </button>\n</div>'
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agCreateButton", function() {
        return {
            "restrict": "E",
            "replace": true,
            "transclude": true,
            "compile": function(element, attrs, trasclude) {
                return {
                    "pre": function(scope, element) {
                        return trasclude(scope, function(clone) {
                            if ($.trim(clone.text()) === "") {
                                return element.append("Create");
                            }
                        });
                    }
                };
            },
            "template": '<a href="" class="btn">\n  <i class="icon-edit"></i>\n  <span ng-transclude></span>\n</a>'
        };
    });
    forms.directive("agCancelButton", function() {
        return {
            "restrict": "E",
            "replace": true,
            "template": '<button type="button" class="btn">\n  <i class="icon-remove"></i> Cancel\n</button>'
        };
    });
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.value("validationMessages", {
        "required": "This field is required",
        "mismatch": "Does not match the confirmation",
        "minlength": "This field is too short",
        "maxlength": "This field is too long",
        "email": "Invalid email address",
        "pattern": "Invalid pattern"
    });
    forms.directive("match", [ "isEmpty", function(isEmpty) {
        return {
            "require": "ngModel",
            "link": function(scope, elem, attrs, modelCtrl) {
                var validateEqual, validator;
                validateEqual = function(value, otherValue) {
                    var allEmpty, valid;
                    allEmpty = _.all([ isEmpty(value), isEmpty(otherValue) ]);
                    valid = allEmpty || value === otherValue;
                    modelCtrl.$setValidity("mismatch", valid);
                    return value;
                };
                scope.$watch(attrs.match, function(otherValue) {
                    return validateEqual(modelCtrl.$viewValue, otherValue);
                });
                validator = function(value) {
                    var otherValue;
                    otherValue = scope.$eval(attrs.match);
                    return validateEqual(value, otherValue);
                };
                modelCtrl.$parsers.unshift(validator);
                return modelCtrl.$formatters.unshift(validator);
            }
        };
    } ]);
    forms.directive("agFieldGroup", [ "$timeout", "$log", function($timeout, $log) {
        return {
            "restrict": "A",
            "require": "^form",
            "replace": true,
            "transclude": true,
            "template": '<div class="control-group" ng-transclude></div>',
            "link": function(scope, element, attrs, formCtrl) {
                var fields, isSubmitted, toggleErrors;
                fields = (attrs["for"] || "").split(",");
                toggleErrors = function() {
                    return $timeout(function() {
                        var invalid;
                        invalid = _.map(fields, function(field) {
                            var _ref, _ref1;
                            return ((_ref = formCtrl[field]) != null ? _ref.$invalid : void 0) || ((_ref1 = formCtrl.$serverErrors) != null ? _ref1[field] : void 0);
                        });
                        if (_.any(invalid)) {
                            return element.addClass("error");
                        } else {
                            return element.removeClass("error");
                        }
                    });
                };
                angular.forEach(fields, function(field) {
                    var getViewValue;
                    getViewValue = function() {
                        var _ref;
                        return (_ref = formCtrl[field]) != null ? _ref.$viewValue : void 0;
                    };
                    return scope.$watch(getViewValue, function() {
                        var _ref;
                        if (!((_ref = formCtrl[field]) != null ? _ref.$dirty : void 0)) {
                            return;
                        }
                        return toggleErrors();
                    });
                });
                angular.forEach(fields, function(field) {
                    var getServerErrors, initial;
                    initial = true;
                    getServerErrors = function() {
                        var _ref;
                        return (_ref = formCtrl.$serverErrors) != null ? _ref[field] : void 0;
                    };
                    return scope.$watch(getServerErrors, function() {
                        if (!initial) {
                            toggleErrors();
                        }
                        return initial = false;
                    });
                });
                isSubmitted = function() {
                    return formCtrl.$submitted;
                };
                return scope.$watch(isSubmitted, function(submitted) {
                    if (!submitted) {
                        return;
                    }
                    return toggleErrors();
                });
            }
        };
    } ]);
    forms.directive("agValidationErrors", [ "validationMessages", function(validationMessages) {
        return {
            "restrict": "E",
            "require": "^form",
            "replace": true,
            "link": function(scope, element, attrs, formCtrl) {
                var appendError, clearErrors, displayErrorMessages, field, fieldName, getServerErrors, getViewValue, initial, isSubmitted, isValid, messageFor;
                fieldName = attrs["for"];
                field = formCtrl[fieldName];
                clearErrors = function() {
                    return element.html("");
                };
                messageFor = function(error) {
                    return attrs[error] || validationMessages[error];
                };
                appendError = function(message, klass) {
                    if (klass == null) {
                        klass = "";
                    }
                    return element.append('<span class="help-inline ' + klass + '">' + message + "</span>");
                };
                displayErrorMessages = function() {
                    var error, invalid, message, _ref, _results;
                    clearErrors();
                    _ref = field.$error;
                    _results = [];
                    for (error in _ref) {
                        invalid = _ref[error];
                        if (!invalid) {
                            continue;
                        }
                        message = messageFor(error);
                        if (message != null) {
                            _results.push(appendError(message));
                        } else {
                            _results.push(void 0);
                        }
                    }
                    return _results;
                };
                initial = true;
                isValid = function() {
                    var _ref;
                    return (_ref = formCtrl[fieldName]) != null ? _ref.$valid : void 0;
                };
                scope.$watch(isValid, function() {
                    if (!initial) {
                        displayErrorMessages();
                    }
                    return initial = false;
                });
                getViewValue = function() {
                    var _ref;
                    return (_ref = formCtrl[fieldName]) != null ? _ref.$viewValue : void 0;
                };
                scope.$watch(getViewValue, function() {
                    if (field.$dirty) {
                        return displayErrorMessages();
                    }
                });
                isSubmitted = function() {
                    return formCtrl.$submitted;
                };
                scope.$watch(isSubmitted, function(submitted) {
                    if (submitted) {
                        return displayErrorMessages();
                    }
                });
                getServerErrors = function() {
                    var _ref;
                    return (_ref = formCtrl.$serverErrors) != null ? _ref[fieldName] : void 0;
                };
                return scope.$watch(getServerErrors, function(serverError) {
                    if (serverError != null) {
                        return appendError(serverError, "server-error");
                    } else {
                        return element.find(".server-error").remove();
                    }
                });
            }
        };
    } ]);
    forms.directive("agServerValidationErrors", function() {
        return {
            "restrict": "A",
            "require": "^form",
            "link": function(scope, element, attrs, formCtrl) {
                var getServerErrors;
                formCtrl.$serverErrors = {};
                getServerErrors = function() {
                    return formCtrl.$serverErrors;
                };
                return scope.$watch(getServerErrors, function(serverErrors) {
                    return angular.forEach(serverErrors, function(_, field) {
                        var getViewValue, unregister;
                        getViewValue = function() {
                            var _ref;
                            return (_ref = formCtrl[field]) != null ? _ref.$viewValue : void 0;
                        };
                        return unregister = scope.$watch(getViewValue, function(oldVal, newVal) {
                            var _ref;
                            if (oldVal === newVal) {
                                return;
                            }
                            if ((_ref = formCtrl[field]) != null) {
                                _ref.$setValidity("server", true);
                            }
                            formCtrl.$serverErrors[field] = null;
                            return unregister();
                        });
                    });
                });
            }
        };
    });
    forms.factory("serverValidationErrorsHandler", [ "$log", function($log) {
        var setErrors;
        setErrors = function(form, errors) {
            var field, message, _ref, _results;
            form.$serverErrors = {};
            _results = [];
            for (field in errors) {
                message = errors[field];
                if (typeof message === "object" && form[field] != null) {
                    setErrors(form[field], message);
                }
                if (typeof message === "string") {
                    if ((_ref = form[field]) != null) {
                        _ref.$setValidity("server", false);
                    }
                    _results.push(form.$serverErrors[field] = message);
                } else {
                    _results.push(void 0);
                }
            }
            return _results;
        };
        return function(form, response, resourceName) {
            var errors, _ref, _ref1;
            errors = (_ref = response.data) != null ? (_ref1 = _ref.errors) != null ? _ref1[resourceName] : void 0 : void 0;
            if (response.status !== 422 || errors == null) {
                $log.warn("Response does not contain validation errors", response);
                return;
            }
            return setErrors(form, errors);
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.factory("focus", [ "$rootScope", "$timeout", function($rootScope, $timeout) {
        return function(name) {
            return $timeout(function() {
                return $rootScope.$broadcast("focusOn", name);
            });
        };
    } ]);
    forms.directive("agFocus", function() {
        return {
            "restrict": "A",
            "link": function(scope, element, attributes) {
                var currentName;
                currentName = attributes.agFocus;
                return scope.$on("focusOn", function(event, name) {
                    if (currentName === name) {
                        element.addClass("ag-focused");
                        return element[0].focus();
                    }
                });
            }
        };
    });
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.factory("massUpdateHandler", [ "$log", function($log) {
        return function(grid, result) {
            var error, id, row, _i, _len, _ref, _ref1, _results;
            $log.info("[forms] Mass update response", result);
            if (result.data != null) {
                _ref = result.data;
                for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                    row = _ref[_i];
                    grid.updateRow(row.id, row);
                }
            } else {
                $log.warn("[forms] Invalid JSON response, missing data array");
            }
            if (result.errors != null) {
                _ref1 = result.errors;
                _results = [];
                for (id in _ref1) {
                    error = _ref1[id];
                    _results.push(grid.flashOnError(id));
                }
                return _results;
            } else {
                return $log.warn("[forms] Invalid JSON response, missing errors assoc array");
            }
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.factory("formDialog", [ "$modal", "pathWithContext", function($modal, pathWithContext) {
        return {
            "open": function(templateUrl, dialogOptions) {
                if (dialogOptions == null) {
                    dialogOptions = {};
                }
                return $modal.open({
                    "templateUrl": pathWithContext(templateUrl),
                    "controller": "FormDialogCtrl",
                    "keyboard": false,
                    "backdrop": "static",
                    "resolve": {
                        "dialogOptions": function() {
                            return dialogOptions;
                        }
                    }
                });
            }
        };
    } ]);
}).call(this);

(function() {
    var FormDialogCtrl, forms, __bind = function(fn, me) {
        return function() {
            return fn.apply(me, arguments);
        };
    }, __hasProp = {}.hasOwnProperty, __extends = function(child, parent) {
        for (var key in parent) {
            if (__hasProp.call(parent, key)) child[key] = parent[key];
        }
        function ctor() {
            this.constructor = child;
        }
        ctor.prototype = parent.prototype;
        child.prototype = new ctor();
        child.__super__ = parent.prototype;
        return child;
    };
    forms = angular.module("angleGrinder.forms");
    FormDialogCtrl = function(_super) {
        __extends(FormDialogCtrl, _super);
        function FormDialogCtrl() {
            this["delete"] = __bind(this["delete"], this);
            this.save = __bind(this.save, this);
            this.closeDialog = __bind(this.closeDialog, this);
            return FormDialogCtrl.__super__.constructor.apply(this, arguments);
        }
        FormDialogCtrl.register(forms, "FormDialogCtrl");
        FormDialogCtrl.inject("$scope", "$rootScope", "$log", "$modalInstance", "dialogOptions");
        FormDialogCtrl.prototype.initialize = function() {
            var resourceName, _ref;
            this.$scope.dialogOptions = this.dialogOptions;
            _ref = this.$scope.dialogOptions, this.record = _ref.record, this.grid = _ref.grid;
            resourceName = angular.isFunction(this.record.resourceName) ? this.record.resourceName() : "record";
            this.$scope[resourceName] = this.record;
            return this.expose(this.$scope, "closeDialog", "save", "delete");
        };
        FormDialogCtrl.prototype.closeDialog = function() {
            this.$log.info("[ag] closing the dialog");
            return this.$modalInstance.close(this.record);
        };
        FormDialogCtrl.prototype.save = function(record) {
            var promise;
            promise = record.save().$promise;
            promise.then(function(_this) {
                return function(record) {
                    _this.$log.info("[ag] record has been updated/created", record);
                    _this.grid.saveRow(record.id, record);
                    return _this.$scope.closeDialog();
                };
            }(this));
            return [ promise, record ];
        };
        FormDialogCtrl.prototype["delete"] = function() {
            var promise;
            promise = this.record["delete"]().$promise;
            promise.then(function(_this) {
                return function(response) {
                    _this.$log.info("[ag] record has been deleted", response);
                    _this.grid.removeRow(response.id);
                    return _this.$scope.closeDialog();
                };
            }(this));
            promise["catch"](function(_this) {
                return function(response) {
                    return _this.$log.error("[ag] something went wrong", response);
                };
            }(this));
            return promise;
        };
        return FormDialogCtrl;
    }(BaseCtrl);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.directive("agTabset", [ "$parse", "$q", function($parse, $q) {
        return {
            "restrict": "E",
            "replace": true,
            "transclude": true,
            "scope": true,
            "require": "agTabset",
            "controller": [ "$log", "$scope", "$location", function($log, $scope, $location) {
                $scope.tabs = [];
                $scope.contentLoading = false;
                $scope.currentTab = function() {
                    return _.findWhere($scope.tabs, {
                        "selected": true
                    });
                };
                $scope.currentTemplateUrl = function() {
                    var currentTab;
                    currentTab = $scope.currentTab();
                    if (currentTab) {
                        return currentTab.tplSrc;
                    }
                };
                $scope.contentLoaded = function() {
                    var tab;
                    $scope.contentLoading = false;
                    tab = $scope.currentTab();
                    tab.loading = false;
                    if (tab.name != null) {
                        $location.search("tab", tab.name);
                    }
                    return $log.debug("[tabs] content loaded", tab);
                };
                this.openTab = function(name) {
                    var deferred, tab, unregister;
                    deferred = $q.defer();
                    tab = _.findWhere($scope.tabs, {
                        "name": name
                    });
                    if (tab == null) {
                        return deferred.promise;
                    }
                    if (!tab.selected) {
                        this._selectTab(tab);
                    }
                    unregister = tab.$watch("loading", function(loading) {
                        if (loading) {
                            return;
                        }
                        deferred.resolve(tab);
                        return unregister();
                    });
                    return deferred.promise;
                };
                this._selectTab = function(tab) {
                    angular.forEach($scope.tabs, function(tab) {
                        return tab.selected = tab.loading = false;
                    });
                    tab.selected = true;
                    tab.loading = true;
                    return $scope.contentLoading = true;
                };
                this._addTab = function(tab, select) {
                    if (select == null) {
                        select = false;
                    }
                    $scope.tabs.push(tab);
                    if (select || $scope.tabs.length === 1) {
                        return this._selectTab(tab);
                    }
                };
            } ],
            "link": function(scope, element, attrs, ctrl) {
                var alias;
                alias = attrs.name;
                if (alias) {
                    return $parse(alias).assign(scope.$parent, ctrl);
                }
            },
            "template": '<div class="container">\n  <div class="nav nav-tabs" ng-transclude></div>\n  <div class="tab container">\n    <span ng-if="contentLoading">loading the content</span>\n    <ng-include src="currentTemplateUrl()"\n                onload="contentLoaded()"\n                ng-hide="contentLoading"></ng-include>\n  </div>\n</div>'
        };
    } ]);
    forms.directive("agTab", [ "$log", "$location", "pathWithContext", function($log, $location, pathWithContext) {
        return {
            "restrict": "E",
            "replace": true,
            "require": "^agTabset",
            "transclude": true,
            "scope": {
                "templateUrl": "@",
                "name": "@"
            },
            "link": function(scope, element, attrs, tabsetCtrl) {
                var active;
                scope.tplSrc = pathWithContext(scope.templateUrl);
                scope.selected = false;
                scope.loading = false;
                active = function() {
                    return scope.name != null && $location.search().tab === scope.name;
                };
                tabsetCtrl._addTab(scope, active());
                return scope.select = function() {
                    if (scope.selected) {
                        return;
                    }
                    return tabsetCtrl._selectTab(scope);
                };
            },
            "template": '<li ng-click="select()" ng-class="{active: selected, loading: loading}">\n  <a href="" ng-transclude>{{heading}}</a>\n</li>'
        };
    } ]);
}).call(this);

(function() {
    var forms;
    forms = angular.module("angleGrinder.forms");
    forms.value("getRealPanelHeight", function(el) {
        var bodyEl, height, oldHeight;
        bodyEl = el.find(".panel-body:visible");
        oldHeight = bodyEl.height();
        bodyEl.css("min-height", "auto");
        height = el.height();
        bodyEl.css("min-height", oldHeight);
        return height;
    });
    forms.directive("agPanelsRow", [ "getRealPanelHeight", function(getHeight) {
        return {
            "restrict": "C",
            "controller": function() {
                this.panels = [];
                this.registerPanel = function(el) {
                    return this.panels.push($(el));
                };
                this.maxHeight = function() {
                    var highest;
                    highest = _.max(this.panels, function(el) {
                        return getHeight(el);
                    });
                    return getHeight(highest);
                };
                this.allEqual = function() {
                    var heights;
                    heights = _.chain(this.panels).map(function(el) {
                        return getHeight(el);
                    }).value();
                    return _.all(heights, function(height) {
                        return height === heights[0];
                    });
                };
                this.equalize = function() {
                    var maxHeight;
                    if (this.allEqual()) {
                        return;
                    }
                    maxHeight = this.maxHeight();
                    return angular.forEach(this.panels, function(el) {
                        var bodyEl, paddings;
                        bodyEl = el.find(".panel-body");
                        paddings = parseInt(bodyEl.css("padding-top")) + parseInt(bodyEl.css("padding-bottom"));
                        paddings += el.find(".panel-heading").outerHeight();
                        paddings += el.find(".panel-footer").outerHeight();
                        return bodyEl.css("min-height", maxHeight - paddings);
                    });
                };
                return this;
            }
        };
    } ]);
    forms.directive("agPanel", [ "getRealPanelHeight", function(getHeight) {
        return {
            "restrict": "C",
            "require": "^agPanelsRow",
            "link": function(scope, element, attrs, ctrl) {
                var elementHeight;
                ctrl.registerPanel(element);
                elementHeight = function() {
                    return getHeight(element);
                };
                return scope.$watch(elementHeight, function() {
                    return ctrl.equalize();
                });
            }
        };
    } ]);
}).call(this);

(function() {
    var app;
    app = angular.module("angleGrinder.forms");
    app.service("select2Options", function() {
        return function(options, dataOptions) {
            var ajax, defaults;
            if (options == null) {
                options = {};
            }
            if (dataOptions == null) {
                dataOptions = {};
            }
            options.ajax || (options.ajax = {});
            defaults = {
                "width": "element",
                "initSelection": angular.noop,
                "ajax": {
                    "dataType": "json",
                    "url": angular.noop,
                    "data": function(term, page) {
                        var dataDefaults;
                        if (page == null) {
                            page = 1;
                        }
                        dataDefaults = {
                            "q": term,
                            "sort": "id",
                            "order": "asc",
                            "max": 20,
                            "page": page
                        };
                        return angular.extend(dataDefaults, dataOptions);
                    },
                    "results": function(result, page) {
                        return {
                            "results": result.rows,
                            "more": page < result.total
                        };
                    }
                },
                "formatResult": function(record) {
                    return record.name;
                },
                "formatSelection": function(record) {
                    return record.name;
                }
            };
            ajax = angular.extend(defaults.ajax, options.ajax);
            options = angular.extend(defaults, options);
            options.ajax = ajax;
            return options;
        };
    });
}).call(this);

(function() {
    var mixin;
    mixin = angular.module("angleGrinder.forms");
    mixin.factory("dialogCrudCtrlMixin", [ "$log", "$parse", "formDialog", "confirmationDialog", function($log, $parse, formDialog, confirmationDialog) {
        return function($scope, options) {
            var Resource, extraDialogOptions, getGrid, gridName, openEditDialogFor, templateUrl;
            if (options == null) {
                options = {};
            }
            Resource = options.Resource, gridName = options.gridName, templateUrl = options.templateUrl, 
            extraDialogOptions = options.extraDialogOptions;
            getGrid = function() {
                return $parse(gridName)($scope);
            };
            openEditDialogFor = function(record) {
                var dialogOptions;
                dialogOptions = {
                    "record": record,
                    "grid": getGrid()
                };
                return formDialog.open(templateUrl, _.extend(dialogOptions, extraDialogOptions));
            };
            $scope.editRecord = function(id) {
                return Resource.get({
                    "id": id
                }, function(record) {
                    if (options.beforeEdit != null) {
                        record = options.beforeEdit(record);
                    }
                    return openEditDialogFor(record);
                });
            };
            $scope.createRecord = function() {
                var record;
                record = new Resource();
                if (options.beforeCreate != null) {
                    record = options.beforeCreate(record);
                }
                return openEditDialogFor(record);
            };
            return $scope.deleteRecord = function(id) {
                return confirmationDialog.open().result.then(function(confirmed) {
                    var promise;
                    if (!confirmed) {
                        return;
                    }
                    promise = Resource["delete"]({
                        "id": id
                    }).$promise;
                    promise.then(function(record) {
                        return getGrid().removeRow(record.id);
                    });
                    promise["catch"](function(response) {
                        return $log.error("Cannot delete a resource", response);
                    });
                    return promise;
                });
            };
        };
    } ]);
}).call(this);

(function() {
    var mixin;
    mixin = angular.module("angleGrinder.forms");
    mixin.factory("singlePageCrudCtrlMixin", [ "$log", "$location", "dialogCrudCtrlMixin", function($log, $location, dialogCrudCtrlMixin) {
        return function($scope, args) {
            var Resource, gridName, resourcePath;
            if (args == null) {
                args = {};
            }
            resourcePath = args.resourcePath, gridName = args.gridName, Resource = args.Resource;
            dialogCrudCtrlMixin($scope, {
                "gridName": gridName,
                "Resource": Resource
            });
            $scope.createRecord = angular.noop;
            $scope.showRecord = function(id) {
                var showRecordPath;
                showRecordPath = [ resourcePath, id ].join("/");
                return $location.path(showRecordPath);
            };
            return $scope.editRecord = function(id) {
                var editRecordPath;
                editRecordPath = [ resourcePath, id, "edit" ].join("/");
                return $location.path(editRecordPath);
            };
        };
    } ]);
}).call(this);

(function() {
    var mixin;
    mixin = angular.module("angleGrinder.forms");
    mixin.factory("massUpdateFormCtrlMixin", [ "$log", "massUpdateHandler", function($log, massUpdateHandler) {
        return function($scope, args) {
            var Resource, beforeSave, dialog, grid, selectedIds;
            if (args == null) {
                args = {};
            }
            dialog = args.dialog, Resource = args.Resource, selectedIds = args.selectedIds, 
            grid = args.grid, beforeSave = args.beforeSave;
            $scope.massUpdate = function(records) {
                var data, params, promise;
                data = angular.copy(records);
                $log.info("[forms] mass update", data);
                if (angular.isFunction(beforeSave)) {
                    data = beforeSave(data);
                }
                params = {
                    "ids": selectedIds,
                    "data": data
                };
                promise = Resource.massUpdate(params).$promise;
                return promise.then(function(result) {
                    massUpdateHandler(grid, result);
                    $scope.closeDialog();
                    return result;
                });
            };
            return $scope.closeDialog = function() {
                $log.info("[forms] closing the mass update dialog");
                return dialog.close();
            };
        };
    } ]);
}).call(this);

(function() {
    var mixin;
    mixin = angular.module("angleGrinder.forms");
    mixin.factory("massUpdateMixin", [ "$log", "$parse", "$modal", "pathWithContext", function($log, $parse, $modal, pathWithContext) {
        return function($scope, args) {
            var controller, extraParams, gridName, templateUrl;
            if (args == null) {
                args = {};
            }
            gridName = args.gridName, templateUrl = args.templateUrl, controller = args.controller, 
            extraParams = args.extraParams;
            if (controller == null) {
                controller = "MassUpdateFormCtrl";
            }
            return $scope.massUpdate = function() {
                var grid, selectedIds;
                grid = $parse(gridName)($scope);
                if (grid == null) {
                    throw new Error("the grid is not defined");
                }
                selectedIds = grid.getSelectedRowIds();
                if (selectedIds.length === 0) {
                    return;
                }
                return $modal.open({
                    "templateUrl": pathWithContext(templateUrl),
                    "controller": controller,
                    "keyboard": false,
                    "backdrop": "static",
                    "resolve": {
                        "selectedIds": function() {
                            return selectedIds;
                        },
                        "grid": function() {
                            return grid;
                        },
                        "extraParams": function() {
                            return extraParams;
                        }
                    }
                });
            };
        };
    } ]);
}).call(this);