',
scope: {
field: '@formGroupValidation'
},
controller: controller,
controllerAs: 'vm',
link: function (scope, element, attrs, formCtrl) {
scope.form = formCtrl;
}
}
}
controller.$inject = ['$scope'];
function controller($scope) {
var vm = this;
vm.field = $scope.field;
vm.getValidationClass = getValidationClass;
function getValidationClass() {
if (!canBeValidated()) return '';
if (isValid()) return 'has-success';
return 'has-error';
}
function canBeValidated() {
if ($scope.form[vm.field] === undefined) return false;
return ($scope.form[vm.field].$touched || $scope.form.$submitted);
}
function isValid() {
return $scope.form[vm.field].$valid;
}
}
})();;
/*
* Lazy Load Product Images. For use on angular modules only.
*/
(function () {
function lazyLoad() {
return {
link: function (scope, element, attr) {
scope.productImages = document.querySelectorAll(".c-product-item__img-container__img");
// create an instance of IntersectionObserver
//prodWatcher = new IntersectionObserver(function (entries) {
// scope.entries = entries;
// for (var i = 0, length = scope.entries.length; i < length; i++) {
// //when image comes into view, attempt to load image.
// if (scope.entries[i].intersectionRatio > 0) {
// loadImage(scope.entries[i].target);
// prodWatcher.unobserve(entries[i].target);
// }
// }
//});
//for (var i = 0, length = scope.productImages.length; i < length; i++) {
// prodWatcher.observe(scope.productImages[i]);
//}
function loadImage(image) {
var src = image.getAttribute("data-src");
image.setAttribute("src", src);
image.onerror = function () {
image.setAttribute("src", "/assets/theme/tfs/images/noimagefound.jpg");
}
}
}
}
};
window.app.directive('lazyLoad', lazyLoad);
})(window.app);
;
/*
jQuery UI Sortable plugin wrapper
@param [ui-sortable] {object} Options to pass to $.fn.sortable() merged onto ui.config
*/
angular.module('ui.sortable', [])
.value('uiSortableConfig', {
// the default for jquery-ui sortable is "> *", we need to restrict this to
// ng-repeat items
// if the user uses
items: '> [ng-repeat],> [data-ng-repeat],> [x-ng-repeat]'
})
.directive('uiSortable', [
'uiSortableConfig', '$timeout', '$log',
function (uiSortableConfig, $timeout, $log) {
return {
require: '?ngModel',
scope: {
ngModel: '=',
uiSortable: '='
},
link: function (scope, element, attrs, ngModel) {
var savedNodes;
function combineCallbacks(first, second) {
var firstIsFunc = first && (typeof first === 'function');
var secondIsFunc = second && (typeof second === 'function');
if (firstIsFunc && secondIsFunc) {
return function () {
first.apply(this, arguments);
second.apply(this, arguments);
};
} else if (secondIsFunc) {
return second;
}
return first;
}
function getSortableWidgetInstance(element) {
// this is a fix to support jquery-ui prior to v1.11.x
// otherwise we should be using `element.sortable('instance')`
var data = element.data('ui-sortable');
if (data && typeof data === 'object' && data.widgetFullName === 'ui-sortable') {
return data;
}
return null;
}
function patchSortableOption(key, value) {
if (callbacks[key]) {
if (key === 'stop') {
// call apply after stop
value = combineCallbacks(
value, function () { scope.$apply(); });
value = combineCallbacks(value, afterStop);
}
// wrap the callback
value = combineCallbacks(callbacks[key], value);
} else if (wrappers[key]) {
value = wrappers[key](value);
}
// patch the options that need to have values set
if (!value) {
if (key === 'items') {
value = uiSortableConfig.items;
} else if (key === 'ui-model-items') {
value = uiSortableConfig.items;
}
}
return value;
}
function patchUISortableOptions(newVal, oldVal, sortableWidgetInstance) {
function addDummyOptionKey(value, key) {
if (!(key in opts)) {
// add the key in the opts object so that
// the patch function detects and handles it
opts[key] = null;
}
}
// for this directive to work we have to attach some callbacks
angular.forEach(callbacks, addDummyOptionKey);
// only initialize it in case we have to
// update some options of the sortable
var optsDiff = null;
if (oldVal) {
// reset deleted options to default
var defaultOptions;
angular.forEach(oldVal, function (oldValue, key) {
if (!newVal || !(key in newVal)) {
if (key in directiveOpts) {
if (key === 'ui-floating') {
opts[key] = 'auto';
} else {
opts[key] = patchSortableOption(key, undefined);
}
return;
}
if (!defaultOptions) {
defaultOptions = angular.element.ui.sortable().options;
}
var defaultValue = defaultOptions[key];
defaultValue = patchSortableOption(key, defaultValue);
if (!optsDiff) {
optsDiff = {};
}
optsDiff[key] = defaultValue;
opts[key] = defaultValue;
}
});
}
// update changed options
angular.forEach(newVal, function (value, key) {
// if it's a custom option of the directive,
// handle it approprietly
if (key in directiveOpts) {
if (key === 'ui-floating' && (value === false || value === true) && sortableWidgetInstance) {
sortableWidgetInstance.floating = value;
}
opts[key] = patchSortableOption(key, value);
return;
}
value = patchSortableOption(key, value);
if (!optsDiff) {
optsDiff = {};
}
optsDiff[key] = value;
opts[key] = value;
});
return optsDiff;
}
function getPlaceholderElement(element) {
var placeholder = element.sortable('option', 'placeholder');
// placeholder.element will be a function if the placeholder, has
// been created (placeholder will be an object). If it hasn't
// been created, either placeholder will be false if no
// placeholder class was given or placeholder.element will be
// undefined if a class was given (placeholder will be a string)
if (placeholder && placeholder.element && typeof placeholder.element === 'function') {
var result = placeholder.element();
// workaround for jquery ui 1.9.x,
// not returning jquery collection
result = angular.element(result);
return result;
}
return null;
}
function getPlaceholderExcludesludes(element, placeholder) {
// exact match with the placeholder's class attribute to handle
// the case that multiple connected sortables exist and
// the placeholder option equals the class of sortable items
var notCssSelector = opts['ui-model-items'].replace(/[^,]*>/g, '');
var excludes = element.find('[class="' + placeholder.attr('class') + '"]:not(' + notCssSelector + ')');
return excludes;
}
function hasSortingHelper(element, ui) {
var helperOption = element.sortable('option', 'helper');
return helperOption === 'clone' || (typeof helperOption === 'function' && ui.item.sortable.isCustomHelperUsed());
}
function getSortingHelper(element, ui, savedNodes) {
var result = null;
if (hasSortingHelper(element, ui) &&
element.sortable('option', 'appendTo') === 'parent') {
// The .ui-sortable-helper element (that's the default class name)
// is placed last.
result = savedNodes.last();
}
return result;
}
// thanks jquery-ui
function isFloating(item) {
return (/left|right/).test(item.css('float')) || (/inline|table-cell/).test(item.css('display'));
}
function getElementScope(elementScopes, element) {
var result = null;
for (var i = 0; i < elementScopes.length; i++) {
var x = elementScopes[i];
if (x.element[0] === element[0]) {
result = x.scope;
break;
}
}
return result;
}
function afterStop(e, ui) {
ui.item.sortable._destroy();
}
// return the index of ui.item among the items
// we can't just do ui.item.index() because there it might have siblings
// which are not items
function getItemIndex(ui) {
return ui.item.parent()
.find(opts['ui-model-items'])
.index(ui.item);
}
var opts = {};
// directive specific options
var directiveOpts = {
'ui-floating': undefined,
'ui-model-items': uiSortableConfig.items
};
var callbacks = {
receive: null,
remove: null,
start: null,
stop: null,
update: null
};
var wrappers = {
helper: null
};
angular.extend(opts, directiveOpts, uiSortableConfig, scope.uiSortable);
if (!angular.element.fn || !angular.element.fn.jquery) {
$log.error('ui.sortable: jQuery should be included before AngularJS!');
return;
}
function wireUp() {
// When we add or remove elements, we need the sortable to 'refresh'
// so it can find the new/removed elements.
scope.$watchCollection('ngModel', function () {
// Timeout to let ng-repeat modify the DOM
$timeout(function () {
// ensure that the jquery-ui-sortable widget instance
// is still bound to the directive's element
if (!!getSortableWidgetInstance(element)) {
element.sortable('refresh');
}
}, 0, false);
});
callbacks.start = function (e, ui) {
if (opts['ui-floating'] === 'auto') {
// since the drag has started, the element will be
// absolutely positioned, so we check its siblings
var siblings = ui.item.siblings();
var sortableWidgetInstance = getSortableWidgetInstance(angular.element(e.target));
sortableWidgetInstance.floating = isFloating(siblings);
}
// Save the starting position of dragged item
var index = getItemIndex(ui);
ui.item.sortable = {
model: ngModel.$modelValue[index],
index: index,
source: ui.item.parent(),
sourceModel: ngModel.$modelValue,
cancel: function () {
ui.item.sortable._isCanceled = true;
},
isCanceled: function () {
return ui.item.sortable._isCanceled;
},
isCustomHelperUsed: function () {
return !!ui.item.sortable._isCustomHelperUsed;
},
_isCanceled: false,
_isCustomHelperUsed: ui.item.sortable._isCustomHelperUsed,
_destroy: function () {
angular.forEach(ui.item.sortable, function (value, key) {
ui.item.sortable[key] = undefined;
});
}
};
};
callbacks.activate = function (e, ui) {
// We need to make a copy of the current element's contents so
// we can restore it after sortable has messed it up.
// This is inside activate (instead of start) in order to save
// both lists when dragging between connected lists.
savedNodes = element.contents();
// If this list has a placeholder (the connected lists won't),
// don't inlcude it in saved nodes.
var placeholder = getPlaceholderElement(element);
if (placeholder && placeholder.length) {
var excludes = getPlaceholderExcludesludes(element, placeholder);
savedNodes = savedNodes.not(excludes);
}
// save the directive's scope so that it is accessible from ui.item.sortable
var connectedSortables = ui.item.sortable._connectedSortables || [];
connectedSortables.push({
element: element,
scope: scope
});
ui.item.sortable._connectedSortables = connectedSortables;
};
callbacks.update = function (e, ui) {
// Save current drop position but only if this is not a second
// update that happens when moving between lists because then
// the value will be overwritten with the old value
if (!ui.item.sortable.received) {
ui.item.sortable.dropindex = getItemIndex(ui);
var droptarget = ui.item.parent();
ui.item.sortable.droptarget = droptarget;
var droptargetScope = getElementScope(ui.item.sortable._connectedSortables, droptarget);
ui.item.sortable.droptargetModel = droptargetScope.ngModel;
// Cancel the sort (let ng-repeat do the sort for us)
// Don't cancel if this is the received list because it has
// already been canceled in the other list, and trying to cancel
// here will mess up the DOM.
element.sortable('cancel');
}
// Put the nodes back exactly the way they started (this is very
// important because ng-repeat uses comment elements to delineate
// the start and stop of repeat sections and sortable doesn't
// respect their order (even if we cancel, the order of the
// comments are still messed up).
var sortingHelper = !ui.item.sortable.received && getSortingHelper(element, ui, savedNodes);
if (sortingHelper && sortingHelper.length) {
// Restore all the savedNodes except from the sorting helper element.
// That way it will be garbage collected.
savedNodes = savedNodes.not(sortingHelper);
}
savedNodes.appendTo(element);
// If this is the target connected list then
// it's safe to clear the restored nodes since:
// update is currently running and
// stop is not called for the target list.
if (ui.item.sortable.received) {
savedNodes = null;
}
// If received is true (an item was dropped in from another list)
// then we add the new item to this list otherwise wait until the
// stop event where we will know if it was a sort or item was
// moved here from another list
if (ui.item.sortable.received && !ui.item.sortable.isCanceled()) {
scope.$apply(function () {
ngModel.$modelValue.splice(ui.item.sortable.dropindex, 0,
ui.item.sortable.moved);
});
}
};
callbacks.stop = function (e, ui) {
// If the received flag hasn't be set on the item, this is a
// normal sort, if dropindex is set, the item was moved, so move
// the items in the list.
if (!ui.item.sortable.received &&
('dropindex' in ui.item.sortable) &&
!ui.item.sortable.isCanceled()) {
scope.$apply(function () {
ngModel.$modelValue.splice(
ui.item.sortable.dropindex, 0,
ngModel.$modelValue.splice(ui.item.sortable.index, 1)[0]);
});
} else {
// if the item was not moved, then restore the elements
// so that the ngRepeat's comment are correct.
if ((!('dropindex' in ui.item.sortable) || ui.item.sortable.isCanceled()) &&
!angular.equals(element.contents(), savedNodes)) {
var sortingHelper = getSortingHelper(element, ui, savedNodes);
if (sortingHelper && sortingHelper.length) {
// Restore all the savedNodes except from the sorting helper element.
// That way it will be garbage collected.
savedNodes = savedNodes.not(sortingHelper);
}
savedNodes.appendTo(element);
}
}
// It's now safe to clear the savedNodes
// since stop is the last callback.
savedNodes = null;
};
callbacks.receive = function (e, ui) {
// An item was dropped here from another list, set a flag on the
// item.
ui.item.sortable.received = true;
};
callbacks.remove = function (e, ui) {
// Workaround for a problem observed in nested connected lists.
// There should be an 'update' event before 'remove' when moving
// elements. If the event did not fire, cancel sorting.
if (!('dropindex' in ui.item.sortable)) {
element.sortable('cancel');
ui.item.sortable.cancel();
}
// Remove the item from this list's model and copy data into item,
// so the next list can retrive it
if (!ui.item.sortable.isCanceled()) {
scope.$apply(function () {
ui.item.sortable.moved = ngModel.$modelValue.splice(
ui.item.sortable.index, 1)[0];
});
}
};
wrappers.helper = function (inner) {
if (inner && typeof inner === 'function') {
return function (e, item) {
var innerResult = inner.apply(this, arguments);
item.sortable._isCustomHelperUsed = item !== innerResult;
return innerResult;
};
}
return inner;
};
scope.$watchCollection('uiSortable', function (newVal, oldVal) {
// ensure that the jquery-ui-sortable widget instance
// is still bound to the directive's element
var sortableWidgetInstance = getSortableWidgetInstance(element);
if (!!sortableWidgetInstance) {
var optsDiff = patchUISortableOptions(newVal, oldVal, sortableWidgetInstance);
if (optsDiff) {
element.sortable('option', optsDiff);
}
}
}, true);
patchUISortableOptions(opts);
}
function init() {
if (ngModel) {
wireUp();
} else {
$log.info('ui.sortable: ngModel not provided!', element);
}
// Create sortable
element.sortable(opts);
}
function initIfEnabled() {
if (scope.uiSortable && scope.uiSortable.disabled) {
return false;
}
init();
// Stop Watcher
initIfEnabled.cancelWatcher();
initIfEnabled.cancelWatcher = angular.noop;
return true;
}
initIfEnabled.cancelWatcher = angular.noop;
if (!initIfEnabled()) {
initIfEnabled.cancelWatcher = scope.$watch('uiSortable.disabled', initIfEnabled);
}
}
};
}
]);;
(function () {
'use strict';
/**
* Set Class When At Top
*/
// var app = angular.module('app', []);
angular.module('numbersOnly', []).directive('numbersOnly', function () {
return {
require: 'ngModel',
link: function (scope, element, attr, ngModelCtrl) {
element.on('keydown', function (event) {
var $input = $(this);
var value = $input.val();
value = value.replace(/[^0-9]/g, '')
$input.val(value);
if (event.which == 64 || event.which == 16) {
// to allow numbers
return false;
} else if (event.which >= 48 && event.which <= 57) {
// to allow numbers
return true;
} else if (event.which >= 96 && event.which <= 105) {
// to allow numpad number
return true;
} else if ([8, 13, 27, 37, 38, 39, 40].indexOf(event.which) > -1) {
// to allow backspace, enter, escape, arrows
return true;
} else {
event.preventDefault();
// to stop others
//alert("Sorry Only Numbers Allowed");
return false;
}
});
//ngModelCtrl.$parsers.push(fromUser);
}
};
});
}());;
/**
* @ngDoc directive
* @name ng.directive:paging
*
* @description
* A directive to aid in paging large datasets
* while requiring a small amount of page
* information.
*
* @element EA
*
*/
angular.module('bw.paging', []).directive('paging', function () {
/**
* The regex expression to use for any replace methods
* Feel free to tweak / fork values for your application
*/
var regex = /\{page\}/g;
/**
* The angular return value required for the directive
* Feel free to tweak / fork values for your application
*/
return {
// Restrict to elements and attributes
restrict: 'EA',
// Assign the angular link function
link: fieldLink,
// Assign the angular directive template HTML
template: fieldTemplate,
// Assign the angular scope attribute formatting
scope: {
page: '=?page',
pageSize: '=?pageSize',
total: '=?total',
totalRecord: '=?totalRecord',
disabled: '@',
dots: '@',
ulClass: '@',
activeClass: '@',
disabledClass: '@',
adjacent: '@',
pagingAction: '&',
pgHref: '@',
textFirst: '@',
textLast: '@',
textNext: '@',
textPrev: '@',
textFirstClass: '@',
textLastClass: '@',
textNextClass: '@',
textPrevClass: '@',
textTitlePage: '@',
textTitleFirst: '@',
textTitleLast: '@',
textTitleNext: '@',
textTitlePrev: '@'
}
};
/**
* Link the directive to enable our scope watch values
*
* @param {object} scope - Angular link scope
* @param {object} el - Angular link element
* @param {object} attrs - Angular link attribute
*/
function fieldLink(scope, el, attrs) {
// Hook in our watched items
scope.$watchCollection('[page,pageSize,total,disabled,totalRecord]', function () {
build(scope, attrs);
});
}
/**
* Create our template html
* We use a function to figure out how to handle href correctly
*
* @param {object} el - Angular link element
* @param {object} attrs - Angular link attribute
*/
function fieldTemplate(el, attrs) {
return '
'
}
/**
* Assign default scope values from settings
* Feel free to tweak / fork these for your application
*
* @param {Object} scope - The local directive scope object
* @param {Object} attrs - The local directive attribute object
*/
function setScopeValues(scope, attrs) {
scope.List = [];
scope.Hide = false;
if (scope.List != undefined && scope.List != null && scope.List.length > 0) {
scope.currentPage = scope.List[0].currentPage;
}
scope.page = parseInt(scope.page) || 1;
scope.total = parseInt(scope.total) || 0;
scope.totalRecord = parseInt(scope.totalRecord) || 0;
scope.adjacent = parseInt(scope.adjacent) || 1;
scope.pgHref = scope.pgHref || '';
scope.dots = scope.dots || '...';
scope.ulClass = scope.ulClass || 'pagination';
scope.activeClass = scope.activeClass || 'active';
scope.disabledClass = scope.disabledClass || 'disabled';
scope.textFirst = scope.textFirst || 'First';
scope.textLast = scope.textLast || 'Last';
scope.textNext = scope.textNext || 'Next';
scope.textPrev = scope.textPrev || 'Prev';
scope.textFirstClass = scope.textFirstClass || '';
scope.textLastClass = scope.textLastClass || '';
scope.textNextClass = scope.textNextClass || '';
scope.textPrevClass = scope.textPrevClass || '';
scope.textTitlePage = scope.textTitlePage || 'Page {page}';
scope.textTitleFirst = scope.textTitleFirst || 'First Page';
scope.textTitleLast = scope.textTitleLast || 'Last Page';
scope.textTitleNext = scope.textTitleNext || 'Next Page';
scope.textTitlePrev = scope.textTitlePrev || 'Previous Page';
scope.hideIfEmpty = evalBoolAttribute(scope, attrs.hideIfEmpty);
scope.showPrevNext = evalBoolAttribute(scope, attrs.showPrevNext);
scope.showFirstLast = evalBoolAttribute(scope, attrs.showFirstLast);
scope.scrollTop = evalBoolAttribute(scope, attrs.scrollTop);
scope.isDisabled = evalBoolAttribute(scope, attrs.disabled);
}
/**
* A helper to perform our boolean eval on attributes
* This allows flexibility in the attribute for strings and variables in scope
*
* @param {Object} scope - The local directive scope object
* @param {Object} value - The attribute value of interest
*/
function evalBoolAttribute(scope, value) {
return angular.isDefined(value)
? !!scope.$parent.$eval(value)
: false;
}
/**
* Validate and clean up any scope values
* This happens after we have set the scope values
*
* @param {Object} scope - The local directive scope object
* @param {int} pageCount - The last page number or total page count
*/
function validateScopeValues(scope, pageCount) {
// Block where the page is larger than the pageCount
if (scope.page > pageCount) {
scope.page = pageCount;
}
// Block where the page is less than 0
if (scope.page <= 0) {
scope.page = 1;
}
// Block where adjacent value is 0 or below
if (scope.adjacent <= 0) {
scope.adjacent = 2;
}
// Hide from page if we have 1 or less pages
// if directed to hide empty
if (pageCount <= 1) {
scope.Hide = scope.hideIfEmpty;
}
}
/**
* Assign the method action to take when a page is clicked
*
* @param {Object} scope - The local directive scope object
* @param {int} page - The current page of interest
*/
function internalAction(scope, page) {
// Block clicks we try to load the active page
if (scope.page == page) {
return;
}
// Block if we are forcing disabled
if (scope.isDisabled) {
return;
}
// Update the page in scope
scope.page = page;
// Pass our parameters to the paging action
scope.pagingAction({
page: scope.page,
pageSize: scope.pageSize,
total: scope.total,
totalRecord: scope.totalRecord
});
// If allowed scroll up to the top of the page
if (scope.scrollTop) {
scrollTo(0, 0);
}
}
/**
* Add the first, previous, next, and last buttons if desired
* The logic is defined by the mode of interest
* This method will simply return if the scope.showPrevNext is false
* This method will simply return if there are no pages to display
*
* @param {Object} scope - The local directive scope object
* @param {int} pageCount - The last page number or total page count
* @param {string} mode - The mode of interest either prev or last
*/
function addPrevNext(scope, pageCount, mode) {
// Ignore if we are not showing
// or there are no pages to display
if ((!scope.showPrevNext && !scope.showFirstLast) || pageCount < 1) {
return;
}
// Local variables to help determine logic
var disabled, alpha, beta;
// Determine logic based on the mode of interest
// Calculate the previous / next page and if the click actions are allowed
if (mode === 'prev') {
disabled = scope.page - 1 <= 0;
var prevPage = scope.page - 1 <= 0 ? 1 : scope.page - 1;
if (scope.showFirstLast == true && disabled == false) {
alpha = {
value: scope.textFirst,
title: scope.textTitleFirst,
aClass: scope.textFirstClass,
page: 1
};
}
if (scope.showPrevNext == true && disabled==false) {
beta = {
value: scope.textPrev,
title: scope.textTitlePrev,
aClass: scope.textPrevClass,
page: prevPage
};
}
} else {
disabled = scope.page + 1 > pageCount;
var nextPage = scope.page + 1 >= pageCount ? pageCount : scope.page + 1;
if (scope.showPrevNext == true && disabled == false) {
alpha = {
value: scope.textNext,
title: scope.textTitleNext,
aClass: scope.textNextClass,
page: nextPage
};
}
if (scope.showFirstLast == true && disabled == false) {
beta = {
value: scope.textLast,
title: scope.textTitleLast,
aClass: scope.textLastClass,
page: pageCount
};
}
}
// Create the Add Item Function
var buildItem = function (item, disabled) {
return {
title: item.title,
aClass: item.aClass,
value: item.aClass ? '' : item.value,
liClass: disabled ? scope.disabledClass : '',
pgHref: disabled ? '' : scope.pgHref.replace(regex, item.page),
action: function () {
if (!disabled) {
internalAction(scope, item.page);
}
}
};
};
// Force disabled if specified
if (scope.isDisabled) {
disabled = true;
}
// Add alpha items
if (alpha) {
var alphaItem = buildItem(alpha, disabled);
scope.List.push(alphaItem);
}
// Add beta items
if (beta) {
var betaItem = buildItem(beta, disabled);
scope.List.push(betaItem);
}
}
/**
* Adds a range of numbers to our list
* The range is dependent on the start and finish parameters
*
* @param {int} start - The start of the range to add to the paging list
* @param {int} finish - The end of the range to add to the paging list
* @param {Object} scope - The local directive scope object
*/
function addRange(start, finish, scope) {
// Add our items where i is the page number
var i = 0;
for (i = start; i <= finish; i++) {
var pgHref = scope.pgHref.replace(regex, i);
var liClass = scope.page == i ? scope.activeClass : '';
// Handle items that are affected by disabled
if (scope.isDisabled) {
pgHref = '';
liClass = scope.disabledClass;
}
scope.List.push({
value: i,
title: scope.textTitlePage.replace(regex, i),
liClass: liClass,
pgHref: pgHref,
action: function () {
internalAction(scope, this.value);
}
});
}
}
/**
* Add Dots ie: 1 2 [...] 10 11 12 [...] 56 57
* This is my favorite function not going to lie
*
* @param {Object} scope - The local directive scope object
*/
function addDots(scope) {
scope.List.push({
value: scope.dots,
liClass: scope.disabledClass
});
}
/**
* Add the first or beginning items in our paging list
* We leverage the 'next' parameter to determine if the dots are required
*
* @param {Object} scope - The local directive scope object
* @param {int} next - the next page number in the paging sequence
*/
function addFirst(scope, next) {
addRange(1, 1, scope);
// We ignore dots if the next value is 3
// ie: 1 2 [...] 3 4 5 becomes just 1 2 3 4 5
if (next != 2) {
addDots(scope);
}
}
/**
* Add the last or end items in our paging list
* We leverage the 'prev' parameter to determine if the dots are required
*
* @param {int} pageCount - The last page number or total page count
* @param {Object} scope - The local directive scope object
* @param {int} prev - the previous page number in the paging sequence
*/
// Add Last Pages
function addLast(pageCount, scope, prev) {
// We ignore dots if the previous value is one less that our start range
// ie: 1 2 3 4 [...] 5 6 becomes just 1 2 3 4 5 6
if (prev != pageCount - 1) {
addDots(scope);
}
addRange(pageCount, pageCount, scope);
}
/**
* The main build function used to determine the paging logic
* Feel free to tweak / fork values for your application
*
* @param {Object} scope - The local directive scope object
* @param {Object} attrs - The local directive attribute object
*/
function build(scope, attrs) {
// Block divide by 0 and empty page size
if (!scope.pageSize || scope.pageSize <= 0) {
scope.pageSize = 1;
}
// Determine the last page or total page count
var pageCount = Math.ceil(scope.total / scope.pageSize);
// Set the default scope values where needed
setScopeValues(scope, attrs);
// Validate the scope values to protect against strange states
validateScopeValues(scope, pageCount);
// Create the beginning and end page values
var start, finish;
// Calculate the full adjacency value
var fullAdjacentSize = (scope.adjacent * 2) + 0;
// Add the Next and Previous buttons to our list
addPrevNext(scope, pageCount, 'prev');
// If the page count is less than the full adjacnet size
// Then we simply display all the pages, Otherwise we calculate the proper paging display
if (pageCount <= (fullAdjacentSize + 1)) {
start = 1;
addRange(start, pageCount, scope);
} else {
// Determine if we are showing the beginning of the paging list
// We know it is the beginning if the page - adjacent is <= 2
if (scope.page - scope.adjacent <= 2) {
start = 1;
finish = 1 + fullAdjacentSize;
addRange(start, finish, scope);
addLast(pageCount, scope, finish);
}
// Determine if we are showing the middle of the paging list
// We know we are either in the middle or at the end since the beginning is ruled out above
// So we simply check if we are not at the end
// Again 2 is hard coded as we always display two pages after the dots
else if (scope.page < pageCount - (scope.adjacent + 1)) {
start = scope.page - scope.adjacent;
finish = scope.page + scope.adjacent;
addFirst(scope, start);
addRange(start, finish, scope);
addLast(pageCount, scope, finish);
}
// If nothing else we conclude we are at the end of the paging list
// We know this since we have already ruled out the beginning and middle above
else {
start = pageCount - fullAdjacentSize;
finish = pageCount;
addFirst(scope, start);
addRange(start, finish, scope);
}
}
// Add the next and last buttons to our paging list
addPrevNext(scope, pageCount, 'next');
}
});
;
(function () {
'use strict';
window.app.directive('surveyInputField', surveyInputField);
function surveyInputField($compile) {
var TEMPLATES = {
TextInput:
'',
Multiline:
'',
RatingScale:
'',
SingleSlider: //http://angular-slider.github.io/angularjs-slider/
' ',
DoubleSlider:
' ',
AsDropdown:
' ' +
' ' +
' ',
AsText:
'
![](https://the-fragrance-shop.imgix.net/product/" + cardDetails.stockCode + "-1.jpg?h=260&w=260&max-w=260" + cardDetails.image + ")
',
link: function ($scope, elem, attrs) {
$scope.imageUrl = attrs.imageurl;
$scope.itemName = attrs.itemname;
$scope.imageType = attrs.imagetype;
$scope.imageUtil = imageUtils.filter(function (item) {
return item.ImageType === $scope.imageType;
})[0];
$scope.$watch("imageUrl", function (newValue, oldValue) {
//This gets called when data changes.
if (oldValue !== newValue) {
const img = elem.find('img');
if (img && img.hasClass('lazyloaded')) {
img.removeClass('lazyloaded');
img.addClass('ls-reloading');
img.addClass('lazyload');
}
}
});
}
};
});
}());;
(function () {
'use strict';
angular.module('btimageutilcustom', [])
.directive('btimageutilcustom', function ($parse, $http, $sce) {
return {
restrict: 'A',
template: '