<!DOCTYPE html>
<html>
<head>
<script data-require="angular.js@*" data-semver="1.2.0-rc3-nonmin" src="http://code.angularjs.org/1.2.0-rc.3/angular.js"></script>
<script data-require="ng-table@*" src="ng-table.js"></script>
<script data-require="angular-mocks@1.2.0-rc3" data-semver="1.2.0-rc3" src="//code.angularjs.org/1.2.0-rc.3/angular-mocks.js"></script>
<script data-require="angular-resource@1.2.0-rc.3" data-semver="1.2.0-rc.3" src="http://code.angularjs.org/1.2.0-rc.3/angular-resource.js"></script>
<link data-require="ng-table@*" data-semver="0.3.0" rel="stylesheet" href="http://bazalt-cms.com/assets/ng-table/0.3.0/ng-table.css" />
<link data-require="bootstrap-css@*" data-semver="3.0.0" rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" />
<link rel="stylesheet" href="style.css" />
<script src="mock.js"></script>
<script src="script.js"></script>
<script src="loadingContainer.js"></script>
</head>
<body ng-app="main" ng-controller="DemoCtrl">
<button ng-click="tableParams.reload()" class="btn btn-default">Reload</button>
<button ng-click="tableParams.sorting({})" class="btn btn-default">Clear sorting</button>
<div class="clearfix"></div>
<div loading-container="tableParams.settings().$loading">
<table ng-table="tableParams" show-filter="true" class="table">
<tbody>
<tr ng-repeat="user in $data">
<td data-title="'Name'" filter="{ 'name': 'text' }" sortable="name">
{{user.name}}
{{$loading}}
</td>
<td data-title="'Age'" sortable="age">
{{user.age}}
</td>
</tr>
</tbody>
</table>
</div>
</body>
</html>
var app = angular.module('main', ['ngTable', 'ngResource', 'DemoMock'])
.controller('DemoCtrl', function($scope, $timeout, $resource, ngTableParams) {
var Api = $resource('/data');
$scope.tableParams = new ngTableParams({
page: 1, // show first page
count: 10, // count per page
sorting: {
name: 'asc' // initial sorting
}
}, {
total: 0, // length of data
getData: function($defer, params) {
// ajax request to api
Api.get(params.url(), function(data) {
$timeout(function() {
// update table params
params.total(data.total);
// set new data
$defer.resolve(data.result);
}, 500);
});
}
});
});
body {
padding: 10px !important;
}
.loading-container {
position: relative;
}
.loading-container .loading:before, .loading-container .loading:after {
content: " ";
position: absolute;
top: 0;
left: 0;
right: 0;
bottom: 0;
min-height: 50px;
min-width: 50px;
}
.loading-container .loading:before {
background-color: white;
opacity: 0.5;
}
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
var app = angular.module('DemoMock', ['ngTable', 'ngMockE2E'])
.run(function($httpBackend, $filter, $log, ngTableParams) {
// emulation of api server
$httpBackend.whenGET(/data.*/).respond(function(method, url, data, headers) {
var query = url.split('?')[1],
requestParams = {};
$log.log('Ajax request: ', url);
var vars = query.split('&');
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split('=');
requestParams[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
}
// parse url params
for (var key in requestParams) {
if (key.indexOf('[') >= 0) {
var params = key.split(/\[(.*)\]/), value = requestParams[key], lastKey = '';
angular.forEach(params.reverse(), function(name) {
if (name != '') {
var v = value;
value = {};
value[lastKey = name] = isNumber(v) ? parseFloat(v) : v;
}
});
requestParams[lastKey] = angular.extend(requestParams[lastKey] || {}, value[lastKey]);
} else {
requestParams[key] = isNumber(requestParams[key]) ? parseFloat(requestParams[key]) : requestParams[key];
}
}
data = [{name: "Moroni", age: 50},
{name: "Tiancum", age: 43},
{name: "Jacob", age: 27},
{name: "Nephi", age: 29},
{name: "Enos", age: 34},
{name: "Tiancum", age: 43},
{name: "Jacob", age: 27},
{name: "Nephi", age: 29},
{name: "Enos", age: 34},
{name: "Tiancum", age: 43},
{name: "Jacob", age: 27},
{name: "Nephi", age: 29},
{name: "Enos", age: 34},
{name: "Tiancum", age: 43},
{name: "Jacob", age: 27},
{name: "Nephi", age: 29},
{name: "Enos", age: 34}];
var params = new ngTableParams(requestParams);
data = params.filter() ? $filter('filter')(data, params.filter()) : data;
data = params.sorting() ? $filter('orderBy')(data, params.orderBy()) : data;
var total = data.length;
data = data.slice((params.page() - 1) * params.count(), params.page() * params.count());
return [200, {
result: data,
total: total
}];
});
$httpBackend.whenGET(/.*/).passThrough();
});
angular.module('main')
.directive('loadingContainer', function () {
return {
restrict: 'A',
scope: false,
link: function(scope, element, attrs) {
var loadingLayer = angular.element('<div class="loading"></div>');
element.append(loadingLayer);
element.addClass('loading-container');
scope.$watch(attrs.loadingContainer, function(value) {
loadingLayer.toggleClass('ng-hide', !value);
});
}
};
});
(function(angular, factory) {
if (typeof define === 'function' && define.amd) {
define(['angular'], function(angular) {
return factory(angular);
});
} else {
return factory(angular);
}
}(angular || null, function(angular) {
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
/**
* @ngdoc module
* @name ngTable
* @description ngTable: Table + Angular JS
* @example
<doc:example>
<doc:source>
<script>
var app = angular.module('myApp', ['ngTable']);
app.controller('MyCtrl', function($scope) {
$scope.users = [
{name: "Moroni", age: 50},
{name: "Tiancum", age: 43},
{name: "Jacob", age: 27},
{name: "Nephi", age: 29},
{name: "Enos", age: 34}
];
});
</script>
<table ng-table class="table">
<tr ng-repeat="user in users">
<td data-title="'Name'">{{user.name}}</td>
<td data-title="'Age'">{{user.age}}</td>
</tr>
</table>
</doc:source>
</doc:example>
*/
var app = angular.module('ngTable', []);
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
/**
* @ngdoc service
* @name ngTable.factory:ngTableParams
* @description Parameters manager for ngTable
*/
app.factory('ngTableParams', ['$q', '$log', function ($q, $log) {
var isNumber = function (n) {
return !isNaN(parseFloat(n)) && isFinite(n);
};
var ngTableParams = function (baseParameters, baseSettings) {
var self = this;
this.data = [];
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#parameters
* @methodOf ngTable.factory:ngTableParams
* @description Set new parameters or get current parameters
*
* @param {string} newParameters New parameters
* @param {string} parseParamsFromUrl Flag if parse parameters like in url
* @returns {Object} Current parameters or `this`
*/
this.parameters = function (newParameters, parseParamsFromUrl) {
parseParamsFromUrl = parseParamsFromUrl || false;
if (angular.isDefined(newParameters)) {
for (var key in newParameters) {
var value = newParameters[key];
if (parseParamsFromUrl && key.indexOf('[') >= 0) {
var keys = key.split(/\[(.*)\]/).reverse()
var lastKey = '';
for (var i = 0, len = keys.length; i < len; i++) {
var name = keys[i];
if (name !== '') {
var v = value;
value = {};
value[lastKey = name] = (isNumber(v) ? parseFloat(v) : v);
}
}
if (lastKey === 'sorting') {
params[lastKey] = {};
}
params[lastKey] = angular.extend(params[lastKey] || {}, value[lastKey]);
} else {
params[key] = (isNumber(newParameters[key]) ? parseFloat(newParameters[key]) : newParameters[key]);
}
}
$log.debug && $log.debug('ngTable: set parameters', params);
return this;
}
return params;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#settings
* @methodOf ngTable.factory:ngTableParams
* @description Set new settings for table
*
* @param {string} newSettings New settings or undefined
* @returns {Object} Current settings or `this`
*/
this.settings = function (newSettings) {
if (angular.isDefined(newSettings)) {
settings = angular.extend(settings, newSettings);
$log.debug && $log.debug('ngTable: set settings', params);
return this;
}
return settings;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#page
* @methodOf ngTable.factory:ngTableParams
* @description If parameter page not set return current page else set current page
*
* @param {string} page Page number
* @returns {Object|Number} Current page or `this`
*/
this.page = function (page) {
return angular.isDefined(page) ? this.parameters({'page': page}) : params.page;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#total
* @methodOf ngTable.factory:ngTableParams
* @description If parameter total not set return current quantity else set quantity
*
* @param {string} total Total quantity of items
* @returns {Object|Number} Current page or `this`
*/
this.total = function (total) {
return angular.isDefined(total) ? this.settings({'total': total}) : settings.total;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#count
* @methodOf ngTable.factory:ngTableParams
* @description If parameter count not set return current count per page else set count per page
*
* @param {string} count Count per number
* @returns {Object|Number} Count per page or `this`
*/
this.count = function (count) {
// reset to first page because can be blank page
return angular.isDefined(count) ? this.parameters({'count': count, 'page': 1}) : params.count;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#filter
* @methodOf ngTable.factory:ngTableParams
* @description If parameter page not set return current filter else set current filter
*
* @param {string} filter New filter
* @returns {Object} Current filter or `this`
*/
this.filter = function (filter) {
return angular.isDefined(filter) ? this.parameters({'filter': filter}) : params.filter;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#sorting
* @methodOf ngTable.factory:ngTableParams
* @description If parameter page not set return current sorting else set current sorting
*
* @param {string} sorting New sorting
* @returns {Object} Current sorting or `this`
*/
this.sorting = function (sorting) {
if (arguments.length == 2){
var sortArray = {};
sortArray[sorting] = arguments[1];
this.parameters({'sorting': sortArray});
return this;
}
return angular.isDefined(sorting) ? this.parameters({'sorting': sorting}) : params.sorting;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#isSortBy
* @methodOf ngTable.factory:ngTableParams
* @description Checks sort field
*
* @param {string} field Field name
* @param {string} direction Direction of sorting 'asc' or 'desc'
* @returns {Array} Return true if field sorted by direction
*/
this.isSortBy = function (field, direction) {
return angular.isDefined(params.sorting[field]) && params.sorting[field] == direction;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#orderBy
* @methodOf ngTable.factory:ngTableParams
* @description Return object of sorting parameters for angular filter
*
* @returns {Array} Array like: [ '-name', '+age' ]
*/
this.orderBy = function () {
var sorting = [];
for (var column in params.sorting) {
sorting.push((params.sorting[column] === "asc" ? "+" : "-") + column);
}
return sorting;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#getData
* @methodOf ngTable.factory:ngTableParams
* @description Called when updated some of parameters for get new data
*
* @param {Object} $defer promise object
* @param {Object} params New parameters
*/
this.getData = function ($defer, params) {
$defer.resolve([]);
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#getGroups
* @methodOf ngTable.factory:ngTableParams
* @description Return groups for table grouping
*/
this.getGroups = function ($defer, column) {
var defer = $q.defer();
defer.promise.then(function(data) {
var groups = {};
for (var k in data) {
var item = data[k],
groupName = angular.isFunction(column) ? column(item) : item[column];
groups[groupName] = groups[groupName] || {
data: []
};
groups[groupName]['value'] = groupName;
groups[groupName].data.push(item);
}
var result = [];
for (var i in groups) {
result.push(groups[i]);
}
$log.debug && $log.debug('ngTable: refresh groups', result);
$defer.resolve(result);
});
this.getData(defer, self);
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#generatePagesArray
* @methodOf ngTable.factory:ngTableParams
* @description Generate array of pages
*
* @param {boolean} currentPage which page must be active
* @param {boolean} totalItems Total quantity of items
* @param {boolean} pageSize Quantity of items on page
* @returns {Array} Array of pages
*/
this.generatePagesArray = function (currentPage, totalItems, pageSize) {
var maxBlocks, maxPage, maxPivotPages, minPage, numPages, pages;
maxBlocks = 11;
pages = [];
numPages = Math.ceil(totalItems / pageSize);
if (numPages > 1) {
pages.push({
type: 'prev',
number: Math.max(1, currentPage - 1),
active: currentPage > 1
});
pages.push({
type: 'first',
number: 1,
active: currentPage > 1
});
maxPivotPages = Math.round((maxBlocks - 5) / 2);
minPage = Math.max(2, currentPage - maxPivotPages);
maxPage = Math.min(numPages - 1, currentPage + maxPivotPages * 2 - (currentPage - minPage));
minPage = Math.max(2, minPage - (maxPivotPages * 2 - (maxPage - minPage)));
i = minPage;
while (i <= maxPage) {
if ((i === minPage && i !== 2) || (i === maxPage && i !== numPages - 1)) {
pages.push({
type: 'more',
active: false
});
} else {
pages.push({
type: 'page',
number: i,
active: currentPage !== i
});
}
i++;
}
pages.push({
type: 'last',
number: numPages,
active: currentPage !== numPages
});
pages.push({
type: 'next',
number: Math.min(numPages, currentPage + 1),
active: currentPage < numPages
});
}
return pages;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#url
* @methodOf ngTable.factory:ngTableParams
* @description Return groups for table grouping
*
* @param {boolean} asString flag indicates return array of string or object
* @returns {Array} If asString = true will be return array of url string parameters else key-value object
*/
this.url = function (asString) {
asString = asString || false;
var pairs = (asString ? [] : {});
for (key in params) {
if (params.hasOwnProperty(key)) {
var item = params[key],
name = encodeURIComponent(key);
if (typeof item === "object") {
for (var subkey in item) {
if (!angular.isUndefined(item[subkey]) && item[subkey] !== "") {
var pname = name + "[" + encodeURIComponent(subkey) + "]";
if (asString) {
pairs.push(pname + "=" + encodeURIComponent(item[subkey]));
} else {
pairs[pname] = encodeURIComponent(item[subkey]);
}
}
}
} else if (!angular.isFunction(item) && !angular.isUndefined(item) && item !== "") {
if (asString) {
pairs.push(name + "=" + encodeURIComponent(item));
} else {
pairs[name] = encodeURIComponent(item);
}
}
}
}
return pairs;
};
/**
* @ngdoc method
* @name ngTable.factory:ngTableParams#reload
* @methodOf ngTable.factory:ngTableParams
* @description Reload table data
*/
this.reload = function() {
var $defer = $q.defer(),
self = this;
settings.$loading = true;
if (settings.groupBy) {
settings.getGroups($defer, settings.groupBy, this);
} else {
settings.getData($defer, this);
}
$log.debug && $log.debug('ngTable: reload data');
$defer.promise.then(function(data) {
settings.$loading = false;
$log.debug && $log.debug('ngTable: current scope', settings.$scope);
if (settings.groupBy) {
self.data = settings.$scope.$groups = data;
} else {
self.data = settings.$scope.$data = data;
}
settings.$scope.pages = self.generatePagesArray(self.page(), self.total(), self.count());
});
};
this.reloadPages = function () {
var self = this;
settings.$scope.pages = self.generatePagesArray(self.page(), self.total(), self.count());
};
var params = this.$params = {
page: 1,
count: 1,
filter: {},
sorting: {},
group: {},
groupBy: null
};
var settings = {
$scope: null, // set by ngTable controller
$loading: false,
total: 0,
counts: [10, 25, 50, 100],
getGroups: this.getGroups,
getData: this.getData
};
this.settings(baseSettings);
this.parameters(baseParameters, true);
return this;
};
return ngTableParams;
}]);
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
/**
* @ngdoc object
* @name ngTable.directive:ngTable.ngTableController
*
* @description
* Each {@link ngTable.directive:ngTable ngTable} directive creates an instance of `ngTableController`
*/
var ngTableController = ['$scope', 'ngTableParams', '$q', function($scope, ngTableParams, $q) {
$scope.$loading = false;
if (!$scope.params) {
$scope.params = new ngTableParams();
}
$scope.params.settings().$scope = $scope;
$scope.$watch('params.$params', function(params) {
$scope.params.settings().$scope = $scope;
$scope.params.reload();
}, true);
$scope.sortBy = function (column) {
var parsedSortable = $scope.parse(column.sortable);
if (!parsedSortable) {
return;
}
var sorting = $scope.params.sorting() && $scope.params.sorting()[parsedSortable] && ($scope.params.sorting()[parsedSortable] === "desc");
var sortingParams = {};
sortingParams[parsedSortable] = (sorting ? 'asc' : 'desc');
$scope.params.parameters({
sorting: sortingParams
});
};
}];
/**
* ngTable: Table + Angular JS
*
* @author Vitalii Savchuk <esvit666@gmail.com>
* @url https://github.com/esvit/ng-table/
* @license New BSD License <http://creativecommons.org/licenses/BSD/>
*/
/**
* @ngdoc directive
* @name ngTable.directive:ngTable
* @restrict A
*
* @description
* Directive that instantiates {@link ngTable.directive:ngTable.ngTableController ngTableController}.
*/
app.directive('ngTable', ['$compile', '$q', '$parse',
function ($compile, $q, $parse) {
'use strict';
return {
restrict: 'A',
priority: 1001,
scope: true,
controller: ngTableController,
compile: function (element) {
var columns = [], i = 0, row = null;
// custom header
var thead = element.find('thead');
// IE 8 fix :not(.ng-table-group) selector
angular.forEach(angular.element(element.find('tr')), function(tr) {
tr = angular.element(tr);
if (!tr.hasClass('ng-table-group') && !row) {
row = tr;
}
});
if (!row) {
return;
}
angular.forEach(row.find('td'), function (item) {
var el = angular.element(item);
if (el.attr('ignore-cell') && 'true' === el.attr('ignore-cell')) {
return;
}
var parsedAttribute = function(attr, defaultValue) {
return function(scope) {
return $parse(el.attr('x-data-' + attr) || el.attr('data-' + attr) || el.attr(attr))(scope, {
$columns: columns
}) || defaultValue;
};
};
var parsedTitle = parsedAttribute('title', ' '),
headerTemplateURL = parsedAttribute('header', false),
filter = parsedAttribute('filter', false)(),
filterTemplateURL = false;
if (filter && filter.templateURL) {
filterTemplateURL = filter.templateURL;
delete filter.templateURL;
}
el.attr('data-title-text', parsedTitle()); // this used in responsive table
columns.push({
id: i++,
title: parsedTitle,
sortable: parsedAttribute('sortable', false),
class: el.attr('x-data-header-class') || el.attr('data-header-class') || el.attr("header-class"),
filter: filter,
filterTemplateURL: filterTemplateURL,
headerTemplateURL: headerTemplateURL,
filterData: (el.attr("filter-data") ? el.attr("filter-data") : null),
show: (el.attr("ng-show") ? function (scope) {
return $parse(el.attr("ng-show"))(scope);
} : function () {
return true;
})
});
});
return function (scope, element, attrs) {
scope.$loading = false;
scope.$columns = columns;
scope.$watch(attrs.ngTable, (function (params) {
if (angular.isUndefined(params)) {
return;
}
scope.paramsModel = $parse(attrs.ngTable);
scope.params = params;
}), true);
scope.parse = function (text) {
return angular.isDefined(text) ? text(scope) : '';
};
if (attrs.showFilter) {
scope.$parent.$watch(attrs.showFilter, function (value) {
scope.show_filter = value;
});
}
angular.forEach(columns, function (column) {
var def;
if (!column.filterData) {
return;
}
def = $parse(column.filterData)(scope, {
$column: column
});
if (!(angular.isObject(def) && angular.isObject(def.promise))) {
throw new Error('Function ' + column.filterData + ' must be instance of $q.defer()');
}
delete column['filterData'];
return def.promise.then(function (data) {
if (!angular.isArray(data)) {
data = [];
}
data.unshift({
title: '-',
id: ''
});
column.data = data;
});
});
if (!element.hasClass('ng-table')) {
scope.templates = {
header: (attrs.templateHeader ? attrs.templateHeader : 'ng-table/header.html'),
pagination: (attrs.templatePagination ? attrs.templatePagination : 'ng-table/pager.html')
};
var headerTemplate = thead.length > 0 ? thead : angular.element(document.createElement('thead')).attr('ng-include', 'templates.header');
var paginationTemplate = angular.element(document.createElement('div')).attr('ng-include', 'templates.pagination');
element.find('thead').remove();
var tbody = element.find('tbody');
element.prepend(headerTemplate);
$compile(headerTemplate)(scope);
$compile(paginationTemplate)(scope);
element.addClass('ng-table');
return element.after(paginationTemplate);
}
};
}
}
}
]);
angular.module('ngTable').run(['$templateCache', function ($templateCache) {
$templateCache.put('ng-table/filters/select.html', '<select ng-options="data.id as data.title for data in column.data" ng-model="params.filter()[name]" ng-show="filter==\'select\'" class="filter filter-select form-control"> </select>');
$templateCache.put('ng-table/filters/text.html', '<input type="text" ng-model="params.filter()[name]" ng-if="filter==\'text\'" class="input-filter form-control"/>');
$templateCache.put('ng-table/header.html', '<tr> <th ng-repeat="column in $columns" ng-class="{ \'sortable\': parse(column.sortable), \'sort-asc\': params.sorting()[parse(column.sortable)]==\'asc\', \'sort-desc\': params.sorting()[parse(column.sortable)]==\'desc\' }" ng-click="sortBy(column)" ng-show="column.show(this)" ng-init="template=column.headerTemplateURL(this)" class="header {{column.class}}"> <div ng-if="!template" ng-show="!template" ng-bind="parse(column.title)"></div> <div ng-if="template" ng-show="template"><div ng-include="template"></div></div> </th> </tr> <tr ng-show="show_filter" class="ng-table-filters"> <th ng-repeat="column in $columns" ng-show="column.show(this)" class="filter"> <div ng-repeat="(name, filter) in column.filter"> <div ng-if="column.filterTemplateURL" ng-show="column.filterTemplateURL"> <div ng-include="column.filterTemplateURL"></div> </div> <div ng-if="!column.filterTemplateURL" ng-show="!column.filterTemplateURL"> <div ng-include="\'ng-table/filters/\' + filter + \'.html\'"></div> </div> </div> </th> </tr>');
$templateCache.put('ng-table/pager.html', '<div class="ng-cloak"> <div ng-if="params.settings().counts.length" class="btn-group pull-right"> <button ng-repeat="count in params.settings().counts" type="button" ng-class="{\'active\':params.count()==count}" ng-click="params.count(count)" class="btn btn-default btn-xs"> <span ng-bind="count"></span> </button> </div> <ul class="pagination"> <li ng-class="{\'disabled\': !page.active}" ng-repeat="page in pages" ng-switch="page.type"> <a ng-switch-when="prev" ng-click="params.page(page.number)" href="">«</a> <a ng-switch-when="first" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="page" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="more" ng-click="params.page(page.number)" href="">…</a> <a ng-switch-when="last" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="next" ng-click="params.page(page.number)" href="">»</a> </li> </ul> </div>');
}]);
return app;
}));