var app = angular.module('plunker', ["xeditable"]);
app.controller('MainCtrl', function($scope) {
$scope.data = {
principalStaffHoursWrapper: {
name: "One, Coordinator",
userId: 1782,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "0.50",
notes: ""
},
{
phase: "Post-Review",
hours: "0.25",
notes: ""
},
{
phase: "Follow-up",
hours: "0.50",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
},
userListStaffHoursWrapper: [
{
name: "BAKER, DAWN A",
userId: 23,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "0.50",
notes: ""
},
{
phase: "Post-Review",
hours: "0.75",
notes: ""
},
{
phase: "Follow-up",
hours: "0.50",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
},
{
name: "DOLPHIN, DERRICK E",
userId: 168,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "1.50",
notes: ""
},
{
phase: "Post-Review",
hours: "0.00",
notes: ""
},
{
phase: "Follow-up",
hours: "0.00",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
},
{
name: "HAYES, ALYSSA V",
userId: 271,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "1.25",
notes: ""
},
{
phase: "Post-Review",
hours: "0.00",
notes: ""
},
{
phase: "Follow-up",
hours: "0.00",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
},
{
name: "LOMETZ, ALEXIS V",
userId: 389,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "0.75",
notes: ""
},
{
phase: "Post-Review",
hours: "0.00",
notes: ""
},
{
phase: "Follow-up",
hours: "0.00",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
}
],
otherUserStaffHoursWrapper: {
name: "Other",
userId: 99999,
staffHoursPhaseWrapperList: [
{
phase: "Pre-Review",
hours: "0.00",
notes: ""
},
{
phase: "Post-Review",
hours: "0.00",
notes: ""
},
{
phase: "Follow-up",
hours: "0.00",
notes: ""
},
{
phase: "Final Action",
hours: "0.00",
notes: ""
}
]
}
}
var currentUser = [];
var otherUser = [];
var userList;
currentUser[0] = $scope.data.principalStaffHoursWrapper;
otherUser[0] = $scope.data.otherUserStaffHoursWrapper;
userList =$scope.data.userListStaffHoursWrapper;
$scope.currentUser = currentUser;
$scope.users = userList;
$scope.otherUser = otherUser;
});
<!DOCTYPE html>
<html ng-app="plunker">
<head>
<meta charset="utf-8" />
<title>AngularJS Plunker</title>
<script data-require="jquery@*" data-semver="2.1.3" src="https://code.jquery.com/jquery-2.1.3.min.js"></script>
<script data-require="angular.js@1.6.2" data-semver="1.6.2" src="https://code.angularjs.org/1.6.2/angular.js"></script>
<script src="https://vitalets.github.io/angular-xeditable/dist/js/xeditable.js"></script>
<link rel="stylesheet" href="style.css" />
<link rel="stylesheet" href="https://vitalets.github.io/angular-xeditable/dist/css/xeditable.css" />
<script src="app.js"></script>
<script src="staff-hours.directive.js"></script>
</head>
<body ng-controller="MainCtrl">
<div data-ng-repeat="user in currentUser">
<staff-hours user="user" is-current="true"></staff-hours>
</div>
<div data-ng-repeat="user in users">
<staff-hours user="user"></staff-hours>
</div>
<div data-ng-repeat="user in otherUser">
<staff-hours user="user"></staff-hours>
</div>
</body>
</html>
/* Put your css in here */
input.ng-invalid {
background:#F84072;
border: 2px red solid;
}
angular.module('plunker')
.directive("staffHours", function(){
return {
restrict: "EA",
templateUrl: 'my-directive.html',
scope: {
user: '=',
isCurrent: '='
},
controller:function($filter, $scope){
$scope.onlyNumbersPattern = /^[0-9]\d*(\.\d+)?$/;
$scope.updateHours = updateHours;
$scope.updateNotes = updateNotes;
$scope.getPhaseHours = getPhaseHours;
$scope.phaseMins = [
{value: '.00'},
{value: '.25'},
{value: '.50'},
{value: '.75'}
];
$scope.phase_Mins = $scope.phaseMins[0].value;
function getPhaseHours(phase) {
$scope.previousPhaseHours = phase.hours;
}
function updateHours(minutes, phase) {
console.log("test");
}
function updateNotes(notes, phase) {
console.log("test");
}
function updateTotals(previousPhaseHours, phaseHours) {
console.log("test");
}
}
};
});
<div class="table-staff-travel mb10">
<table class="table table-hover table-small table-simple editable">
<thead>
<tr>
<th>{{user.name}}</th>
<th>Total Hours</th>
</tr>
</thead>
<tbody>
<tr data-ng-repeat="phase in user.staffHoursPhaseWrapperList">
<td>{{phase.phase}}</td>
<td>
<div class="table-inline-group">
<div class="text-left col-md-9">
<div class="text-left col-md-5">
<div e-form="editableHours{{$index}}" e-clickable="true" editable-text="phase.hours" e-step="any" e-name="Hours" e-min="0" ng-click="this.form.$show()" e-ng-pattern="onlyNumbersPattern">
{{phase.hours}}
</div>
</div>
<div class="text-left col-md-3" ng-show="editableHours{{$index}}.$visible">
<a href="#" e-form="editableHours{{$index}}" editable-select="phase_Mins" onaftersave="updateHours($data, phase)" e-name="Hours" e-ng-options="m.value as m.value for m in phaseMins">
{{phase_Mins}}
</a>
</div>
</div>
</div>
</td>
</tr>
</tbody>
</table>
</div>
/*!
angular-xeditable - 0.1.9
Edit-in-place for angular.js
Build date: 2015-03-26
*/
/**
* Angular-xeditable module
*
*/
angular.module('xeditable', [])
/**
* Default options.
*
* @namespace editable-options
*/
//todo: maybe better have editableDefaults, not options...
.value('editableOptions', {
/**
* Theme. Possible values `bs3`, `bs2`, `default`.
*
* @var {string} theme
* @memberOf editable-options
*/
theme: 'default',
/**
* Icon Set. Possible values `font-awesome`, `default`.
*
* @var {string} icon set
* @memberOf editable-options
*/
icon_set: 'default',
/**
* Whether to show buttons for single editalbe element.
* Possible values `right` (default), `no`.
*
* @var {string} buttons
* @memberOf editable-options
*/
buttons: 'right',
/**
* Default value for `blur` attribute of single editable element.
* Can be `cancel|submit|ignore`.
*
* @var {string} blurElem
* @memberOf editable-options
*/
blurElem: 'cancel',
/**
* Default value for `blur` attribute of editable form.
* Can be `cancel|submit|ignore`.
*
* @var {string} blurForm
* @memberOf editable-options
*/
blurForm: 'ignore',
/**
* How input elements get activated. Possible values: `focus|select|none`.
*
* @var {string} activate
* @memberOf editable-options
*/
activate: 'focus',
/**
* Whether to disable x-editable. Can be overloaded on each element.
*
* @var {boolean} isDisabled
* @memberOf editable-options
*/
isDisabled: false,
/**
* Event, on which the edit mode gets activated.
* Can be any event.
*
* @var {string} activationEvent
* @memberOf editable-options
*/
activationEvent: 'click'
});
/*
Angular-ui bootstrap datepicker
http://angular-ui.github.io/bootstrap/#/datepicker
*/
angular.module('xeditable').directive('editableBsdate', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableBsdate',
inputTpl: '<div></div>',
render: function() {
/** This basically renders a datepicker as in the example shown in
** http://angular-ui.github.io/bootstrap/#/datepicker
** The attributes are all the same as in the bootstrap-ui datepicker with e- as prefix
**/
this.parent.render.call(this);
var inputDatePicker = angular.element('<input type="text" class="form-control" ng-model="$data"/>');
var buttonDatePicker = angular.element('<button type="button" class="btn btn-default"><i class="glyphicon glyphicon-calendar"></i></button>');
var buttonWrapper = angular.element('<span class="input-group-btn"></span>');
inputDatePicker.attr('datepicker-popup', this.attrs.eDatepickerPopupXEditable || 'yyyy/MM/dd' );
inputDatePicker.attr('is-open', this.attrs.eIsOpen);
inputDatePicker.attr('date-disabled', this.attrs.eDateDisabled);
inputDatePicker.attr('datepicker-popup', this.attrs.eDatepickerPopup);
inputDatePicker.attr('datepicker-mode', this.attrs.eDatepickerMode || 'day');
inputDatePicker.attr('min-date', this.attrs.eMinDate);
inputDatePicker.attr('max-date', this.attrs.eMaxDate);
inputDatePicker.attr('show-weeks', this.attrs.eShowWeeks || true);
inputDatePicker.attr('starting-day', this.attrs.eStartingDay || 0);
inputDatePicker.attr('init-date', this.attrs.eInitDate || new Date());
inputDatePicker.attr('min-mode', this.attrs.eMinMode || 'day');
inputDatePicker.attr('max-mode', this.attrs.eMaxMode || 'year');
inputDatePicker.attr('format-day', this.attrs.eFormatDay || 'dd');
inputDatePicker.attr('format-month', this.attrs.eFormatMonth || 'MMMM');
inputDatePicker.attr('format-year', this.attrs.eFormatYear || 'yyyy');
inputDatePicker.attr('format-day-header', this.attrs.eFormatDayHeader || 'EEE');
inputDatePicker.attr('format-day-title', this.attrs.eFormatDayTitle || 'MMMM yyyy');
inputDatePicker.attr('format-month-title', this.attrs.eFormatMonthTitle || 'yyyy');
inputDatePicker.attr('year-range', this.attrs.eYearRange || 20);
inputDatePicker.attr('show-button-bar', this.attrs.eShowButtonBar || true);
inputDatePicker.attr('current-text', this.attrs.eCurrentText || 'Today');
inputDatePicker.attr('clear-text', this.attrs.eClearText || 'Clear');
inputDatePicker.attr('close-text', this.attrs.eCloseText || 'Done');
inputDatePicker.attr('close-on-date-selection', this.attrs.eCloseOnDateSelection || true);
inputDatePicker.attr('date-picker-append-to-body', this.attrs.eDatePickerAppendToBody || false);
inputDatePicker.attr('date-disabled', this.attrs.eDateDisabled);
buttonDatePicker.attr('ng-click',this.attrs.eNgClick);
buttonWrapper.append(buttonDatePicker);
this.inputEl.prepend(inputDatePicker);
this.inputEl.append(buttonWrapper);
this.inputEl.removeAttr('class');
this.inputEl.attr('class','input-group');
}
});
}]);
/*
Angular-ui bootstrap editable timepicker
http://angular-ui.github.io/bootstrap/#/timepicker
*/
angular.module('xeditable').directive('editableBstime', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableBstime',
inputTpl: '<timepicker></timepicker>',
render: function() {
this.parent.render.call(this);
// timepicker can't update model when ng-model set directly to it
// see: https://github.com/angular-ui/bootstrap/issues/1141
// so we wrap it into DIV
var div = angular.element('<div class="well well-small" style="display:inline-block;"></div>');
// move ng-model to wrapping div
div.attr('ng-model', this.inputEl.attr('ng-model'));
this.inputEl.removeAttr('ng-model');
// move ng-change to wrapping div
if(this.attrs.eNgChange) {
div.attr('ng-change', this.inputEl.attr('ng-change'));
this.inputEl.removeAttr('ng-change');
}
// wrap
this.inputEl.wrap(div);
}
});
}]);
//checkbox
angular.module('xeditable').directive('editableCheckbox', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableCheckbox',
inputTpl: '<input type="checkbox">',
render: function() {
this.parent.render.call(this);
if(this.attrs.eTitle) {
this.inputEl.wrap('<label></label>');
this.inputEl.parent().append(this.attrs.eTitle);
}
},
autosubmit: function() {
var self = this;
self.inputEl.bind('change', function() {
setTimeout(function() {
self.scope.$apply(function() {
self.scope.$form.$submit();
});
}, 500);
});
}
});
}]);
// checklist
angular.module('xeditable').directive('editableChecklist', [
'editableDirectiveFactory',
'editableNgOptionsParser',
function(editableDirectiveFactory, editableNgOptionsParser) {
return editableDirectiveFactory({
directiveName: 'editableChecklist',
inputTpl: '<span></span>',
useCopy: true,
render: function() {
this.parent.render.call(this);
var parsed = editableNgOptionsParser(this.attrs.eNgOptions);
var html = '<label ng-repeat="'+parsed.ngRepeat+'">'+
'<input type="checkbox" checklist-model="$parent.$data" checklist-value="'+parsed.locals.valueFn+'">'+
'<span ng-bind="'+parsed.locals.displayFn+'"></span></label>';
this.inputEl.removeAttr('ng-model');
this.inputEl.removeAttr('ng-options');
this.inputEl.html(html);
}
});
}]);
angular.module('xeditable').directive('editableCombodate', ['editableDirectiveFactory', 'editableCombodate',
function(editableDirectiveFactory, editableCombodate) {
return editableDirectiveFactory({
directiveName: 'editableCombodate',
inputTpl: '<input type="text">',
render: function() {
this.parent.render.call(this);
var combodate = editableCombodate.getInstance(this.inputEl, {value: new Date(this.scope.$data)});
var self = this;
combodate.$widget.find('select').bind('change', function(e) {
self.scope.$data = (new Date(combodate.getValue())).toISOString();
});
}
});
}
]);
/*
Input types: text|email|tel|number|url|search|color|date|datetime|time|month|week
*/
(function() {
var types = 'text|password|email|tel|number|url|search|color|date|datetime|time|month|week|file'.split('|');
//todo: datalist
// generate directives
angular.forEach(types, function(type) {
var directiveName = 'editable'+type.charAt(0).toUpperCase() + type.slice(1);
angular.module('xeditable').directive(directiveName, ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: directiveName,
inputTpl: '<input type="'+type+'">'
});
}]);
});
//`range` is bit specific
angular.module('xeditable').directive('editableRange', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableRange',
inputTpl: '<input type="range" id="range" name="range">',
render: function() {
this.parent.render.call(this);
this.inputEl.after('<output>{{$data}}</output>');
}
});
}]);
}());
// radiolist
angular.module('xeditable').directive('editableRadiolist', [
'editableDirectiveFactory',
'editableNgOptionsParser',
function(editableDirectiveFactory, editableNgOptionsParser) {
return editableDirectiveFactory({
directiveName: 'editableRadiolist',
inputTpl: '<span></span>',
render: function() {
this.parent.render.call(this);
var parsed = editableNgOptionsParser(this.attrs.eNgOptions);
var html = '<label ng-repeat="'+parsed.ngRepeat+'">'+
'<input type="radio" ng-disabled="' + this.attrs.eNgDisabled + '" ng-model="$parent.$data" value="{{'+parsed.locals.valueFn+'}}">'+
'<span ng-bind="'+parsed.locals.displayFn+'"></span></label>';
this.inputEl.removeAttr('ng-model');
this.inputEl.removeAttr('ng-options');
this.inputEl.html(html);
},
autosubmit: function() {
var self = this;
self.inputEl.bind('change', function() {
setTimeout(function() {
self.scope.$apply(function() {
self.scope.$form.$submit();
});
}, 500);
});
}
});
}]);
//select
angular.module('xeditable').directive('editableSelect', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableSelect',
inputTpl: '<select></select>',
autosubmit: function() {
var self = this;
self.inputEl.bind('change', function() {
self.scope.$apply(function() {
self.scope.$form.$submit();
});
});
}
});
}]);
//textarea
angular.module('xeditable').directive('editableTextarea', ['editableDirectiveFactory',
function(editableDirectiveFactory) {
return editableDirectiveFactory({
directiveName: 'editableTextarea',
inputTpl: '<textarea></textarea>',
addListeners: function() {
var self = this;
self.parent.addListeners.call(self);
// submit textarea by ctrl+enter even with buttons
if (self.single && self.buttons !== 'no') {
self.autosubmit();
}
},
autosubmit: function() {
var self = this;
self.inputEl.bind('keydown', function(e) {
if ((e.ctrlKey || e.metaKey) && (e.keyCode === 13)) {
self.scope.$apply(function() {
self.scope.$form.$submit();
});
}
});
}
});
}]);
/**
* EditableController class.
* Attached to element with `editable-xxx` directive.
*
* @namespace editable-element
*/
/*
TODO: this file should be refactored to work more clear without closures!
*/
angular.module('xeditable').factory('editableController',
['$q', 'editableUtils',
function($q, editableUtils) {
//EditableController function
EditableController.$inject = ['$scope', '$attrs', '$element', '$parse', 'editableThemes', 'editableIcons', 'editableOptions', '$rootScope', '$compile', '$q'];
function EditableController($scope, $attrs, $element, $parse, editableThemes, editableIcons, editableOptions, $rootScope, $compile, $q) {
var valueGetter;
//if control is disabled - it does not participate in waiting process
var inWaiting;
var self = this;
self.scope = $scope;
self.elem = $element;
self.attrs = $attrs;
self.inputEl = null;
self.editorEl = null;
self.single = true;
self.error = '';
self.theme = editableThemes[editableOptions.theme] || editableThemes['default'];
self.parent = {};
//will be undefined if icon_set is default and theme is default
self.icon_set = editableOptions.icon_set === 'default' ? editableIcons.default[editableOptions.theme] : editableIcons.external[editableOptions.icon_set];
//to be overwritten by directive
self.inputTpl = '';
self.directiveName = '';
// with majority of controls copy is not needed, but..
// copy MUST NOT be used for `select-multiple` with objects as items
// copy MUST be used for `checklist`
self.useCopy = false;
//runtime (defaults)
self.single = null;
/**
* Attributes defined with `e-*` prefix automatically transfered from original element to
* control.
* For example, if you set `<span editable-text="user.name" e-style="width: 100px"`>
* then input will appear as `<input style="width: 100px">`.
* See [demo](#text-customize).
*
* @var {any|attribute} e-*
* @memberOf editable-element
*/
/**
* Whether to show ok/cancel buttons. Values: `right|no`.
* If set to `no` control automatically submitted when value changed.
* If control is part of form buttons will never be shown.
*
* @var {string|attribute} buttons
* @memberOf editable-element
*/
self.buttons = 'right';
/**
* Action when control losses focus. Values: `cancel|submit|ignore`.
* Has sense only for single editable element.
* Otherwise, if control is part of form - you should set `blur` of form, not of individual element.
*
* @var {string|attribute} blur
* @memberOf editable-element
*/
// no real `blur` property as it is transfered to editable form
//init
self.init = function(single) {
self.single = single;
self.name = $attrs.eName || $attrs[self.directiveName];
/*
if(!$attrs[directiveName] && !$attrs.eNgModel && ($attrs.eValue === undefined)) {
throw 'You should provide value for `'+directiveName+'` or `e-value` in editable element!';
}
*/
if($attrs[self.directiveName]) {
valueGetter = $parse($attrs[self.directiveName]);
} else {
throw 'You should provide value for `'+self.directiveName+'` in editable element!';
}
// settings for single and non-single
if (!self.single) {
// hide buttons for non-single
self.buttons = 'no';
} else {
self.buttons = self.attrs.buttons || editableOptions.buttons;
}
//if name defined --> watch changes and update $data in form
if($attrs.eName) {
self.scope.$watch('$data', function(newVal){
self.scope.$form.$data[$attrs.eName] = newVal;
});
}
/**
* Called when control is shown.
* See [demo](#select-remote).
*
* @var {method|attribute} onshow
* @memberOf editable-element
*/
if($attrs.onshow) {
self.onshow = function() {
return self.catchError($parse($attrs.onshow)($scope));
};
}
/**
* Called when control is hidden after both save or cancel.
*
* @var {method|attribute} onhide
* @memberOf editable-element
*/
if($attrs.onhide) {
self.onhide = function() {
return $parse($attrs.onhide)($scope);
};
}
/**
* Called when control is cancelled.
*
* @var {method|attribute} oncancel
* @memberOf editable-element
*/
if($attrs.oncancel) {
self.oncancel = function() {
return $parse($attrs.oncancel)($scope);
};
}
/**
* Called during submit before value is saved to model.
* See [demo](#onbeforesave).
*
* @var {method|attribute} onbeforesave
* @memberOf editable-element
*/
if ($attrs.onbeforesave) {
self.onbeforesave = function() {
return self.catchError($parse($attrs.onbeforesave)($scope));
};
}
/**
* Called during submit after value is saved to model.
* See [demo](#onaftersave).
*
* @var {method|attribute} onaftersave
* @memberOf editable-element
*/
if ($attrs.onaftersave) {
self.onaftersave = function() {
return self.catchError($parse($attrs.onaftersave)($scope));
};
}
// watch change of model to update editable element
// now only add/remove `editable-empty` class.
// Initially this method called with newVal = undefined, oldVal = undefined
// so no need initially call handleEmpty() explicitly
$scope.$parent.$watch($attrs[self.directiveName], function(newVal, oldVal) {
self.setLocalValue();
self.handleEmpty();
});
};
self.render = function() {
var theme = self.theme;
//build input
self.inputEl = angular.element(self.inputTpl);
//build controls
self.controlsEl = angular.element(theme.controlsTpl);
self.controlsEl.append(self.inputEl);
//build buttons
if(self.buttons !== 'no') {
self.buttonsEl = angular.element(theme.buttonsTpl);
self.submitEl = angular.element(theme.submitTpl);
self.cancelEl = angular.element(theme.cancelTpl);
if(self.icon_set) {
self.submitEl.find('span').addClass(self.icon_set.ok);
self.cancelEl.find('span').addClass(self.icon_set.cancel);
}
self.buttonsEl.append(self.submitEl).append(self.cancelEl);
self.controlsEl.append(self.buttonsEl);
self.inputEl.addClass('editable-has-buttons');
}
//build error
self.errorEl = angular.element(theme.errorTpl);
self.controlsEl.append(self.errorEl);
//build editor
self.editorEl = angular.element(self.single ? theme.formTpl : theme.noformTpl);
self.editorEl.append(self.controlsEl);
// transfer `e-*|data-e-*|x-e-*` attributes
for(var k in $attrs.$attr) {
if(k.length <= 1) {
continue;
}
var transferAttr = false;
var nextLetter = k.substring(1, 2);
// if starts with `e` + uppercase letter
if(k.substring(0, 1) === 'e' && nextLetter === nextLetter.toUpperCase()) {
transferAttr = k.substring(1); // cut `e`
} else {
continue;
}
// exclude `form` and `ng-submit`,
if(transferAttr === 'Form' || transferAttr === 'NgSubmit') {
continue;
}
// convert back to lowercase style
transferAttr = transferAttr.substring(0, 1).toLowerCase() + editableUtils.camelToDash(transferAttr.substring(1));
// workaround for attributes without value (e.g. `multiple = "multiple"`)
// except for 'e-value'
var attrValue = (transferAttr !== 'value' && $attrs[k] === '') ? transferAttr : $attrs[k];
// set attributes to input
self.inputEl.attr(transferAttr, attrValue);
}
self.inputEl.addClass('editable-input');
self.inputEl.attr('ng-model', '$data');
// add directiveName class to editor, e.g. `editable-text`
self.editorEl.addClass(editableUtils.camelToDash(self.directiveName));
if(self.single) {
self.editorEl.attr('editable-form', '$form');
// transfer `blur` to form
self.editorEl.attr('blur', self.attrs.blur || (self.buttons === 'no' ? 'cancel' : editableOptions.blurElem));
}
//apply `postrender` method of theme
if(angular.isFunction(theme.postrender)) {
theme.postrender.call(self);
}
};
// with majority of controls copy is not needed, but..
// copy MUST NOT be used for `select-multiple` with objects as items
// copy MUST be used for `checklist`
self.setLocalValue = function() {
self.scope.$data = self.useCopy ?
angular.copy(valueGetter($scope.$parent)) :
valueGetter($scope.$parent);
};
//show
self.show = function() {
// set value of scope.$data
self.setLocalValue();
/*
Originally render() was inside init() method, but some directives polluting editorEl,
so it is broken on second openning.
Cloning is not a solution as jqLite can not clone with event handler's.
*/
self.render();
// insert into DOM
$element.after(self.editorEl);
// compile (needed to attach ng-* events from markup)
$compile(self.editorEl)($scope);
// attach listeners (`escape`, autosubmit, etc)
self.addListeners();
// hide element
$element.addClass('editable-hide');
// onshow
return self.onshow();
};
//hide
self.hide = function() {
self.editorEl.remove();
$element.removeClass('editable-hide');
// onhide
return self.onhide();
};
// cancel
self.cancel = function() {
// oncancel
self.oncancel();
// don't call hide() here as it called in form's code
};
/*
Called after show to attach listeners
*/
self.addListeners = function() {
// bind keyup for `escape`
self.inputEl.bind('keyup', function(e) {
if(!self.single) {
return;
}
// todo: move this to editable-form!
switch(e.keyCode) {
// hide on `escape` press
case 27:
self.scope.$apply(function() {
self.scope.$form.$cancel();
});
break;
}
});
// autosubmit when `no buttons`
if (self.single && self.buttons === 'no') {
self.autosubmit();
}
// click - mark element as clicked to exclude in document click handler
self.editorEl.bind('click', function(e) {
// ignore right/middle button click
if (e.which && e.which !== 1) {
return;
}
if (self.scope.$form.$visible) {
self.scope.$form._clicked = true;
}
});
};
// setWaiting
self.setWaiting = function(value) {
if (value) {
// participate in waiting only if not disabled
inWaiting = !self.inputEl.attr('disabled') &&
!self.inputEl.attr('ng-disabled') &&
!self.inputEl.attr('ng-enabled');
if (inWaiting) {
self.inputEl.attr('disabled', 'disabled');
if(self.buttonsEl) {
self.buttonsEl.find('button').attr('disabled', 'disabled');
}
}
} else {
if (inWaiting) {
self.inputEl.removeAttr('disabled');
if (self.buttonsEl) {
self.buttonsEl.find('button').removeAttr('disabled');
}
}
}
};
self.activate = function(start, end) {
setTimeout(function() {
var el = self.inputEl[0];
if (editableOptions.activate === 'focus' && el.focus) {
if(start){
end = end || start;
el.onfocus = function(){
var that = this;
setTimeout(function(){
that.setSelectionRange(start,end);
});
};
}
el.focus();
}
if (editableOptions.activate === 'select' && el.select) {
el.select();
}
}, 0);
};
self.setError = function(msg) {
if(!angular.isObject(msg)) {
$scope.$error = msg;
self.error = msg;
}
};
/*
Checks that result is string or promise returned string and shows it as error message
Applied to onshow, onbeforesave, onaftersave
*/
self.catchError = function(result, noPromise) {
if (angular.isObject(result) && noPromise !== true) {
$q.when(result).then(
//success and fail handlers are equal
angular.bind(this, function(r) {
this.catchError(r, true);
}),
angular.bind(this, function(r) {
this.catchError(r, true);
})
);
//check $http error
} else if (noPromise && angular.isObject(result) && result.status &&
(result.status !== 200) && result.data && angular.isString(result.data)) {
this.setError(result.data);
//set result to string: to let form know that there was error
result = result.data;
} else if (angular.isString(result)) {
this.setError(result);
}
return result;
};
self.save = function() {
valueGetter.assign($scope.$parent,
self.useCopy ? angular.copy(self.scope.$data) : self.scope.$data);
// no need to call handleEmpty here as we are watching change of model value
// self.handleEmpty();
};
/*
attach/detach `editable-empty` class to element
*/
self.handleEmpty = function() {
var val = valueGetter($scope.$parent);
var isEmpty = val === null || val === undefined || val === "" || (angular.isArray(val) && val.length === 0);
$element.toggleClass('editable-empty', isEmpty);
};
/*
Called when `buttons = "no"` to submit automatically
*/
self.autosubmit = angular.noop;
self.onshow = angular.noop;
self.onhide = angular.noop;
self.oncancel = angular.noop;
self.onbeforesave = angular.noop;
self.onaftersave = angular.noop;
}
return EditableController;
}]);
/*
editableFactory is used to generate editable directives (see `/directives` folder)
Inside it does several things:
- detect form for editable element. Form may be one of three types:
1. autogenerated form (for single editable elements)
2. wrapper form (element wrapped by <form> tag)
3. linked form (element has `e-form` attribute pointing to existing form)
- attach editableController to element
Depends on: editableController, editableFormFactory
*/
angular.module('xeditable').factory('editableDirectiveFactory',
['$parse', '$compile', 'editableThemes', '$rootScope', '$document', 'editableController', 'editableFormController', 'editableOptions',
function($parse, $compile, editableThemes, $rootScope, $document, editableController, editableFormController, editableOptions) {
//directive object
return function(overwrites) {
return {
restrict: 'A',
scope: true,
require: [overwrites.directiveName, '?^form'],
controller: editableController,
link: function(scope, elem, attrs, ctrl) {
// editable controller
var eCtrl = ctrl[0];
// form controller
var eFormCtrl;
// this variable indicates is element is bound to some existing form,
// or it's single element who's form will be generated automatically
// By default consider single element without any linked form.ß
var hasForm = false;
// element wrapped by form
if(ctrl[1]) {
eFormCtrl = ctrl[1];
hasForm = true;
} else if(attrs.eForm) { // element not wrapped by <form>, but we hane `e-form` attr
var getter = $parse(attrs.eForm)(scope);
if(getter) { // form exists in scope (above), e.g. editable column
eFormCtrl = getter;
hasForm = true;
} else { // form exists below or not exist at all: check document.forms
for(var i=0; i<$document[0].forms.length;i++){
if($document[0].forms[i].name === attrs.eForm) {
// form is below and not processed yet
eFormCtrl = null;
hasForm = true;
break;
}
}
}
}
/*
if(hasForm && !attrs.eName) {
throw 'You should provide `e-name` for editable element inside form!';
}
*/
//check for `editable-form` attr in form
/*
if(eFormCtrl && ) {
throw 'You should provide `e-name` for editable element inside form!';
}
*/
// store original props to `parent` before merge
angular.forEach(overwrites, function(v, k) {
if(eCtrl[k] !== undefined) {
eCtrl.parent[k] = eCtrl[k];
}
});
// merge overwrites to base editable controller
angular.extend(eCtrl, overwrites);
// x-editable can be disabled using editableOption or edit-disabled attribute
var disabled = angular.isDefined(attrs.editDisabled) ?
scope.$eval(attrs.editDisabled) :
editableOptions.isDisabled;
if (disabled) {
return;
}
// init editable ctrl
eCtrl.init(!hasForm);
// publich editable controller as `$editable` to be referenced in html
scope.$editable = eCtrl;
// add `editable` class to element
elem.addClass('editable');
// hasForm
if(hasForm) {
if(eFormCtrl) {
scope.$form = eFormCtrl;
if(!scope.$form.$addEditable) {
throw 'Form with editable elements should have `editable-form` attribute.';
}
scope.$form.$addEditable(eCtrl);
} else {
// future form (below): add editable controller to buffer and add to form later
$rootScope.$$editableBuffer = $rootScope.$$editableBuffer || {};
$rootScope.$$editableBuffer[attrs.eForm] = $rootScope.$$editableBuffer[attrs.eForm] || [];
$rootScope.$$editableBuffer[attrs.eForm].push(eCtrl);
scope.$form = null; //will be re-assigned later
}
// !hasForm
} else {
// create editableform controller
scope.$form = editableFormController();
// add self to editable controller
scope.$form.$addEditable(eCtrl);
// if `e-form` provided, publish local $form in scope
if(attrs.eForm) {
scope.$parent[attrs.eForm] = scope.$form;
}
// bind click - if no external form defined
if(!attrs.eForm || attrs.eClickable) {
elem.addClass('editable-click');
elem.bind(editableOptions.activationEvent, function(e) {
e.preventDefault();
e.editable = eCtrl;
scope.$apply(function(){
scope.$form.$show();
});
});
}
}
}
};
};
}]);
/*
Returns editableForm controller
*/
angular.module('xeditable').factory('editableFormController',
['$parse', '$document', '$rootScope', 'editablePromiseCollection', 'editableUtils',
function($parse, $document, $rootScope, editablePromiseCollection, editableUtils) {
// array of opened editable forms
var shown = [];
//Check if the child element correspond or is a descendant of the parent element
var isSelfOrDescendant = function (parent, child) {
if (child == parent) {
return true;
}
var node = child.parentNode;
while (node !== null) {
if (node == parent) {
return true;
}
node = node.parentNode;
}
return false;
};
//Check if it is a real blur : if the click event appear on a shown editable elem, this is not a blur.
var isBlur = function(shown, event) {
var isBlur = true;
var editables = shown.$editables;
angular.forEach(editables, function(v){
var element = v.editorEl[0];
if (isSelfOrDescendant(element, event.target))
isBlur = false;
});
return isBlur;
};
// bind click to body: cancel|submit|ignore forms
$document.bind('click', function(e) {
// ignore right/middle button click
if ((e.which && e.which !== 1) || e.isDefaultPrevented()) {
return;
}
var toCancel = [];
var toSubmit = [];
for (var i=0; i<shown.length; i++) {
// exclude clicked
if (shown[i]._clicked) {
shown[i]._clicked = false;
continue;
}
// exclude waiting
if (shown[i].$waiting) {
continue;
}
if (shown[i]._blur === 'cancel' && isBlur(shown[i], e)) {
toCancel.push(shown[i]);
}
if (shown[i]._blur === 'submit' && isBlur(shown[i], e)) {
toSubmit.push(shown[i]);
}
}
if (toCancel.length || toSubmit.length) {
$rootScope.$apply(function() {
angular.forEach(toCancel, function(v){ v.$cancel(); });
angular.forEach(toSubmit, function(v){ v.$submit(); });
});
}
});
var base = {
$addEditable: function(editable) {
//console.log('add editable', editable.elem, editable.elem.bind);
this.$editables.push(editable);
//'on' is not supported in angular 1.0.8
editable.elem.bind('$destroy', angular.bind(this, this.$removeEditable, editable));
//bind editable's local $form to self (if not bound yet, below form)
if (!editable.scope.$form) {
editable.scope.$form = this;
}
//if form already shown - call show() of new editable
if (this.$visible) {
editable.catchError(editable.show());
}
},
$removeEditable: function(editable) {
//arrayRemove
for(var i=0; i < this.$editables.length; i++) {
if(this.$editables[i] === editable) {
this.$editables.splice(i, 1);
return;
}
}
},
/**
* Shows form with editable controls.
*
* @method $show()
* @memberOf editable-form
*/
$show: function() {
if (this.$visible) {
return;
}
this.$visible = true;
var pc = editablePromiseCollection();
//own show
pc.when(this.$onshow());
//clear errors
this.$setError(null, '');
//children show
angular.forEach(this.$editables, function(editable) {
pc.when(editable.show());
});
//wait promises and activate
pc.then({
onWait: angular.bind(this, this.$setWaiting),
onTrue: angular.bind(this, this.$activate),
onFalse: angular.bind(this, this.$activate),
onString: angular.bind(this, this.$activate)
});
// add to internal list of shown forms
// setTimeout needed to prevent closing right after opening (e.g. when trigger by button)
setTimeout(angular.bind(this, function() {
// clear `clicked` to get ready for clicks on visible form
this._clicked = false;
if(editableUtils.indexOf(shown, this) === -1) {
shown.push(this);
}
}), 0);
},
/**
* Sets focus on form field specified by `name`.
*
* @method $activate(name)
* @param {string} name name of field
* @memberOf editable-form
*/
$activate: function(name) {
var i;
if (this.$editables.length) {
//activate by name
if (angular.isString(name)) {
for(i=0; i<this.$editables.length; i++) {
if (this.$editables[i].name === name) {
this.$editables[i].activate();
return;
}
}
}
//try activate error field
for(i=0; i<this.$editables.length; i++) {
if (this.$editables[i].error) {
this.$editables[i].activate();
return;
}
}
//by default activate first field
this.$editables[0].activate(this.$editables[0].elem[0].selectionStart, this.$editables[0].elem[0].selectionEnd);
}
},
/**
* Hides form with editable controls without saving.
*
* @method $hide()
* @memberOf editable-form
*/
$hide: function() {
if (!this.$visible) {
return;
}
this.$visible = false;
// self hide
this.$onhide();
// children's hide
angular.forEach(this.$editables, function(editable) {
editable.hide();
});
// remove from internal list of shown forms
editableUtils.arrayRemove(shown, this);
},
/**
* Triggers `oncancel` event and calls `$hide()`.
*
* @method $cancel()
* @memberOf editable-form
*/
$cancel: function() {
if (!this.$visible) {
return;
}
// self cancel
this.$oncancel();
// children's cancel
angular.forEach(this.$editables, function(editable) {
editable.cancel();
});
// self hide
this.$hide();
},
$setWaiting: function(value) {
this.$waiting = !!value;
// we can't just set $waiting variable and use it via ng-disabled in children
// because in editable-row form is not accessible
angular.forEach(this.$editables, function(editable) {
editable.setWaiting(!!value);
});
},
/**
* Shows error message for particular field.
*
* @method $setError(name, msg)
* @param {string} name name of field
* @param {string} msg error message
* @memberOf editable-form
*/
$setError: function(name, msg) {
angular.forEach(this.$editables, function(editable) {
if(!name || editable.name === name) {
editable.setError(msg);
}
});
},
$submit: function() {
if (this.$waiting) {
return;
}
//clear errors
this.$setError(null, '');
//children onbeforesave
var pc = editablePromiseCollection();
angular.forEach(this.$editables, function(editable) {
pc.when(editable.onbeforesave());
});
/*
onbeforesave result:
- true/undefined: save data and close form
- false: close form without saving
- string: keep form open and show error
*/
pc.then({
onWait: angular.bind(this, this.$setWaiting),
onTrue: angular.bind(this, checkSelf, true),
onFalse: angular.bind(this, checkSelf, false),
onString: angular.bind(this, this.$activate)
});
//save
function checkSelf(childrenTrue){
var pc = editablePromiseCollection();
pc.when(this.$onbeforesave());
pc.then({
onWait: angular.bind(this, this.$setWaiting),
onTrue: childrenTrue ? angular.bind(this, this.$save) : angular.bind(this, this.$hide),
onFalse: angular.bind(this, this.$hide),
onString: angular.bind(this, this.$activate)
});
}
},
$save: function() {
// write model for each editable
angular.forEach(this.$editables, function(editable) {
editable.save();
});
//call onaftersave of self and children
var pc = editablePromiseCollection();
pc.when(this.$onaftersave());
angular.forEach(this.$editables, function(editable) {
pc.when(editable.onaftersave());
});
/*
onaftersave result:
- true/undefined/false: just close form
- string: keep form open and show error
*/
pc.then({
onWait: angular.bind(this, this.$setWaiting),
onTrue: angular.bind(this, this.$hide),
onFalse: angular.bind(this, this.$hide),
onString: angular.bind(this, this.$activate)
});
},
$onshow: angular.noop,
$oncancel: angular.noop,
$onhide: angular.noop,
$onbeforesave: angular.noop,
$onaftersave: angular.noop
};
return function() {
return angular.extend({
$editables: [],
/**
* Form visibility flag.
*
* @var {bool} $visible
* @memberOf editable-form
*/
$visible: false,
/**
* Form waiting flag. It becomes `true` when form is loading or saving data.
*
* @var {bool} $waiting
* @memberOf editable-form
*/
$waiting: false,
$data: {},
_clicked: false,
_blur: null
}, base);
};
}]);
/**
* EditableForm directive. Should be defined in <form> containing editable controls.
* It add some usefull methods to form variable exposed to scope by `name="myform"` attribute.
*
* @namespace editable-form
*/
angular.module('xeditable').directive('editableForm',
['$rootScope', '$parse', 'editableFormController', 'editableOptions',
function($rootScope, $parse, editableFormController, editableOptions) {
return {
restrict: 'A',
require: ['form'],
//require: ['form', 'editableForm'],
//controller: EditableFormController,
compile: function() {
return {
pre: function(scope, elem, attrs, ctrl) {
var form = ctrl[0];
var eForm;
//if `editableForm` has value - publish smartly under this value
//this is required only for single editor form that is created and removed
if(attrs.editableForm) {
if(scope[attrs.editableForm] && scope[attrs.editableForm].$show) {
eForm = scope[attrs.editableForm];
angular.extend(form, eForm);
} else {
eForm = editableFormController();
scope[attrs.editableForm] = eForm;
angular.extend(eForm, form);
}
} else { //just merge to form and publish if form has name
eForm = editableFormController();
angular.extend(form, eForm);
}
//read editables from buffer (that appeared before FORM tag)
var buf = $rootScope.$$editableBuffer;
var name = form.$name;
if(name && buf && buf[name]) {
angular.forEach(buf[name], function(editable) {
eForm.$addEditable(editable);
});
delete buf[name];
}
},
post: function(scope, elem, attrs, ctrl) {
var eForm;
if(attrs.editableForm && scope[attrs.editableForm] && scope[attrs.editableForm].$show) {
eForm = scope[attrs.editableForm];
} else {
eForm = ctrl[0];
}
/**
* Called when form is shown.
*
* @var {method|attribute} onshow
* @memberOf editable-form
*/
if(attrs.onshow) {
eForm.$onshow = angular.bind(eForm, $parse(attrs.onshow), scope);
}
/**
* Called when form hides after both save or cancel.
*
* @var {method|attribute} onhide
* @memberOf editable-form
*/
if(attrs.onhide) {
eForm.$onhide = angular.bind(eForm, $parse(attrs.onhide), scope);
}
/**
* Called when form is cancelled.
*
* @var {method|attribute} oncancel
* @memberOf editable-form
*/
if(attrs.oncancel) {
eForm.$oncancel = angular.bind(eForm, $parse(attrs.oncancel), scope);
}
/**
* Whether form initially rendered in shown state.
*
* @var {bool|attribute} shown
* @memberOf editable-form
*/
if(attrs.shown && $parse(attrs.shown)(scope)) {
eForm.$show();
}
/**
* Action when form losses focus. Values: `cancel|submit|ignore`.
* Default is `ignore`.
*
* @var {string|attribute} blur
* @memberOf editable-form
*/
eForm._blur = attrs.blur || editableOptions.blurForm;
// onbeforesave, onaftersave
if(!attrs.ngSubmit && !attrs.submit) {
/**
* Called after all children `onbeforesave` callbacks but before saving form values
* to model.
* If at least one children callback returns `non-string` - it will not not be called.
* See [editable-form demo](#editable-form) for details.
*
* @var {method|attribute} onbeforesave
* @memberOf editable-form
*
*/
if(attrs.onbeforesave) {
eForm.$onbeforesave = function() {
return $parse(attrs.onbeforesave)(scope, {$data: eForm.$data});
};
}
/**
* Called when form values are saved to model.
* See [editable-form demo](#editable-form) for details.
*
* @var {method|attribute} onaftersave
* @memberOf editable-form
*
*/
if(attrs.onaftersave) {
eForm.$onaftersave = function() {
return $parse(attrs.onaftersave)(scope, {$data: eForm.$data});
};
}
elem.bind('submit', function(event) {
event.preventDefault();
scope.$apply(function() {
eForm.$submit();
});
});
}
// click - mark form as clicked to exclude in document click handler
elem.bind('click', function(e) {
// ignore right/middle button click
if (e.which && e.which !== 1) {
return;
}
if (eForm.$visible) {
eForm._clicked = true;
}
});
}
};
}
};
}]);
/**
* editablePromiseCollection
*
* Collect results of function calls. Shows waiting if there are promises.
* Finally, applies callbacks if:
* - onTrue(): all results are true and all promises resolved to true
* - onFalse(): at least one result is false or promise resolved to false
* - onString(): at least one result is string or promise rejected or promise resolved to string
*/
angular.module('xeditable').factory('editablePromiseCollection', ['$q', function($q) {
function promiseCollection() {
return {
promises: [],
hasFalse: false,
hasString: false,
when: function(result, noPromise) {
if (result === false) {
this.hasFalse = true;
} else if (!noPromise && angular.isObject(result)) {
this.promises.push($q.when(result));
} else if (angular.isString(result)){
this.hasString = true;
} else { //result === true || result === undefined || result === null
return;
}
},
//callbacks: onTrue, onFalse, onString
then: function(callbacks) {
callbacks = callbacks || {};
var onTrue = callbacks.onTrue || angular.noop;
var onFalse = callbacks.onFalse || angular.noop;
var onString = callbacks.onString || angular.noop;
var onWait = callbacks.onWait || angular.noop;
var self = this;
if (this.promises.length) {
onWait(true);
$q.all(this.promises).then(
//all resolved
function(results) {
onWait(false);
//check all results via same `when` method (without checking promises)
angular.forEach(results, function(result) {
self.when(result, true);
});
applyCallback();
},
//some rejected
function(error) {
onWait(false);
onString();
}
);
} else {
applyCallback();
}
function applyCallback() {
if (!self.hasString && !self.hasFalse) {
onTrue();
} else if (!self.hasString && self.hasFalse) {
onFalse();
} else {
onString();
}
}
}
};
}
return promiseCollection;
}]);
/**
* editableUtils
*/
angular.module('xeditable').factory('editableUtils', [function() {
return {
indexOf: function (array, obj) {
if (array.indexOf) return array.indexOf(obj);
for ( var i = 0; i < array.length; i++) {
if (obj === array[i]) return i;
}
return -1;
},
arrayRemove: function (array, value) {
var index = this.indexOf(array, value);
if (index >= 0) {
array.splice(index, 1);
}
return value;
},
// copy from https://github.com/angular/angular.js/blob/master/src/Angular.js
camelToDash: function(str) {
var SNAKE_CASE_REGEXP = /[A-Z]/g;
return str.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
return (pos ? '-' : '') + letter.toLowerCase();
});
},
dashToCamel: function(str) {
var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
var MOZ_HACK_REGEXP = /^moz([A-Z])/;
return str.
replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
return offset ? letter.toUpperCase() : letter;
}).
replace(MOZ_HACK_REGEXP, 'Moz$1');
}
};
}]);
/**
* editableNgOptionsParser
*
* see: https://github.com/angular/angular.js/blob/master/src/ng/directive/select.js#L131
*/
angular.module('xeditable').factory('editableNgOptionsParser', [function() {
//0000111110000000000022220000000000000000000000333300000000000000444444444444444000000000555555555555555000000066666666666666600000000000000007777000000000000000000088888
var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+(.*?)(?:\s+track\s+by\s+(.*?))?$/;
function parser(optionsExp) {
var match;
if (! (match = optionsExp.match(NG_OPTIONS_REGEXP))) {
throw 'ng-options parse error';
}
var
displayFn = match[2] || match[1],
valueName = match[4] || match[6],
keyName = match[5],
groupByFn = match[3] || '',
valueFn = match[2] ? match[1] : valueName,
valuesFn = match[7],
track = match[8],
trackFn = track ? match[8] : null;
var ngRepeat;
if (keyName === undefined) { // array
ngRepeat = valueName + ' in ' + valuesFn;
if (track !== undefined) {
ngRepeat += ' track by '+trackFn;
}
} else { // object
ngRepeat = '('+keyName+', '+valueName+') in '+valuesFn;
}
// group not supported yet
return {
ngRepeat: ngRepeat,
locals: {
valueName: valueName,
keyName: keyName,
valueFn: valueFn,
displayFn: displayFn
}
};
}
return parser;
}]);
/**
* editableCombodate
*
* angular version of https://github.com/vitalets/combodate
*/
angular.module('xeditable').factory('editableCombodate', [function() {
function Combodate(element, options) {
this.$element = angular.element(element);
if(this.$element[0].nodeName != 'INPUT') {
throw 'Combodate should be applied to INPUT element';
}
this.defaults = {
//in this format value stored in original input
format: 'YYYY-MM-DD HH:mm',
//in this format items in dropdowns are displayed
template: 'D / MMM / YYYY H : mm',
//initial value, can be `new Date()`
value: null,
minYear: 1970,
maxYear: 2015,
yearDescending: true,
minuteStep: 5,
secondStep: 1,
firstItem: 'empty', //'name', 'empty', 'none'
errorClass: null,
customClass: '',
roundTime: true, // whether to round minutes and seconds if step > 1
smartDays: true // whether days in combo depend on selected month: 31, 30, 28
};
this.options = angular.extend({}, this.defaults, options);
this.init();
}
Combodate.prototype = {
constructor: Combodate,
init: function () {
this.map = {
//key regexp moment.method
day: ['D', 'date'],
month: ['M', 'month'],
year: ['Y', 'year'],
hour: ['[Hh]', 'hours'],
minute: ['m', 'minutes'],
second: ['s', 'seconds'],
ampm: ['[Aa]', '']
};
this.$widget = angular.element('<span class="combodate"></span>').html(this.getTemplate());
this.initCombos();
if (this.options.smartDays) {
var combo = this;
this.$widget.find('select').bind('change', function(e) {
// update days count if month or year changes
if (angular.element(e.target).hasClass('month') || angular.element(e.target).hasClass('year')) {
combo.fillCombo('day');
}
});
}
this.$widget.find('select').css('width', 'auto');
// hide original input and insert widget
this.$element.css('display', 'none').after(this.$widget);
// set initial value
this.setValue(this.$element.val() || this.options.value);
},
/*
Replace tokens in template with <select> elements
*/
getTemplate: function() {
var tpl = this.options.template;
var customClass = this.options.customClass;
//first pass
angular.forEach(this.map, function(v, k) {
v = v[0];
var r = new RegExp(v+'+');
var token = v.length > 1 ? v.substring(1, 2) : v;
tpl = tpl.replace(r, '{'+token+'}');
});
//replace spaces with
tpl = tpl.replace(/ /g, ' ');
//second pass
angular.forEach(this.map, function(v, k) {
v = v[0];
var token = v.length > 1 ? v.substring(1, 2) : v;
tpl = tpl.replace('{'+token+'}', '<select class="'+k+' '+customClass+'"></select>');
});
return tpl;
},
/*
Initialize combos that presents in template
*/
initCombos: function() {
for (var k in this.map) {
var c = this.$widget[0].querySelectorAll('.'+k);
// set properties like this.$day, this.$month etc.
this['$'+k] = c.length ? angular.element(c) : null;
// fill with items
this.fillCombo(k);
}
},
/*
Fill combo with items
*/
fillCombo: function(k) {
var $combo = this['$'+k];
if (!$combo) {
return;
}
// define method name to fill items, e.g `fillDays`
var f = 'fill' + k.charAt(0).toUpperCase() + k.slice(1);
var items = this[f]();
var value = $combo.val();
$combo.html('');
for(var i=0; i<items.length; i++) {
$combo.append('<option value="'+items[i][0]+'">'+items[i][1]+'</option>');
}
$combo.val(value);
},
/*
Initialize items of combos. Handles `firstItem` option
*/
fillCommon: function(key) {
var values = [], relTime;
if(this.options.firstItem === 'name') {
//need both to support moment ver < 2 and >= 2
relTime = moment.relativeTime || moment.langData()._relativeTime;
var header = typeof relTime[key] === 'function' ? relTime[key](1, true, key, false) : relTime[key];
//take last entry (see momentjs lang files structure)
header = header.split(' ').reverse()[0];
values.push(['', header]);
} else if(this.options.firstItem === 'empty') {
values.push(['', '']);
}
return values;
},
/*
fill day
*/
fillDay: function() {
var items = this.fillCommon('d'), name, i,
twoDigit = this.options.template.indexOf('DD') !== -1,
daysCount = 31;
// detect days count (depends on month and year)
// originally https://github.com/vitalets/combodate/pull/7
if (this.options.smartDays && this.$month && this.$year) {
var month = parseInt(this.$month.val(), 10);
var year = parseInt(this.$year.val(), 10);
if (!isNaN(month) && !isNaN(year)) {
daysCount = moment([year, month]).daysInMonth();
}
}
for (i = 1; i <= daysCount; i++) {
name = twoDigit ? this.leadZero(i) : i;
items.push([i, name]);
}
return items;
},
/*
fill month
*/
fillMonth: function() {
var items = this.fillCommon('M'), name, i,
longNames = this.options.template.indexOf('MMMM') !== -1,
shortNames = this.options.template.indexOf('MMM') !== -1,
twoDigit = this.options.template.indexOf('MM') !== -1;
for(i=0; i<=11; i++) {
if(longNames) {
//see https://github.com/timrwood/momentjs.com/pull/36
name = moment().date(1).month(i).format('MMMM');
} else if(shortNames) {
name = moment().date(1).month(i).format('MMM');
} else if(twoDigit) {
name = this.leadZero(i+1);
} else {
name = i+1;
}
items.push([i, name]);
}
return items;
},
/*
fill year
*/
fillYear: function() {
var items = [], name, i,
longNames = this.options.template.indexOf('YYYY') !== -1;
for(i=this.options.maxYear; i>=this.options.minYear; i--) {
name = longNames ? i : (i+'').substring(2);
items[this.options.yearDescending ? 'push' : 'unshift']([i, name]);
}
items = this.fillCommon('y').concat(items);
return items;
},
/*
fill hour
*/
fillHour: function() {
var items = this.fillCommon('h'), name, i,
h12 = this.options.template.indexOf('h') !== -1,
h24 = this.options.template.indexOf('H') !== -1,
twoDigit = this.options.template.toLowerCase().indexOf('hh') !== -1,
min = h12 ? 1 : 0,
max = h12 ? 12 : 23;
for(i=min; i<=max; i++) {
name = twoDigit ? this.leadZero(i) : i;
items.push([i, name]);
}
return items;
},
/*
fill minute
*/
fillMinute: function() {
var items = this.fillCommon('m'), name, i,
twoDigit = this.options.template.indexOf('mm') !== -1;
for(i=0; i<=59; i+= this.options.minuteStep) {
name = twoDigit ? this.leadZero(i) : i;
items.push([i, name]);
}
return items;
},
/*
fill second
*/
fillSecond: function() {
var items = this.fillCommon('s'), name, i,
twoDigit = this.options.template.indexOf('ss') !== -1;
for(i=0; i<=59; i+= this.options.secondStep) {
name = twoDigit ? this.leadZero(i) : i;
items.push([i, name]);
}
return items;
},
/*
fill ampm
*/
fillAmpm: function() {
var ampmL = this.options.template.indexOf('a') !== -1,
ampmU = this.options.template.indexOf('A') !== -1,
items = [
['am', ampmL ? 'am' : 'AM'],
['pm', ampmL ? 'pm' : 'PM']
];
return items;
},
/*
Returns current date value from combos.
If format not specified - `options.format` used.
If format = `null` - Moment object returned.
*/
getValue: function(format) {
var dt, values = {},
that = this,
notSelected = false;
//getting selected values
angular.forEach(this.map, function(v, k) {
if(k === 'ampm') {
return;
}
var def = k === 'day' ? 1 : 0;
values[k] = that['$'+k] ? parseInt(that['$'+k].val(), 10) : def;
if(isNaN(values[k])) {
notSelected = true;
return false;
}
});
//if at least one visible combo not selected - return empty string
if(notSelected) {
return '';
}
//convert hours 12h --> 24h
if(this.$ampm) {
//12:00 pm --> 12:00 (24-h format, midday), 12:00 am --> 00:00 (24-h format, midnight, start of day)
if(values.hour === 12) {
values.hour = this.$ampm.val() === 'am' ? 0 : 12;
} else {
values.hour = this.$ampm.val() === 'am' ? values.hour : values.hour+12;
}
}
dt = moment([values.year, values.month, values.day, values.hour, values.minute, values.second]);
//highlight invalid date
this.highlight(dt);
format = format === undefined ? this.options.format : format;
if(format === null) {
return dt.isValid() ? dt : null;
} else {
return dt.isValid() ? dt.format(format) : '';
}
},
setValue: function(value) {
if(!value) {
return;
}
// parse in strict mode (third param `true`)
var dt = typeof value === 'string' ? moment(value, this.options.format, true) : moment(value),
that = this,
values = {};
//function to find nearest value in select options
function getNearest($select, value) {
var delta = {};
angular.forEach($select.children('option'), function(opt, i){
var optValue = angular.element(opt).attr('value');
if(optValue === '') return;
var distance = Math.abs(optValue - value);
if(typeof delta.distance === 'undefined' || distance < delta.distance) {
delta = {value: optValue, distance: distance};
}
});
return delta.value;
}
if(dt.isValid()) {
//read values from date object
angular.forEach(this.map, function(v, k) {
if(k === 'ampm') {
return;
}
values[k] = dt[v[1]]();
});
if(this.$ampm) {
//12:00 pm --> 12:00 (24-h format, midday), 12:00 am --> 00:00 (24-h format, midnight, start of day)
if(values.hour >= 12) {
values.ampm = 'pm';
if(values.hour > 12) {
values.hour -= 12;
}
} else {
values.ampm = 'am';
if(values.hour === 0) {
values.hour = 12;
}
}
}
angular.forEach(values, function(v, k) {
//call val() for each existing combo, e.g. this.$hour.val()
if(that['$'+k]) {
if(k === 'minute' && that.options.minuteStep > 1 && that.options.roundTime) {
v = getNearest(that['$'+k], v);
}
if(k === 'second' && that.options.secondStep > 1 && that.options.roundTime) {
v = getNearest(that['$'+k], v);
}
that['$'+k].val(v);
}
});
// update days count
if (this.options.smartDays) {
this.fillCombo('day');
}
this.$element.val(dt.format(this.options.format)).triggerHandler('change');
}
},
/*
highlight combos if date is invalid
*/
highlight: function(dt) {
if(!dt.isValid()) {
if(this.options.errorClass) {
this.$widget.addClass(this.options.errorClass);
} else {
//store original border color
if(!this.borderColor) {
this.borderColor = this.$widget.find('select').css('border-color');
}
this.$widget.find('select').css('border-color', 'red');
}
} else {
if(this.options.errorClass) {
this.$widget.removeClass(this.options.errorClass);
} else {
this.$widget.find('select').css('border-color', this.borderColor);
}
}
},
leadZero: function(v) {
return v <= 9 ? '0' + v : v;
},
destroy: function() {
this.$widget.remove();
this.$element.removeData('combodate').show();
}
};
return {
getInstance: function(element, options) {
return new Combodate(element, options);
}
};
}]);
/*
Editable icons:
- default
- font-awesome
*/
angular.module('xeditable').factory('editableIcons', function() {
var icons = {
//Icon-set to use, defaults to bootstrap icons
default: {
'bs2': {
ok: 'icon-ok icon-white',
cancel: 'icon-remove'
},
'bs3': {
ok: 'glyphicon glyphicon-ok',
cancel: 'glyphicon glyphicon-remove'
}
},
external: {
'font-awesome': {
ok: 'fa fa-check',
cancel: 'fa fa-times'
}
}
};
return icons;
});
/*
Editable themes:
- default
- bootstrap 2
- bootstrap 3
Note: in postrender() `this` is instance of editableController
*/
angular.module('xeditable').factory('editableThemes', function() {
var themes = {
//default
'default': {
formTpl: '<form class="editable-wrap"></form>',
noformTpl: '<span class="editable-wrap"></span>',
controlsTpl: '<span class="editable-controls"></span>',
inputTpl: '',
errorTpl: '<div class="editable-error" ng-show="$error" ng-bind="$error"></div>',
buttonsTpl: '<span class="editable-buttons"></span>',
submitTpl: '<button type="submit">save</button>',
cancelTpl: '<button type="button" ng-click="$form.$cancel()">cancel</button>'
},
//bs2
'bs2': {
formTpl: '<form class="form-inline editable-wrap" role="form"></form>',
noformTpl: '<span class="editable-wrap"></span>',
controlsTpl: '<div class="editable-controls controls control-group" ng-class="{\'error\': $error}"></div>',
inputTpl: '',
errorTpl: '<div class="editable-error help-block" ng-show="$error" ng-bind="$error"></div>',
buttonsTpl: '<span class="editable-buttons"></span>',
submitTpl: '<button type="submit" class="btn btn-primary"><span></span></button>',
cancelTpl: '<button type="button" class="btn" ng-click="$form.$cancel()">'+
'<span></span>'+
'</button>'
},
//bs3
'bs3': {
formTpl: '<form class="form-inline editable-wrap" role="form"></form>',
noformTpl: '<span class="editable-wrap"></span>',
controlsTpl: '<div class="editable-controls form-group" ng-class="{\'has-error\': $error}"></div>',
inputTpl: '',
errorTpl: '<div class="editable-error help-block" ng-show="$error" ng-bind="$error"></div>',
buttonsTpl: '<span class="editable-buttons"></span>',
submitTpl: '<button type="submit" class="btn btn-primary"><span></span></button>',
cancelTpl: '<button type="button" class="btn btn-default" ng-click="$form.$cancel()">'+
'<span></span>'+
'</button>',
//bs3 specific prop to change buttons class: btn-sm, btn-lg
buttonsClass: '',
//bs3 specific prop to change standard inputs class: input-sm, input-lg
inputClass: '',
postrender: function() {
//apply `form-control` class to std inputs
switch(this.directiveName) {
case 'editableText':
case 'editableSelect':
case 'editableTextarea':
case 'editableEmail':
case 'editableTel':
case 'editableNumber':
case 'editableUrl':
case 'editableSearch':
case 'editableDate':
case 'editableDatetime':
case 'editableBsdate':
case 'editableTime':
case 'editableMonth':
case 'editableWeek':
this.inputEl.addClass('form-control');
if(this.theme.inputClass) {
// don`t apply `input-sm` and `input-lg` to select multiple
// should be fixed in bs itself!
if(this.inputEl.attr('multiple') &&
(this.theme.inputClass === 'input-sm' || this.theme.inputClass === 'input-lg')) {
break;
}
this.inputEl.addClass(this.theme.inputClass);
}
break;
case 'editableCheckbox':
this.editorEl.addClass('checkbox');
}
//apply buttonsClass (bs3 specific!)
if(this.buttonsEl && this.theme.buttonsClass) {
this.buttonsEl.find('button').addClass(this.theme.buttonsClass);
}
}
}
};
return themes;
});