diff --git a/docs-core/src/main/java/com/sismics/util/mime/MimeTypeUtil.java b/docs-core/src/main/java/com/sismics/util/mime/MimeTypeUtil.java
index f87f01a2..a8c1565b 100644
--- a/docs-core/src/main/java/com/sismics/util/mime/MimeTypeUtil.java
+++ b/docs-core/src/main/java/com/sismics/util/mime/MimeTypeUtil.java
@@ -1,7 +1,6 @@
package com.sismics.util.mime;
import java.io.InputStream;
-import java.io.PushbackInputStream;
/**
* Utility to check MIME types.
@@ -18,9 +17,9 @@ public class MimeTypeUtil {
*/
public static String guessMimeType(InputStream is) throws Exception {
byte[] headerBytes = new byte[64];
- PushbackInputStream pb = new PushbackInputStream(is, headerBytes.length);
- int readCount = pb.read(headerBytes);
- pb.unread(headerBytes);
+ is.mark(headerBytes.length);
+ int readCount = is.read(headerBytes);
+ is.reset();
if (readCount <= 0) {
throw new Exception("Cannot read input file");
diff --git a/docs-web/src/main/java/com/sismics/docs/rest/resource/DocumentResource.java b/docs-web/src/main/java/com/sismics/docs/rest/resource/DocumentResource.java
index 342a99b3..40fc896c 100644
--- a/docs-web/src/main/java/com/sismics/docs/rest/resource/DocumentResource.java
+++ b/docs-web/src/main/java/com/sismics/docs/rest/resource/DocumentResource.java
@@ -46,9 +46,10 @@ public class DocumentResource extends BaseResource {
* @throws JSONException
*/
@GET
+ @Path("{id: [a-z0-9\\-]+}")
@Produces(MediaType.APPLICATION_JSON)
public Response get(
- @QueryParam("id") String id) throws JSONException {
+ @PathParam("id") String id) throws JSONException {
if (!authenticate()) {
throw new ForbiddenClientException();
}
@@ -190,7 +191,7 @@ public class DocumentResource extends BaseResource {
// Always return ok
JSONObject response = new JSONObject();
- response.put("status", "ok");
+ response.put("id", id);
return Response.ok().entity(response).build();
}
diff --git a/docs-web/src/main/java/com/sismics/docs/rest/resource/FileResource.java b/docs-web/src/main/java/com/sismics/docs/rest/resource/FileResource.java
index 317ef3f8..e75f4683 100644
--- a/docs-web/src/main/java/com/sismics/docs/rest/resource/FileResource.java
+++ b/docs-web/src/main/java/com/sismics/docs/rest/resource/FileResource.java
@@ -1,6 +1,11 @@
package com.sismics.docs.rest.resource;
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
import java.io.InputStream;
+import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.text.MessageFormat;
@@ -18,10 +23,12 @@ import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
+import javax.ws.rs.core.StreamingOutput;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
+import com.google.common.io.ByteStreams;
import com.sismics.docs.core.dao.jpa.DocumentDao;
import com.sismics.docs.core.dao.jpa.FileDao;
import com.sismics.docs.core.model.jpa.Document;
@@ -42,61 +49,6 @@ import com.sun.jersey.multipart.FormDataParam;
*/
@Path("/file")
public class FileResource extends BaseResource {
- /**
- * Add a file to a document.
- *
- * @param id Document ID
- * @param fileBodyPart File to add
- * @return Response
- * @throws JSONException
- */
- @PUT
- @Consumes("multipart/form-data")
- @Produces(MediaType.APPLICATION_JSON)
- public Response add(
- @FormDataParam("id") String documentId,
- @FormDataParam("file") FormDataBodyPart fileBodyPart) throws JSONException {
- if (!authenticate()) {
- throw new ForbiddenClientException();
- }
-
- // Validate input data
- ValidationUtil.validateRequired(documentId, "id");
- ValidationUtil.validateRequired(fileBodyPart, "file");
-
- // Get the document
- DocumentDao documentDao = new DocumentDao();
- Document document = null;
- try {
- document = documentDao.getDocument(documentId, principal.getId());
- } catch (NoResultException e) {
- throw new ClientException("DocumentNotFound", MessageFormat.format("Document not found: {0}", documentId));
- }
-
-
- FileDao fileDao = new FileDao();
-
- InputStream is = fileBodyPart.getValueAs(InputStream.class);
- try {
- // Create the file
- File file = new File();
- file.setDocumentId(document.getId());
- file.setMimeType(MimeTypeUtil.guessMimeType(is));
- String fileId = fileDao.create(file);
-
- // Copy the incoming stream content into the storage directory
- Files.copy(is, Paths.get(DirectoryUtil.getStorageDirectory().getPath(), fileId));
-
- // Always return ok
- JSONObject response = new JSONObject();
- response.put("status", "ok");
- response.put("id", fileId);
- return Response.ok().entity(response).build();
- } catch (Exception e) {
- throw new ServerException("FileError", "Error adding a file", e);
- }
- }
-
/**
* Returns a file.
*
@@ -129,6 +81,71 @@ public class FileResource extends BaseResource {
return Response.ok().entity(file).build();
}
+ /**
+ * Add a file to a document.
+ *
+ * @param id Document ID
+ * @param fileBodyPart File to add
+ * @return Response
+ * @throws JSONException
+ */
+ @PUT
+ @Consumes("multipart/form-data")
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response add(
+ @FormDataParam("id") String documentId,
+ @FormDataParam("file") FormDataBodyPart fileBodyPart) throws JSONException {
+ if (!authenticate()) {
+ throw new ForbiddenClientException();
+ }
+
+ // Validate input data
+ ValidationUtil.validateRequired(documentId, "id");
+ ValidationUtil.validateRequired(fileBodyPart, "file");
+
+ // Get the document
+ DocumentDao documentDao = new DocumentDao();
+ Document document = null;
+ try {
+ document = documentDao.getDocument(documentId, principal.getId());
+ } catch (NoResultException e) {
+ throw new ClientException("DocumentNotFound", MessageFormat.format("Document not found: {0}", documentId));
+ }
+
+ FileDao fileDao = new FileDao();
+
+ // Validate mime type
+ InputStream is = new BufferedInputStream(fileBodyPart.getValueAs(InputStream.class));
+ String mimeType = null;
+ try {
+ mimeType = MimeTypeUtil.guessMimeType(is);
+ } catch (Exception e) {
+ throw new ServerException("ErrorGuessMime", "Error guessing mime type", e);
+ }
+ if (mimeType == null) {
+ throw new ClientException("InvalidFileType", "File type not recognized");
+ }
+
+ try {
+ // Create the file
+ File file = new File();
+ file.setDocumentId(document.getId());
+ file.setMimeType(mimeType);
+ String fileId = fileDao.create(file);
+
+ // Copy the incoming stream content into the storage directory
+ Files.copy(is, Paths.get(DirectoryUtil.getStorageDirectory().getPath(), fileId));
+
+ // Always return ok
+ JSONObject response = new JSONObject();
+ response.put("status", "ok");
+ response.put("id", fileId);
+ return Response.ok().entity(response).build();
+ } catch (Exception e) {
+ throw new ServerException("FileError", "Error adding a file", e);
+ }
+ }
+
/**
* Returns files linked to a document.
*
@@ -197,4 +214,42 @@ public class FileResource extends BaseResource {
response.put("status", "ok");
return Response.ok().entity(response).build();
}
+
+ /**
+ * Returns a file.
+ *
+ * @param id File ID
+ * @return Response
+ * @throws JSONException
+ */
+ @GET
+ @Path("{id: [a-z0-9\\-]+}/data")
+ @Produces(MediaType.APPLICATION_OCTET_STREAM)
+ public Response data(
+ @PathParam("id") final String id) throws JSONException {
+ if (!authenticate()) {
+ throw new ForbiddenClientException();
+ }
+
+ // Get the file
+ java.io.File storageDirectory = DirectoryUtil.getStorageDirectory();
+ java.io.File[] matchingFiles = storageDirectory.listFiles(new FilenameFilter() {
+ @Override
+ public boolean accept(java.io.File dir, String name) {
+ return name.startsWith(id);
+ }
+ });
+ final java.io.File storageFile = matchingFiles[0];
+
+ // Stream the file to the response
+ StreamingOutput stream = new StreamingOutput() {
+ @Override
+ public void write(OutputStream os) throws IOException {
+ ByteStreams.copy(new FileInputStream(storageFile), os);
+ }
+ };
+ return Response.ok(stream)
+ .header("Content-Disposition", MessageFormat.format("attachment; filename=\"{0}\"", storageFile.getName()))
+ .build();
+ }
}
diff --git a/docs-web/src/main/webapp/.gitignore b/docs-web/src/main/webapp/.gitignore
new file mode 100644
index 00000000..3fcc60d9
--- /dev/null
+++ b/docs-web/src/main/webapp/.gitignore
@@ -0,0 +1 @@
+/sismicsdocs
diff --git a/docs-web/src/main/webapp/index.html b/docs-web/src/main/webapp/index.html
index f1a3e315..72da63f3 100644
--- a/docs-web/src/main/webapp/index.html
+++ b/docs-web/src/main/webapp/index.html
@@ -18,16 +18,21 @@
+
+
+
+
+
diff --git a/docs-web/src/main/webapp/js/app.js b/docs-web/src/main/webapp/js/app.js
index 2e429662..bcb775d1 100644
--- a/docs-web/src/main/webapp/js/app.js
+++ b/docs-web/src/main/webapp/js/app.js
@@ -3,7 +3,7 @@
/**
* Trackino application.
*/
-var App = angular.module('docs', ['ui.state', 'ui.bootstrap', 'restangular'])
+var App = angular.module('docs', ['ui.state', 'ui.bootstrap', 'ui.keypress', 'restangular', 'ngSanitize'])
/**
* Configuring modules.
@@ -22,6 +22,7 @@ var App = angular.module('docs', ['ui.state', 'ui.bootstrap', 'restangular'])
})
.state('document', {
url: '/document',
+ abstract: true,
views: {
'page': {
templateUrl: 'partial/document.html',
@@ -29,6 +30,14 @@ var App = angular.module('docs', ['ui.state', 'ui.bootstrap', 'restangular'])
}
}
})
+ .state('document.default', {
+ url: '',
+ views: {
+ 'document': {
+ templateUrl: 'partial/document.default.html'
+ }
+ }
+ })
.state('document.add', {
url: '/add',
views: {
@@ -56,6 +65,18 @@ var App = angular.module('docs', ['ui.state', 'ui.bootstrap', 'restangular'])
}
}
})
+ .state('document.view.file', {
+ url: '/file/:fileId',
+ onEnter: function($stateParams, $state, $dialog) {
+ $dialog.dialog({
+ keyboard: true,
+ templateUrl: 'partial/file.view.html',
+ controller: 'FileView'
+ }).open().then(function(result) {
+ $state.transitionTo('document.view', { id: $stateParams.id });
+ });
+ }
+ })
.state('login', {
url: '/login',
views: {
diff --git a/docs-web/src/main/webapp/js/controller/Document.js b/docs-web/src/main/webapp/js/controller/Document.js
index 7bd7b1db..5e3cd3ac 100644
--- a/docs-web/src/main/webapp/js/controller/Document.js
+++ b/docs-web/src/main/webapp/js/controller/Document.js
@@ -5,19 +5,61 @@
*/
App.controller('Document', function($scope, $state, Restangular) {
/**
- * Load documents.
+ * Documents table sort status.
*/
- $scope.loadDocuments = function() {
+ $scope.sortColumn = 3;
+ $scope.asc = false;
+ $scope.offset = 0;
+ $scope.currentPage = 1;
+ $scope.limit = 10;
+
+ /**
+ * Load new documents page.
+ */
+ $scope.pageDocuments = function() {
Restangular.one('document')
.getList('list', {
- offset: 0,
- limit: 30
+ offset: $scope.offset,
+ limit: $scope.limit,
+ sort_column: $scope.sortColumn,
+ asc: $scope.asc
})
.then(function(data) {
- $scope.documents = data.documents;
+ $scope.documents = data;
+ $scope.numPages = Math.ceil(data.total / $scope.limit);
});
};
+ /**
+ * Reload documents.
+ */
+ $scope.loadDocuments = function() {
+ $scope.offset = 0;
+ $scope.currentPage = 1;
+ $scope.pageDocuments();
+ };
+
+ /**
+ * Watch for current page change.
+ */
+ $scope.$watch('currentPage', function() {
+ $scope.offset = ($scope.currentPage - 1) * $scope.limit;
+ $scope.pageDocuments();
+ });
+
+ /**
+ * Sort documents.
+ */
+ $scope.sortDocuments = function(sortColumn) {
+ if (sortColumn == $scope.sortColumn) {
+ $scope.asc = !$scope.asc;
+ } else {
+ $scope.asc = true;
+ }
+ $scope.sortColumn = sortColumn;
+ $scope.loadDocuments();
+ };
+
/**
* Go to add document form.
*/
@@ -25,10 +67,17 @@ App.controller('Document', function($scope, $state, Restangular) {
$state.transitionTo('document.add');
};
+ /**
+ * Go to edit document form.
+ */
+ $scope.editDocument = function(id) {
+ $state.transitionTo('document.edit', { id: id });
+ };
+
+ /**
+ * Display a document.
+ */
$scope.viewDocument = function(id) {
$state.transitionTo('document.view', { id: id });
};
-
- // Initial documents loading
- $scope.loadDocuments();
});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/controller/DocumentEdit.js b/docs-web/src/main/webapp/js/controller/DocumentEdit.js
index 97bd209b..873055d7 100644
--- a/docs-web/src/main/webapp/js/controller/DocumentEdit.js
+++ b/docs-web/src/main/webapp/js/controller/DocumentEdit.js
@@ -3,7 +3,7 @@
/**
* Document edition controller.
*/
-App.controller('DocumentEdit', function($scope, $state, $stateParams, Restangular) {
+App.controller('DocumentEdit', function($scope, $http, $state, $stateParams, Restangular) {
/**
* Returns true if in edit mode (false in add mode).
*/
@@ -11,27 +11,65 @@ App.controller('DocumentEdit', function($scope, $state, $stateParams, Restangula
return $stateParams.id;
};
+ /**
+ * In edit mode, load the current document.
+ */
+ if ($scope.isEdit()) {
+ Restangular.one('document', $stateParams.id).get().then(function(data) {
+ $scope.document = data;
+ });
+ }
+
/**
* Edit a document.
*/
$scope.edit = function() {
+ var promise = null;
+
if ($scope.isEdit()) {
- // TODO
+ promise = Restangular
+ .one('document', $stateParams.id)
+ .post('', $scope.document);
+ promise.then(function(data) {
+ $scope.loadDocuments();
+ $state.transitionTo('document.view', { id: $stateParams.id });
+ })
} else {
- Restangular
+ promise = Restangular
.one('document')
- .put($scope.document)
- .then(function() {
+ .put($scope.document);
+ promise.then(function(data) {
$scope.document = {};
$scope.loadDocuments();
});
}
+
+ // Upload files after edition
+ // TODO Handle file upload progression and errors
+ promise.then(function(data) {
+ _.each($scope.files, function(file) {
+ var formData = new FormData();
+ formData.append('id', data.id);
+ formData.append('file', file);
+ $.ajax({
+ url: 'api/file',
+ type: 'PUT',
+ data: formData,
+ processData: false,
+ contentType: false
+ });
+ });
+ });
};
/**
* Cancel edition.
*/
$scope.cancel = function() {
- $state.transitionTo('document');
+ if ($scope.isEdit()) {
+ $state.transitionTo('document.view', { id: $stateParams.id });
+ } else {
+ $state.transitionTo('document.default');
+ }
};
});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/controller/DocumentView.js b/docs-web/src/main/webapp/js/controller/DocumentView.js
index 79ade596..1a6a77d3 100644
--- a/docs-web/src/main/webapp/js/controller/DocumentView.js
+++ b/docs-web/src/main/webapp/js/controller/DocumentView.js
@@ -3,5 +3,17 @@
/**
* Document view controller.
*/
-App.controller('DocumentView', function($scope, Restangular) {
+App.controller('DocumentView', function($rootScope, $scope, $state, $stateParams, Restangular) {
+ // Load data from server
+ $scope.document = Restangular.one('document', $stateParams.id).get();
+ Restangular.one('file').getList('list', { id: $stateParams.id }).then(function(data) {
+ $rootScope.files = data.files;
+ });
+
+ /**
+ * Navigate to the selected file.
+ */
+ $scope.openFile = function(file) {
+ $state.transitionTo('document.view.file', { id: $stateParams.id, fileId: file.id })
+ }
});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/controller/FileView.js b/docs-web/src/main/webapp/js/controller/FileView.js
new file mode 100644
index 00000000..cd2e4d20
--- /dev/null
+++ b/docs-web/src/main/webapp/js/controller/FileView.js
@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * File view controller.
+ */
+App.controller('FileView', function($rootScope, $state, $scope, $stateParams) {
+ $scope.id = $stateParams.fileId;
+
+ /**
+ * Navigate to the next file.
+ */
+ $scope.nextFile = function() {
+ _.each($rootScope.files, function(value, key, list) {
+ if (value.id == $scope.id) {
+ var next = $rootScope.files[key + 1];
+ if (next) {
+ $state.transitionTo('document.view.file', { id: $stateParams.id, fileId: next.id });
+ }
+ }
+ });
+ };
+
+ /**
+ * Navigate to the previous file.
+ */
+ $scope.previousFile = function() {
+ _.each($rootScope.files, function(value, key, list) {
+ if (value.id == $scope.id) {
+ var previous = $rootScope.files[key - 1];
+ if (previous) {
+ $state.transitionTo('document.view.file', { id: $stateParams.id, fileId: previous.id });
+ }
+ }
+ });
+ };
+});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/controller/Login.js b/docs-web/src/main/webapp/js/controller/Login.js
index e13ba9c5..072cab42 100644
--- a/docs-web/src/main/webapp/js/controller/Login.js
+++ b/docs-web/src/main/webapp/js/controller/Login.js
@@ -6,7 +6,7 @@
App.controller('Login', function($scope, $state, $dialog, User) {
$scope.login = function() {
User.login($scope.user).then(function() {
- $state.transitionTo('browse');
+ $state.transitionTo('document.default');
}, function() {
var title = 'Login failed';
var msg = 'Username or password invalid';
diff --git a/docs-web/src/main/webapp/js/controller/Main.js b/docs-web/src/main/webapp/js/controller/Main.js
index 09e50153..17384b71 100644
--- a/docs-web/src/main/webapp/js/controller/Main.js
+++ b/docs-web/src/main/webapp/js/controller/Main.js
@@ -8,7 +8,7 @@ App.controller('Main', function($scope, $state, User) {
if (data.anonymous) {
$state.transitionTo('login');
} else {
- $state.transitionTo('document');
+ $state.transitionTo('document.default');
}
});
});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/directive/File.js b/docs-web/src/main/webapp/js/directive/File.js
new file mode 100644
index 00000000..01b315e0
--- /dev/null
+++ b/docs-web/src/main/webapp/js/directive/File.js
@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * File upload directive.
+ */
+App.directive('file', function() {
+ return {
+ restrict: 'E',
+ template: '',
+ replace: true,
+ require: 'ngModel',
+ link: function(scope, element, attr, ctrl) {
+ var listener = function() {
+ scope.$apply(function() {
+ attr.multiple ? ctrl.$setViewValue(element[0].files) : ctrl.$setViewValue(element[0].files[0]);
+ });
+ }
+ element.bind('change', listener);
+ }
+ }
+});
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/js/filter/Newline.js b/docs-web/src/main/webapp/js/filter/Newline.js
new file mode 100644
index 00000000..ed0bb238
--- /dev/null
+++ b/docs-web/src/main/webapp/js/filter/Newline.js
@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Filter converting new lines in
+ */
+App.filter('newline', function() {
+ return function(text) {
+ if (!text) {
+ return '';
+ }
+ return text.replace(/\n/g, ' ');
+ }
+})
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/lib/angular.ui-utils.js b/docs-web/src/main/webapp/lib/angular.ui-utils.js
new file mode 100644
index 00000000..7fd280e9
--- /dev/null
+++ b/docs-web/src/main/webapp/lib/angular.ui-utils.js
@@ -0,0 +1,1261 @@
+/**
+ * angular-ui-utils - Swiss-Army-Knife of AngularJS tools (with no external dependencies!)
+ * @version v0.0.4 - 2013-07-21
+ * @link http://angular-ui.github.com
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+/**
+ * General-purpose Event binding. Bind any event not natively supported by Angular
+ * Pass an object with keynames for events to ui-event
+ * Allows $event object and $params object to be passed
+ *
+ * @example
+ * @example
+ *
+ * @param ui-event {string|object literal} The event to bind to as a string or a hash of events with their callbacks
+ */
+angular.module('ui.event',[]).directive('uiEvent', ['$parse',
+ function ($parse) {
+ return function ($scope, elm, attrs) {
+ var events = $scope.$eval(attrs.uiEvent);
+ angular.forEach(events, function (uiEvent, eventName) {
+ var fn = $parse(uiEvent);
+ elm.bind(eventName, function (evt) {
+ var params = Array.prototype.slice.call(arguments);
+ //Take out first paramater (event object);
+ params = params.splice(1);
+ fn($scope, {$event: evt, $params: params});
+ if (!$scope.$$phase) {
+ $scope.$apply();
+ }
+ });
+ });
+ };
+ }]);
+
+
+/**
+ * A replacement utility for internationalization very similar to sprintf.
+ *
+ * @param replace {mixed} The tokens to replace depends on type
+ * string: all instances of $0 will be replaced
+ * array: each instance of $0, $1, $2 etc. will be placed with each array item in corresponding order
+ * object: all attributes will be iterated through, with :key being replaced with its corresponding value
+ * @return string
+ *
+ * @example: 'Hello :name, how are you :day'.format({ name:'John', day:'Today' })
+ * @example: 'Records $0 to $1 out of $2 total'.format(['10', '20', '3000'])
+ * @example: '$0 agrees to all mentions $0 makes in the event that $0 hits a tree while $0 is driving drunk'.format('Bob')
+ */
+angular.module('ui.format',[]).filter('format', function(){
+ return function(value, replace) {
+ var target = value;
+ if (angular.isString(target) && replace !== undefined) {
+ if (!angular.isArray(replace) && !angular.isObject(replace)) {
+ replace = [replace];
+ }
+ if (angular.isArray(replace)) {
+ var rlen = replace.length;
+ var rfx = function (str, i) {
+ i = parseInt(i, 10);
+ return (i>=0 && i' + search + '');
+ } else {
+ return text.replace(new RegExp(search, 'gi'), '$&');
+ }
+ } else {
+ return text;
+ }
+ };
+});
+
+// modeled after: angular-1.0.7/src/ng/directive/ngInclude.js
+angular.module('ui.include',[])
+.directive('uiInclude', ['$http', '$templateCache', '$anchorScroll', '$compile',
+ function($http, $templateCache, $anchorScroll, $compile) {
+ return {
+ restrict: 'ECA',
+ terminal: true,
+ compile: function(element, attr) {
+ var srcExp = attr.uiInclude || attr.src,
+ fragExp = attr.fragment || '',
+ onloadExp = attr.onload || '',
+ autoScrollExp = attr.autoscroll;
+
+ return function(scope, element) {
+ var changeCounter = 0,
+ childScope;
+
+ var clearContent = function() {
+ if (childScope) {
+ childScope.$destroy();
+ childScope = null;
+ }
+
+ element.html('');
+ };
+
+ function ngIncludeWatchAction() {
+ var thisChangeId = ++changeCounter;
+ var src = scope.$eval(srcExp);
+ var fragment = scope.$eval(fragExp);
+
+ if (src) {
+ $http.get(src, {cache: $templateCache}).success(function(response) {
+ if (thisChangeId !== changeCounter) { return; }
+
+ if (childScope) { childScope.$destroy(); }
+ childScope = scope.$new();
+
+ var contents;
+ if (fragment) {
+ contents = angular.element('').html(response).find(fragment);
+ }
+ else {
+ contents = angular.element('').html(response).contents();
+ }
+ element.html(contents);
+ $compile(contents)(childScope);
+
+ if (angular.isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) {
+ $anchorScroll();
+ }
+
+ childScope.$emit('$includeContentLoaded');
+ scope.$eval(onloadExp);
+ }).error(function() {
+ if (thisChangeId === changeCounter) { clearContent(); }
+ });
+ } else { clearContent(); }
+ }
+
+ scope.$watch(fragExp, ngIncludeWatchAction);
+ scope.$watch(srcExp, ngIncludeWatchAction);
+ };
+ }
+ };
+}]);
+
+/**
+ * Provides an easy way to toggle a checkboxes indeterminate property
+ *
+ * @example
+ */
+angular.module('ui.indeterminate',[]).directive('uiIndeterminate', [
+ function () {
+ return {
+ compile: function(tElm, tAttrs) {
+ if (!tAttrs.type || tAttrs.type.toLowerCase() !== 'checkbox') {
+ return angular.noop;
+ }
+
+ return function ($scope, elm, attrs) {
+ $scope.$watch(attrs.uiIndeterminate, function(newVal, oldVal) {
+ elm[0].indeterminate = !!newVal;
+ });
+ };
+ }
+ };
+ }]);
+
+/**
+ * Converts variable-esque naming conventions to something presentational, capitalized words separated by space.
+ * @param {String} value The value to be parsed and prettified.
+ * @param {String} [inflector] The inflector to use. Default: humanize.
+ * @return {String}
+ * @example {{ 'Here Is my_phoneNumber' | inflector:'humanize' }} => Here Is My Phone Number
+ * {{ 'Here Is my_phoneNumber' | inflector:'underscore' }} => here_is_my_phone_number
+ * {{ 'Here Is my_phoneNumber' | inflector:'variable' }} => hereIsMyPhoneNumber
+ */
+angular.module('ui.inflector',[]).filter('inflector', function () {
+ function ucwords(text) {
+ return text.replace(/^([a-z])|\s+([a-z])/g, function ($1) {
+ return $1.toUpperCase();
+ });
+ }
+
+ function breakup(text, separator) {
+ return text.replace(/[A-Z]/g, function (match) {
+ return separator + match;
+ });
+ }
+
+ var inflectors = {
+ humanize: function (value) {
+ return ucwords(breakup(value, ' ').split('_').join(' '));
+ },
+ underscore: function (value) {
+ return value.substr(0, 1).toLowerCase() + breakup(value.substr(1), '_').toLowerCase().split(' ').join('_');
+ },
+ variable: function (value) {
+ value = value.substr(0, 1).toLowerCase() + ucwords(value.split('_').join(' ')).substr(1).split(' ').join('');
+ return value;
+ }
+ };
+
+ return function (text, inflector, separator) {
+ if (inflector !== false && angular.isString(text)) {
+ inflector = inflector || 'humanize';
+ return inflectors[inflector](text);
+ } else {
+ return text;
+ }
+ };
+});
+
+/**
+ * General-purpose jQuery wrapper. Simply pass the plugin name as the expression.
+ *
+ * It is possible to specify a default set of parameters for each jQuery plugin.
+ * Under the jq key, namespace each plugin by that which will be passed to ui-jq.
+ * Unfortunately, at this time you can only pre-define the first parameter.
+ * @example { jq : { datepicker : { showOn:'click' } } }
+ *
+ * @param ui-jq {string} The $elm.[pluginName]() to call.
+ * @param [ui-options] {mixed} Expression to be evaluated and passed as options to the function
+ * Multiple parameters can be separated by commas
+ * @param [ui-refresh] {expression} Watch expression and refire plugin on changes
+ *
+ * @example
+ */
+angular.module('ui.jq',[]).
+ value('uiJqConfig',{}).
+ directive('uiJq', ['uiJqConfig', '$timeout', function uiJqInjectingFunction(uiJqConfig, $timeout) {
+
+ return {
+ restrict: 'A',
+ compile: function uiJqCompilingFunction(tElm, tAttrs) {
+
+ if (!angular.isFunction(tElm[tAttrs.uiJq])) {
+ throw new Error('ui-jq: The "' + tAttrs.uiJq + '" function does not exist');
+ }
+ var options = uiJqConfig && uiJqConfig[tAttrs.uiJq];
+
+ return function uiJqLinkingFunction(scope, elm, attrs) {
+
+ var linkOptions = [];
+
+ // If ui-options are passed, merge (or override) them onto global defaults and pass to the jQuery method
+ if (attrs.uiOptions) {
+ linkOptions = scope.$eval('[' + attrs.uiOptions + ']');
+ if (angular.isObject(options) && angular.isObject(linkOptions[0])) {
+ linkOptions[0] = angular.extend({}, options, linkOptions[0]);
+ }
+ } else if (options) {
+ linkOptions = [options];
+ }
+ // If change compatibility is enabled, the form input's "change" event will trigger an "input" event
+ if (attrs.ngModel && elm.is('select,input,textarea')) {
+ elm.bind('change', function() {
+ elm.trigger('input');
+ });
+ }
+
+ // Call jQuery method and pass relevant options
+ function callPlugin() {
+ $timeout(function() {
+ elm[attrs.uiJq].apply(elm, linkOptions);
+ }, 0, false);
+ }
+
+ // If ui-refresh is used, re-fire the the method upon every change
+ if (attrs.uiRefresh) {
+ scope.$watch(attrs.uiRefresh, function(newVal) {
+ callPlugin();
+ });
+ }
+ callPlugin();
+ };
+ }
+ };
+}]);
+
+angular.module('ui.keypress',[]).
+factory('keypressHelper', ['$parse', function keypress($parse){
+ var keysByCode = {
+ 8: 'backspace',
+ 9: 'tab',
+ 13: 'enter',
+ 27: 'esc',
+ 32: 'space',
+ 33: 'pageup',
+ 34: 'pagedown',
+ 35: 'end',
+ 36: 'home',
+ 37: 'left',
+ 38: 'up',
+ 39: 'right',
+ 40: 'down',
+ 45: 'insert',
+ 46: 'delete'
+ };
+
+ var capitaliseFirstLetter = function (string) {
+ return string.charAt(0).toUpperCase() + string.slice(1);
+ };
+
+ return function(mode, scope, elm, attrs) {
+ var params, combinations = [];
+ params = scope.$eval(attrs['ui'+capitaliseFirstLetter(mode)]);
+
+ // Prepare combinations for simple checking
+ angular.forEach(params, function (v, k) {
+ var combination, expression;
+ expression = $parse(v);
+
+ angular.forEach(k.split(' '), function(variation) {
+ combination = {
+ expression: expression,
+ keys: {}
+ };
+ angular.forEach(variation.split('-'), function (value) {
+ combination.keys[value] = true;
+ });
+ combinations.push(combination);
+ });
+ });
+
+ // Check only matching of pressed keys one of the conditions
+ elm.bind(mode, function (event) {
+ // No need to do that inside the cycle
+ var metaPressed = !!(event.metaKey && !event.ctrlKey);
+ var altPressed = !!event.altKey;
+ var ctrlPressed = !!event.ctrlKey;
+ var shiftPressed = !!event.shiftKey;
+ var keyCode = event.keyCode;
+
+ // normalize keycodes
+ if (mode === 'keypress' && !shiftPressed && keyCode >= 97 && keyCode <= 122) {
+ keyCode = keyCode - 32;
+ }
+
+ // Iterate over prepared combinations
+ angular.forEach(combinations, function (combination) {
+
+ var mainKeyPressed = combination.keys[keysByCode[keyCode]] || combination.keys[keyCode.toString()];
+
+ var metaRequired = !!combination.keys.meta;
+ var altRequired = !!combination.keys.alt;
+ var ctrlRequired = !!combination.keys.ctrl;
+ var shiftRequired = !!combination.keys.shift;
+
+ if (
+ mainKeyPressed &&
+ ( metaRequired === metaPressed ) &&
+ ( altRequired === altPressed ) &&
+ ( ctrlRequired === ctrlPressed ) &&
+ ( shiftRequired === shiftPressed )
+ ) {
+ // Run the function
+ scope.$apply(function () {
+ combination.expression(scope, { '$event': event });
+ });
+ }
+ });
+ });
+ };
+}]);
+
+/**
+ * Bind one or more handlers to particular keys or their combination
+ * @param hash {mixed} keyBindings Can be an object or string where keybinding expression of keys or keys combinations and AngularJS Exspressions are set. Object syntax: "{ keys1: expression1 [, keys2: expression2 [ , ... ]]}". String syntax: ""expression1 on keys1 [ and expression2 on keys2 [ and ... ]]"". Expression is an AngularJS Expression, and key(s) are dash-separated combinations of keys and modifiers (one or many, if any. Order does not matter). Supported modifiers are 'ctrl', 'shift', 'alt' and key can be used either via its keyCode (13 for Return) or name. Named keys are 'backspace', 'tab', 'enter', 'esc', 'space', 'pageup', 'pagedown', 'end', 'home', 'left', 'up', 'right', 'down', 'insert', 'delete'.
+ * @example
+ **/
+angular.module('ui.keypress').directive('uiKeydown', ['keypressHelper', function(keypressHelper){
+ return {
+ link: function (scope, elm, attrs) {
+ keypressHelper('keydown', scope, elm, attrs);
+ }
+ };
+}]);
+
+angular.module('ui.keypress').directive('uiKeypress', ['keypressHelper', function(keypressHelper){
+ return {
+ link: function (scope, elm, attrs) {
+ keypressHelper('keypress', scope, elm, attrs);
+ }
+ };
+}]);
+
+angular.module('ui.keypress').directive('uiKeyup', ['keypressHelper', function(keypressHelper){
+ return {
+ link: function (scope, elm, attrs) {
+ keypressHelper('keyup', scope, elm, attrs);
+ }
+ };
+}]);
+/*
+ Attaches input mask onto input element
+ */
+angular.module('ui.mask', [])
+ .value('uiMaskConfig', {
+ 'maskDefinitions': {
+ '9': /\d/,
+ 'A': /[a-zA-Z]/,
+ '*': /[a-zA-Z0-9]/
+ }
+ })
+ .directive('uiMask', ['uiMaskConfig', function (maskConfig) {
+ return {
+ priority: 100,
+ require: 'ngModel',
+ restrict: 'A',
+ compile: function uiMaskCompilingFunction(){
+ var options = maskConfig;
+
+ return function uiMaskLinkingFunction(scope, iElement, iAttrs, controller){
+ var maskProcessed = false, eventsBound = false,
+ maskCaretMap, maskPatterns, maskPlaceholder, maskComponents,
+ // Minimum required length of the value to be considered valid
+ minRequiredLength,
+ value, valueMasked, isValid,
+ // Vars for initializing/uninitializing
+ originalPlaceholder = iAttrs.placeholder,
+ originalMaxlength = iAttrs.maxlength,
+ // Vars used exclusively in eventHandler()
+ oldValue, oldValueUnmasked, oldCaretPosition, oldSelectionLength;
+
+ function initialize(maskAttr){
+ if (!angular.isDefined(maskAttr)) {
+ return uninitialize();
+ }
+ processRawMask(maskAttr);
+ if (!maskProcessed) {
+ return uninitialize();
+ }
+ initializeElement();
+ bindEventListeners();
+ return true;
+ }
+
+ function initPlaceholder(placeholderAttr) {
+ if(! angular.isDefined(placeholderAttr)) {
+ return;
+ }
+
+ maskPlaceholder = placeholderAttr;
+
+ // If the mask is processed, then we need to update the value
+ if (maskProcessed) {
+ eventHandler();
+ }
+ }
+
+ function formatter(fromModelValue){
+ if (!maskProcessed) {
+ return fromModelValue;
+ }
+ value = unmaskValue(fromModelValue || '');
+ isValid = validateValue(value);
+ controller.$setValidity('mask', isValid);
+ return isValid && value.length ? maskValue(value) : undefined;
+ }
+
+ function parser(fromViewValue){
+ if (!maskProcessed) {
+ return fromViewValue;
+ }
+ value = unmaskValue(fromViewValue || '');
+ isValid = validateValue(value);
+ // We have to set viewValue manually as the reformatting of the input
+ // value performed by eventHandler() doesn't happen until after
+ // this parser is called, which causes what the user sees in the input
+ // to be out-of-sync with what the controller's $viewValue is set to.
+ controller.$viewValue = value.length ? maskValue(value) : '';
+ controller.$setValidity('mask', isValid);
+ if (value === '' && controller.$error.required !== undefined) {
+ controller.$setValidity('required', false);
+ }
+ return isValid ? value : undefined;
+ }
+
+ var linkOptions = {};
+
+ if (iAttrs.uiOptions) {
+ linkOptions = scope.$eval('[' + iAttrs.uiOptions + ']');
+ if (angular.isObject(linkOptions[0])) {
+ // we can't use angular.copy nor angular.extend, they lack the power to do a deep merge
+ linkOptions = (function(original, current){
+ for(var i in original) {
+ if (Object.prototype.hasOwnProperty.call(original, i)) {
+ if (!current[i]) {
+ current[i] = angular.copy(original[i]);
+ } else {
+ angular.extend(current[i], original[i]);
+ }
+ }
+ }
+ return current;
+ })(options, linkOptions[0]);
+ }
+ } else {
+ linkOptions = options;
+ }
+
+ iAttrs.$observe('uiMask', initialize);
+ iAttrs.$observe('placeholder', initPlaceholder);
+ controller.$formatters.push(formatter);
+ controller.$parsers.push(parser);
+
+ function uninitialize(){
+ maskProcessed = false;
+ unbindEventListeners();
+
+ if (angular.isDefined(originalPlaceholder)) {
+ iElement.attr('placeholder', originalPlaceholder);
+ } else {
+ iElement.removeAttr('placeholder');
+ }
+
+ if (angular.isDefined(originalMaxlength)) {
+ iElement.attr('maxlength', originalMaxlength);
+ } else {
+ iElement.removeAttr('maxlength');
+ }
+
+ iElement.val(controller.$modelValue);
+ controller.$viewValue = controller.$modelValue;
+ return false;
+ }
+
+ function initializeElement(){
+ value = oldValueUnmasked = unmaskValue(controller.$modelValue || '');
+ valueMasked = oldValue = maskValue(value);
+ isValid = validateValue(value);
+ var viewValue = isValid && value.length ? valueMasked : '';
+ if (iAttrs.maxlength) { // Double maxlength to allow pasting new val at end of mask
+ iElement.attr('maxlength', maskCaretMap[maskCaretMap.length - 1] * 2);
+ }
+ iElement.attr('placeholder', maskPlaceholder);
+ iElement.val(viewValue);
+ controller.$viewValue = viewValue;
+ // Not using $setViewValue so we don't clobber the model value and dirty the form
+ // without any kind of user interaction.
+ }
+
+ function bindEventListeners(){
+ if (eventsBound) {
+ return;
+ }
+ iElement.bind('blur', blurHandler);
+ iElement.bind('mousedown mouseup', mouseDownUpHandler);
+ iElement.bind('input keyup click', eventHandler);
+ eventsBound = true;
+ }
+
+ function unbindEventListeners(){
+ if (!eventsBound) {
+ return;
+ }
+ iElement.unbind('blur', blurHandler);
+ iElement.unbind('mousedown', mouseDownUpHandler);
+ iElement.unbind('mouseup', mouseDownUpHandler);
+ iElement.unbind('input', eventHandler);
+ iElement.unbind('keyup', eventHandler);
+ iElement.unbind('click', eventHandler);
+ eventsBound = false;
+ }
+
+ function validateValue(value){
+ // Zero-length value validity is ngRequired's determination
+ return value.length ? value.length >= minRequiredLength : true;
+ }
+
+ function unmaskValue(value){
+ var valueUnmasked = '',
+ maskPatternsCopy = maskPatterns.slice();
+ // Preprocess by stripping mask components from value
+ value = value.toString();
+ angular.forEach(maskComponents, function (component){
+ value = value.replace(component, '');
+ });
+ angular.forEach(value.split(''), function (chr){
+ if (maskPatternsCopy.length && maskPatternsCopy[0].test(chr)) {
+ valueUnmasked += chr;
+ maskPatternsCopy.shift();
+ }
+ });
+ return valueUnmasked;
+ }
+
+ function maskValue(unmaskedValue){
+ var valueMasked = '',
+ maskCaretMapCopy = maskCaretMap.slice();
+
+ angular.forEach(maskPlaceholder.split(''), function (chr, i){
+ if (unmaskedValue.length && i === maskCaretMapCopy[0]) {
+ valueMasked += unmaskedValue.charAt(0) || '_';
+ unmaskedValue = unmaskedValue.substr(1);
+ maskCaretMapCopy.shift();
+ }
+ else {
+ valueMasked += chr;
+ }
+ });
+ return valueMasked;
+ }
+
+ function getPlaceholderChar(i) {
+ var placeholder = iAttrs.placeholder;
+
+ if (typeof placeholder !== "undefined" && placeholder[i]) {
+ return placeholder[i];
+ } else {
+ return "_";
+ }
+ }
+
+ // Generate array of mask components that will be stripped from a masked value
+ // before processing to prevent mask components from being added to the unmasked value.
+ // E.g., a mask pattern of '+7 9999' won't have the 7 bleed into the unmasked value.
+ // If a maskable char is followed by a mask char and has a mask
+ // char behind it, we'll split it into it's own component so if
+ // a user is aggressively deleting in the input and a char ahead
+ // of the maskable char gets deleted, we'll still be able to strip
+ // it in the unmaskValue() preprocessing.
+ function getMaskComponents() {
+ return maskPlaceholder.replace(/[_]+/g, '_').replace(/([^_]+)([a-zA-Z0-9])([^_])/g, '$1$2_$3').split('_');
+ }
+
+ function processRawMask(mask){
+ var characterCount = 0;
+
+ maskCaretMap = [];
+ maskPatterns = [];
+ maskPlaceholder = '';
+
+ if (typeof mask === 'string') {
+ minRequiredLength = 0;
+
+ var isOptional = false,
+ splitMask = mask.split("");
+
+ angular.forEach(splitMask, function (chr, i){
+ if (linkOptions.maskDefinitions[chr]) {
+
+ maskCaretMap.push(characterCount);
+
+ maskPlaceholder += getPlaceholderChar(i);
+ maskPatterns.push(linkOptions.maskDefinitions[chr]);
+
+ characterCount++;
+ if (!isOptional) {
+ minRequiredLength++;
+ }
+ }
+ else if (chr === "?") {
+ isOptional = true;
+ }
+ else {
+ maskPlaceholder += chr;
+ characterCount++;
+ }
+ });
+ }
+ // Caret position immediately following last position is valid.
+ maskCaretMap.push(maskCaretMap.slice().pop() + 1);
+
+ maskComponents = getMaskComponents();
+ maskProcessed = maskCaretMap.length > 1 ? true : false;
+ }
+
+ function blurHandler(){
+ oldCaretPosition = 0;
+ oldSelectionLength = 0;
+ if (!isValid || value.length === 0) {
+ valueMasked = '';
+ iElement.val('');
+ scope.$apply(function (){
+ controller.$setViewValue('');
+ });
+ }
+ }
+
+ function mouseDownUpHandler(e){
+ if (e.type === 'mousedown') {
+ iElement.bind('mouseout', mouseoutHandler);
+ } else {
+ iElement.unbind('mouseout', mouseoutHandler);
+ }
+ }
+
+ iElement.bind('mousedown mouseup', mouseDownUpHandler);
+
+ function mouseoutHandler(){
+ oldSelectionLength = getSelectionLength(this);
+ iElement.unbind('mouseout', mouseoutHandler);
+ }
+
+ function eventHandler(e){
+ e = e || {};
+ // Allows more efficient minification
+ var eventWhich = e.which,
+ eventType = e.type;
+
+ // Prevent shift and ctrl from mucking with old values
+ if (eventWhich === 16 || eventWhich === 91) { return;}
+
+ var val = iElement.val(),
+ valOld = oldValue,
+ valMasked,
+ valUnmasked = unmaskValue(val),
+ valUnmaskedOld = oldValueUnmasked,
+ valAltered = false,
+
+ caretPos = getCaretPosition(this) || 0,
+ caretPosOld = oldCaretPosition || 0,
+ caretPosDelta = caretPos - caretPosOld,
+ caretPosMin = maskCaretMap[0],
+ caretPosMax = maskCaretMap[valUnmasked.length] || maskCaretMap.slice().shift(),
+
+ selectionLenOld = oldSelectionLength || 0,
+ isSelected = getSelectionLength(this) > 0,
+ wasSelected = selectionLenOld > 0,
+
+ // Case: Typing a character to overwrite a selection
+ isAddition = (val.length > valOld.length) || (selectionLenOld && val.length > valOld.length - selectionLenOld),
+ // Case: Delete and backspace behave identically on a selection
+ isDeletion = (val.length < valOld.length) || (selectionLenOld && val.length === valOld.length - selectionLenOld),
+ isSelection = (eventWhich >= 37 && eventWhich <= 40) && e.shiftKey, // Arrow key codes
+
+ isKeyLeftArrow = eventWhich === 37,
+ // Necessary due to "input" event not providing a key code
+ isKeyBackspace = eventWhich === 8 || (eventType !== 'keyup' && isDeletion && (caretPosDelta === -1)),
+ isKeyDelete = eventWhich === 46 || (eventType !== 'keyup' && isDeletion && (caretPosDelta === 0 ) && !wasSelected),
+
+ // Handles cases where caret is moved and placed in front of invalid maskCaretMap position. Logic below
+ // ensures that, on click or leftward caret placement, caret is moved leftward until directly right of
+ // non-mask character. Also applied to click since users are (arguably) more likely to backspace
+ // a character when clicking within a filled input.
+ caretBumpBack = (isKeyLeftArrow || isKeyBackspace || eventType === 'click') && caretPos > caretPosMin;
+
+ oldSelectionLength = getSelectionLength(this);
+
+ // These events don't require any action
+ if (isSelection || (isSelected && (eventType === 'click' || eventType === 'keyup'))) {
+ return;
+ }
+
+ // Value Handling
+ // ==============
+
+ // User attempted to delete but raw value was unaffected--correct this grievous offense
+ if ((eventType === 'input') && isDeletion && !wasSelected && valUnmasked === valUnmaskedOld) {
+ while (isKeyBackspace && caretPos > caretPosMin && !isValidCaretPosition(caretPos)) {
+ caretPos--;
+ }
+ while (isKeyDelete && caretPos < caretPosMax && maskCaretMap.indexOf(caretPos) === -1) {
+ caretPos++;
+ }
+ var charIndex = maskCaretMap.indexOf(caretPos);
+ // Strip out non-mask character that user would have deleted if mask hadn't been in the way.
+ valUnmasked = valUnmasked.substring(0, charIndex) + valUnmasked.substring(charIndex + 1);
+ valAltered = true;
+ }
+
+ // Update values
+ valMasked = maskValue(valUnmasked);
+
+ oldValue = valMasked;
+ oldValueUnmasked = valUnmasked;
+ iElement.val(valMasked);
+ if (valAltered) {
+ // We've altered the raw value after it's been $digest'ed, we need to $apply the new value.
+ scope.$apply(function (){
+ controller.$setViewValue(valUnmasked);
+ });
+ }
+
+ // Caret Repositioning
+ // ===================
+
+ // Ensure that typing always places caret ahead of typed character in cases where the first char of
+ // the input is a mask char and the caret is placed at the 0 position.
+ if (isAddition && (caretPos <= caretPosMin)) {
+ caretPos = caretPosMin + 1;
+ }
+
+ if (caretBumpBack) {
+ caretPos--;
+ }
+
+ // Make sure caret is within min and max position limits
+ caretPos = caretPos > caretPosMax ? caretPosMax : caretPos < caretPosMin ? caretPosMin : caretPos;
+
+ // Scoot the caret back or forth until it's in a non-mask position and within min/max position limits
+ while (!isValidCaretPosition(caretPos) && caretPos > caretPosMin && caretPos < caretPosMax) {
+ caretPos += caretBumpBack ? -1 : 1;
+ }
+
+ if ((caretBumpBack && caretPos < caretPosMax) || (isAddition && !isValidCaretPosition(caretPosOld))) {
+ caretPos++;
+ }
+ oldCaretPosition = caretPos;
+ setCaretPosition(this, caretPos);
+ }
+
+ function isValidCaretPosition(pos){ return maskCaretMap.indexOf(pos) > -1; }
+
+ function getCaretPosition(input){
+ if (input.selectionStart !== undefined) {
+ return input.selectionStart;
+ } else if (document.selection) {
+ // Curse you IE
+ input.focus();
+ var selection = document.selection.createRange();
+ selection.moveStart('character', -input.value.length);
+ return selection.text.length;
+ }
+ return 0;
+ }
+
+ function setCaretPosition(input, pos){
+ if (input.offsetWidth === 0 || input.offsetHeight === 0) {
+ return; // Input's hidden
+ }
+ if (input.setSelectionRange) {
+ input.focus();
+ input.setSelectionRange(pos, pos);
+ }
+ else if (input.createTextRange) {
+ // Curse you IE
+ var range = input.createTextRange();
+ range.collapse(true);
+ range.moveEnd('character', pos);
+ range.moveStart('character', pos);
+ range.select();
+ }
+ }
+
+ function getSelectionLength(input){
+ if (input.selectionStart !== undefined) {
+ return (input.selectionEnd - input.selectionStart);
+ }
+ if (document.selection) {
+ return (document.selection.createRange().text.length);
+ }
+ return 0;
+ }
+
+ // https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf
+ if (!Array.prototype.indexOf) {
+ Array.prototype.indexOf = function (searchElement /*, fromIndex */){
+ "use strict";
+ if (this === null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (len === 0) {
+ return -1;
+ }
+ var n = 0;
+ if (arguments.length > 1) {
+ n = Number(arguments[1]);
+ if (n !== n) { // shortcut for verifying if it's NaN
+ n = 0;
+ } else if (n !== 0 && n !== Infinity && n !== -Infinity) {
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+ }
+ if (n >= len) {
+ return -1;
+ }
+ var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+ for (; k < len; k++) {
+ if (k in t && t[k] === searchElement) {
+ return k;
+ }
+ }
+ return -1;
+ };
+ }
+
+ };
+ }
+ };
+ }
+]);
+
+/**
+ * Add a clear button to form inputs to reset their value
+ */
+angular.module('ui.reset',[]).value('uiResetConfig',null).directive('uiReset', ['uiResetConfig', function (uiResetConfig) {
+ var resetValue = null;
+ if (uiResetConfig !== undefined){
+ resetValue = uiResetConfig;
+ }
+ return {
+ require: 'ngModel',
+ link: function (scope, elm, attrs, ctrl) {
+ var aElement;
+ aElement = angular.element('');
+ elm.wrap('').after(aElement);
+ aElement.bind('click', function (e) {
+ e.preventDefault();
+ scope.$apply(function () {
+ if (attrs.uiReset){
+ ctrl.$setViewValue(scope.$eval(attrs.uiReset));
+ }else{
+ ctrl.$setViewValue(resetValue);
+ }
+ ctrl.$render();
+ });
+ });
+ }
+ };
+}]);
+
+/**
+ * Set a $uiRoute boolean to see if the current route matches
+ */
+angular.module('ui.route', []).directive('uiRoute', ['$location', '$parse', function ($location, $parse) {
+ return {
+ restrict: 'AC',
+ scope: true,
+ compile: function(tElement, tAttrs) {
+ var useProperty;
+ if (tAttrs.uiRoute) {
+ useProperty = 'uiRoute';
+ } else if (tAttrs.ngHref) {
+ useProperty = 'ngHref';
+ } else if (tAttrs.href) {
+ useProperty = 'href';
+ } else {
+ throw new Error('uiRoute missing a route or href property on ' + tElement[0]);
+ }
+ return function ($scope, elm, attrs) {
+ var modelSetter = $parse(attrs.ngModel || attrs.routeModel || '$uiRoute').assign;
+ var watcher = angular.noop;
+
+ // Used by href and ngHref
+ function staticWatcher(newVal) {
+ if ((hash = newVal.indexOf('#')) > -1){
+ newVal = newVal.substr(hash + 1);
+ }
+ watcher = function watchHref() {
+ modelSetter($scope, ($location.path().indexOf(newVal) > -1));
+ };
+ watcher();
+ }
+ // Used by uiRoute
+ function regexWatcher(newVal) {
+ if ((hash = newVal.indexOf('#')) > -1){
+ newVal = newVal.substr(hash + 1);
+ }
+ watcher = function watchRegex() {
+ var regexp = new RegExp('^' + newVal + '$', ['i']);
+ modelSetter($scope, regexp.test($location.path()));
+ };
+ watcher();
+ }
+
+ switch (useProperty) {
+ case 'uiRoute':
+ // if uiRoute={{}} this will be undefined, otherwise it will have a value and $observe() never gets triggered
+ if (attrs.uiRoute){
+ regexWatcher(attrs.uiRoute);
+ }else{
+ attrs.$observe('uiRoute', regexWatcher);
+ }
+ break;
+ case 'ngHref':
+ // Setup watcher() every time ngHref changes
+ if (attrs.ngHref){
+ staticWatcher(attrs.ngHref);
+ }else{
+ attrs.$observe('ngHref', staticWatcher);
+ }
+ break;
+ case 'href':
+ // Setup watcher()
+ staticWatcher(attrs.href);
+ }
+
+ $scope.$on('$routeChangeSuccess', function(){
+ watcher();
+ });
+
+ //Added for compatibility with ui-router
+ $scope.$on('$stateChangeSuccess', function(){
+ watcher();
+ });
+ };
+ }
+ };
+}]);
+
+/*global angular, $, document*/
+/**
+ * Adds a 'ui-scrollfix' class to the element when the page scrolls past it's position.
+ * @param [offset] {int} optional Y-offset to override the detected offset.
+ * Takes 300 (absolute) or -300 or +300 (relative to detected)
+ */
+angular.module('ui.scrollfix',[]).directive('uiScrollfix', ['$window', function ($window) {
+ 'use strict';
+ return {
+ require: '^?uiScrollfixTarget',
+ link: function (scope, elm, attrs, uiScrollfixTarget) {
+ var top = elm[0].offsetTop,
+ $target = uiScrollfixTarget && uiScrollfixTarget.$element || angular.element($window);
+ if (!attrs.uiScrollfix) {
+ attrs.uiScrollfix = top;
+ } else if (typeof(attrs.uiScrollfix) === 'string') {
+ // charAt is generally faster than indexOf: http://jsperf.com/indexof-vs-charat
+ if (attrs.uiScrollfix.charAt(0) === '-') {
+ attrs.uiScrollfix = top - parseFloat(attrs.uiScrollfix.substr(1));
+ } else if (attrs.uiScrollfix.charAt(0) === '+') {
+ attrs.uiScrollfix = top + parseFloat(attrs.uiScrollfix.substr(1));
+ }
+ }
+
+ $target.bind('scroll', function () {
+ // if pageYOffset is defined use it, otherwise use other crap for IE
+ var offset;
+ if (angular.isDefined($window.pageYOffset)) {
+ offset = $window.pageYOffset;
+ } else {
+ var iebody = (document.compatMode && document.compatMode !== "BackCompat") ? document.documentElement : document.body;
+ offset = iebody.scrollTop;
+ }
+ if (!elm.hasClass('ui-scrollfix') && offset > attrs.uiScrollfix) {
+ elm.addClass('ui-scrollfix');
+ } else if (elm.hasClass('ui-scrollfix') && offset < attrs.uiScrollfix) {
+ elm.removeClass('ui-scrollfix');
+ }
+ });
+ }
+ };
+}]).directive('uiScrollfixTarget', [function () {
+ 'use strict';
+ return {
+ controller: function($element) {
+ this.$element = $element;
+ }
+ };
+}]);
+
+/**
+ * uiShow Directive
+ *
+ * Adds a 'ui-show' class to the element instead of display:block
+ * Created to allow tighter control of CSS without bulkier directives
+ *
+ * @param expression {boolean} evaluated expression to determine if the class should be added
+ */
+angular.module('ui.showhide',[])
+.directive('uiShow', [function () {
+ return function (scope, elm, attrs) {
+ scope.$watch(attrs.uiShow, function (newVal, oldVal) {
+ if (newVal) {
+ elm.addClass('ui-show');
+ } else {
+ elm.removeClass('ui-show');
+ }
+ });
+ };
+}])
+
+/**
+ * uiHide Directive
+ *
+ * Adds a 'ui-hide' class to the element instead of display:block
+ * Created to allow tighter control of CSS without bulkier directives
+ *
+ * @param expression {boolean} evaluated expression to determine if the class should be added
+ */
+.directive('uiHide', [function () {
+ return function (scope, elm, attrs) {
+ scope.$watch(attrs.uiHide, function (newVal, oldVal) {
+ if (newVal) {
+ elm.addClass('ui-hide');
+ } else {
+ elm.removeClass('ui-hide');
+ }
+ });
+ };
+}])
+
+/**
+ * uiToggle Directive
+ *
+ * Adds a class 'ui-show' if true, and a 'ui-hide' if false to the element instead of display:block/display:none
+ * Created to allow tighter control of CSS without bulkier directives. This also allows you to override the
+ * default visibility of the element using either class.
+ *
+ * @param expression {boolean} evaluated expression to determine if the class should be added
+ */
+.directive('uiToggle', [function () {
+ return function (scope, elm, attrs) {
+ scope.$watch(attrs.uiToggle, function (newVal, oldVal) {
+ if (newVal) {
+ elm.removeClass('ui-hide').addClass('ui-show');
+ } else {
+ elm.removeClass('ui-show').addClass('ui-hide');
+ }
+ });
+ };
+}]);
+
+/**
+ * Filters out all duplicate items from an array by checking the specified key
+ * @param [key] {string} the name of the attribute of each object to compare for uniqueness
+ if the key is empty, the entire object will be compared
+ if the key === false then no filtering will be performed
+ * @return {array}
+ */
+angular.module('ui.unique',[]).filter('unique', ['$parse', function ($parse) {
+
+ return function (items, filterOn) {
+
+ if (filterOn === false) {
+ return items;
+ }
+
+ if ((filterOn || angular.isUndefined(filterOn)) && angular.isArray(items)) {
+ var hashCheck = {}, newItems = [],
+ get = angular.isString(filterOn) ? $parse(filterOn) : function (item) { return item; };
+
+ var extractValueToCompare = function (item) {
+ return angular.isObject(item) ? get(item) : item;
+ };
+
+ angular.forEach(items, function (item) {
+ var valueToCheck, isDuplicate = false;
+
+ for (var i = 0; i < newItems.length; i++) {
+ if (angular.equals(extractValueToCompare(newItems[i]), extractValueToCompare(item))) {
+ isDuplicate = true;
+ break;
+ }
+ }
+ if (!isDuplicate) {
+ newItems.push(item);
+ }
+
+ });
+ items = newItems;
+ }
+ return items;
+ };
+}]);
+
+/**
+ * General-purpose validator for ngModel.
+ * angular.js comes with several built-in validation mechanism for input fields (ngRequired, ngPattern etc.) but using
+ * an arbitrary validation function requires creation of a custom formatters and / or parsers.
+ * The ui-validate directive makes it easy to use any function(s) defined in scope as a validator function(s).
+ * A validator function will trigger validation on both model and input changes.
+ *
+ * @example
+ * @example
+ * @example
+ * @example
+ *
+ * @param ui-validate {string|object literal} If strings is passed it should be a scope's function to be used as a validator.
+ * If an object literal is passed a key denotes a validation error key while a value should be a validator function.
+ * In both cases validator function should take a value to validate as its argument and should return true/false indicating a validation result.
+ */
+angular.module('ui.validate',[]).directive('uiValidate', function () {
+
+ return {
+ restrict: 'A',
+ require: 'ngModel',
+ link: function (scope, elm, attrs, ctrl) {
+ var validateFn, watch, validators = {},
+ validateExpr = scope.$eval(attrs.uiValidate);
+
+ if (!validateExpr){ return;}
+
+ if (angular.isString(validateExpr)) {
+ validateExpr = { validator: validateExpr };
+ }
+
+ angular.forEach(validateExpr, function (exprssn, key) {
+ validateFn = function (valueToValidate) {
+ var expression = scope.$eval(exprssn, { '$value' : valueToValidate });
+ if (angular.isObject(expression) && angular.isFunction(expression.then)) {
+ // expression is a promise
+ expression.then(function(){
+ ctrl.$setValidity(key, true);
+ }, function(){
+ ctrl.$setValidity(key, false);
+ });
+ return valueToValidate;
+ } else if (expression) {
+ // expression is true
+ ctrl.$setValidity(key, true);
+ return valueToValidate;
+ } else {
+ // expression is false
+ ctrl.$setValidity(key, false);
+ return undefined;
+ }
+ };
+ validators[key] = validateFn;
+ ctrl.$formatters.push(validateFn);
+ ctrl.$parsers.push(validateFn);
+ });
+
+ // Support for ui-validate-watch
+ if (attrs.uiValidateWatch) {
+ watch = scope.$eval(attrs.uiValidateWatch);
+ if (angular.isString(watch)) {
+ scope.$watch(watch, function(){
+ angular.forEach(validators, function(validatorFn, key){
+ validatorFn(ctrl.$modelValue);
+ });
+ });
+ } else {
+ angular.forEach(watch, function(expression, key){
+ scope.$watch(expression, function(){
+ validators[key](ctrl.$modelValue);
+ });
+ });
+ }
+ }
+ }
+ };
+});
+
+angular.module('ui.utils', [
+ "ui.event",
+ "ui.format",
+ "ui.highlight",
+ "ui.indeterminate",
+ "ui.inflector",
+ "ui.jq",
+ "ui.keypress",
+ "ui.mask",
+ "ui.reset",
+ "ui.route",
+ "ui.scrollfix",
+ "ui.showhide",
+ "ui.unique",
+ "ui.validate"
+]);
\ No newline at end of file
diff --git a/docs-web/src/main/webapp/partial/document.default.html b/docs-web/src/main/webapp/partial/document.default.html
new file mode 100644
index 00000000..381c5acf
--- /dev/null
+++ b/docs-web/src/main/webapp/partial/document.default.html
@@ -0,0 +1,8 @@
+
+ {{ documents.total }} document{{ documents.total > 1 ? 's' : '' }} in the database
+
+
+
+
There seems to be a kind of order in the universe, in the movement of the stars and the turning of the earth and the changing of the seasons, and even in the cycle of human life. But human life itself is almost pure chaos. Everyone takes his stance, asserts his own rights and feelings, mistaking the motives of others, and his own.