\n"+c(a,2):"\n\n\n <\!-- CACHE FILE: "+a+' --\>\n
38 |
39 |
40 | */
41 | factory('$cookies', ['$rootScope', '$browser', function ($rootScope, $browser) {
42 | var cookies = {},
43 | lastCookies = {},
44 | lastBrowserCookies,
45 | runEval = false,
46 | copy = angular.copy,
47 | isUndefined = angular.isUndefined;
48 |
49 | //creates a poller fn that copies all cookies from the $browser to service & inits the service
50 | $browser.addPollFn(function() {
51 | var currentCookies = $browser.cookies();
52 | if (lastBrowserCookies != currentCookies) { //relies on browser.cookies() impl
53 | lastBrowserCookies = currentCookies;
54 | copy(currentCookies, lastCookies);
55 | copy(currentCookies, cookies);
56 | if (runEval) $rootScope.$apply();
57 | }
58 | })();
59 |
60 | runEval = true;
61 |
62 | //at the end of each eval, push cookies
63 | //TODO: this should happen before the "delayed" watches fire, because if some cookies are not
64 | // strings or browser refuses to store some cookies, we update the model in the push fn.
65 | $rootScope.$watch(push);
66 |
67 | return cookies;
68 |
69 |
70 | /**
71 | * Pushes all the cookies from the service to the browser and verifies if all cookies were stored.
72 | */
73 | function push() {
74 | var name,
75 | value,
76 | browserCookies,
77 | updated;
78 |
79 | //delete any cookies deleted in $cookies
80 | for (name in lastCookies) {
81 | if (isUndefined(cookies[name])) {
82 | $browser.cookies(name, undefined);
83 | }
84 | }
85 |
86 | //update all cookies updated in $cookies
87 | for(name in cookies) {
88 | value = cookies[name];
89 | if (!angular.isString(value)) {
90 | if (angular.isDefined(lastCookies[name])) {
91 | cookies[name] = lastCookies[name];
92 | } else {
93 | delete cookies[name];
94 | }
95 | } else if (value !== lastCookies[name]) {
96 | $browser.cookies(name, value);
97 | updated = true;
98 | }
99 | }
100 |
101 | //verify what was actually stored
102 | if (updated){
103 | updated = false;
104 | browserCookies = $browser.cookies();
105 |
106 | for (name in cookies) {
107 | if (cookies[name] !== browserCookies[name]) {
108 | //delete or reset all cookies that the browser dropped from $cookies
109 | if (isUndefined(browserCookies[name])) {
110 | delete cookies[name];
111 | } else {
112 | cookies[name] = browserCookies[name];
113 | }
114 | updated = true;
115 | }
116 | }
117 | }
118 | }
119 | }]).
120 |
121 |
122 | /**
123 | * @ngdoc object
124 | * @name ngCookies.$cookieStore
125 | * @requires $cookies
126 | *
127 | * @description
128 | * Provides a key-value (string-object) storage, that is backed by session cookies.
129 | * Objects put or retrieved from this storage are automatically serialized or
130 | * deserialized by angular's toJson/fromJson.
131 | * @example
132 | */
133 | factory('$cookieStore', ['$cookies', function($cookies) {
134 |
135 | return {
136 | /**
137 | * @ngdoc method
138 | * @name ngCookies.$cookieStore#get
139 | * @methodOf ngCookies.$cookieStore
140 | *
141 | * @description
142 | * Returns the value of given cookie key
143 | *
144 | * @param {string} key Id to use for lookup.
145 | * @returns {Object} Deserialized cookie value.
146 | */
147 | get: function(key) {
148 | var value = $cookies[key];
149 | return value ? angular.fromJson(value) : value;
150 | },
151 |
152 | /**
153 | * @ngdoc method
154 | * @name ngCookies.$cookieStore#put
155 | * @methodOf ngCookies.$cookieStore
156 | *
157 | * @description
158 | * Sets a value for given cookie key
159 | *
160 | * @param {string} key Id for the `value`.
161 | * @param {Object} value Value to be stored.
162 | */
163 | put: function(key, value) {
164 | $cookies[key] = angular.toJson(value);
165 | },
166 |
167 | /**
168 | * @ngdoc method
169 | * @name ngCookies.$cookieStore#remove
170 | * @methodOf ngCookies.$cookieStore
171 | *
172 | * @description
173 | * Remove given cookie
174 | *
175 | * @param {string} key Id of the key-value pair to delete.
176 | */
177 | remove: function(key) {
178 | delete $cookies[key];
179 | }
180 | };
181 |
182 | }]);
183 |
184 |
185 | })(window, window.angular);
186 |
--------------------------------------------------------------------------------
/js/lib/angular/angular-cookies.min.js:
--------------------------------------------------------------------------------
1 | /*
2 | AngularJS v1.0.7
3 | (c) 2010-2012 Google, Inc. http://angularjs.org
4 | License: MIT
5 | */
6 | (function(m,f,l){'use strict';f.module("ngCookies",["ng"]).factory("$cookies",["$rootScope","$browser",function(d,b){var c={},g={},h,i=!1,j=f.copy,k=f.isUndefined;b.addPollFn(function(){var a=b.cookies();h!=a&&(h=a,j(a,g),j(a,c),i&&d.$apply())})();i=!0;d.$watch(function(){var a,e,d;for(a in g)k(c[a])&&b.cookies(a,l);for(a in c)e=c[a],f.isString(e)?e!==g[a]&&(b.cookies(a,e),d=!0):f.isDefined(g[a])?c[a]=g[a]:delete c[a];if(d)for(a in e=b.cookies(),c)c[a]!==e[a]&&(k(e[a])?delete c[a]:c[a]=e[a])});return c}]).factory("$cookieStore",
7 | ["$cookies",function(d){return{get:function(b){return(b=d[b])?f.fromJson(b):b},put:function(b,c){d[b]=f.toJson(c)},remove:function(b){delete d[b]}}}])})(window,window.angular);
8 |
--------------------------------------------------------------------------------
/js/lib/angular/angular-loader.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @license AngularJS v1.0.7
3 | * (c) 2010-2012 Google, Inc. http://angularjs.org
4 | * License: MIT
5 | */
6 |
7 | (
8 |
9 | /**
10 | * @ngdoc interface
11 | * @name angular.Module
12 | * @description
13 | *
14 | * Interface for configuring angular {@link angular.module modules}.
15 | */
16 |
17 | function setupModuleLoader(window) {
18 |
19 | function ensure(obj, name, factory) {
20 | return obj[name] || (obj[name] = factory());
21 | }
22 |
23 | return ensure(ensure(window, 'angular', Object), 'module', function() {
24 | /** @type {Object.
} */
25 | var modules = {};
26 |
27 | /**
28 | * @ngdoc function
29 | * @name angular.module
30 | * @description
31 | *
32 | * The `angular.module` is a global place for creating and registering Angular modules. All
33 | * modules (angular core or 3rd party) that should be available to an application must be
34 | * registered using this mechanism.
35 | *
36 | *
37 | * # Module
38 | *
39 | * A module is a collocation of services, directives, filters, and configuration information. Module
40 | * is used to configure the {@link AUTO.$injector $injector}.
41 | *
42 | *
43 | * // Create a new module
44 | * var myModule = angular.module('myModule', []);
45 | *
46 | * // register a new service
47 | * myModule.value('appName', 'MyCoolApp');
48 | *
49 | * // configure existing services inside initialization blocks.
50 | * myModule.config(function($locationProvider) {
51 | 'use strict';
52 | * // Configure existing providers
53 | * $locationProvider.hashPrefix('!');
54 | * });
55 | *
56 | *
57 | * Then you can create an injector and load your modules like this:
58 | *
59 | *
60 | * var injector = angular.injector(['ng', 'MyModule'])
61 | *
62 | *
63 | * However it's more likely that you'll just use
64 | * {@link ng.directive:ngApp ngApp} or
65 | * {@link angular.bootstrap} to simplify this process for you.
66 | *
67 | * @param {!string} name The name of the module to create or retrieve.
68 | * @param {Array.=} requires If specified then new module is being created. If unspecified then the
69 | * the module is being retrieved for further configuration.
70 | * @param {Function} configFn Optional configuration function for the module. Same as
71 | * {@link angular.Module#config Module#config()}.
72 | * @returns {module} new module with the {@link angular.Module} api.
73 | */
74 | return function module(name, requires, configFn) {
75 | if (requires && modules.hasOwnProperty(name)) {
76 | modules[name] = null;
77 | }
78 | return ensure(modules, name, function() {
79 | if (!requires) {
80 | throw Error('No module: ' + name);
81 | }
82 |
83 | /** @type {!Array.>} */
84 | var invokeQueue = [];
85 |
86 | /** @type {!Array.} */
87 | var runBlocks = [];
88 |
89 | var config = invokeLater('$injector', 'invoke');
90 |
91 | /** @type {angular.Module} */
92 | var moduleInstance = {
93 | // Private state
94 | _invokeQueue: invokeQueue,
95 | _runBlocks: runBlocks,
96 |
97 | /**
98 | * @ngdoc property
99 | * @name angular.Module#requires
100 | * @propertyOf angular.Module
101 | * @returns {Array.} List of module names which must be loaded before this module.
102 | * @description
103 | * Holds the list of modules which the injector will load before the current module is loaded.
104 | */
105 | requires: requires,
106 |
107 | /**
108 | * @ngdoc property
109 | * @name angular.Module#name
110 | * @propertyOf angular.Module
111 | * @returns {string} Name of the module.
112 | * @description
113 | */
114 | name: name,
115 |
116 |
117 | /**
118 | * @ngdoc method
119 | * @name angular.Module#provider
120 | * @methodOf angular.Module
121 | * @param {string} name service name
122 | * @param {Function} providerType Construction function for creating new instance of the service.
123 | * @description
124 | * See {@link AUTO.$provide#provider $provide.provider()}.
125 | */
126 | provider: invokeLater('$provide', 'provider'),
127 |
128 | /**
129 | * @ngdoc method
130 | * @name angular.Module#factory
131 | * @methodOf angular.Module
132 | * @param {string} name service name
133 | * @param {Function} providerFunction Function for creating new instance of the service.
134 | * @description
135 | * See {@link AUTO.$provide#factory $provide.factory()}.
136 | */
137 | factory: invokeLater('$provide', 'factory'),
138 |
139 | /**
140 | * @ngdoc method
141 | * @name angular.Module#service
142 | * @methodOf angular.Module
143 | * @param {string} name service name
144 | * @param {Function} constructor A constructor function that will be instantiated.
145 | * @description
146 | * See {@link AUTO.$provide#service $provide.service()}.
147 | */
148 | service: invokeLater('$provide', 'service'),
149 |
150 | /**
151 | * @ngdoc method
152 | * @name angular.Module#value
153 | * @methodOf angular.Module
154 | * @param {string} name service name
155 | * @param {*} object Service instance object.
156 | * @description
157 | * See {@link AUTO.$provide#value $provide.value()}.
158 | */
159 | value: invokeLater('$provide', 'value'),
160 |
161 | /**
162 | * @ngdoc method
163 | * @name angular.Module#constant
164 | * @methodOf angular.Module
165 | * @param {string} name constant name
166 | * @param {*} object Constant value.
167 | * @description
168 | * Because the constant are fixed, they get applied before other provide methods.
169 | * See {@link AUTO.$provide#constant $provide.constant()}.
170 | */
171 | constant: invokeLater('$provide', 'constant', 'unshift'),
172 |
173 | /**
174 | * @ngdoc method
175 | * @name angular.Module#filter
176 | * @methodOf angular.Module
177 | * @param {string} name Filter name.
178 | * @param {Function} filterFactory Factory function for creating new instance of filter.
179 | * @description
180 | * See {@link ng.$filterProvider#register $filterProvider.register()}.
181 | */
182 | filter: invokeLater('$filterProvider', 'register'),
183 |
184 | /**
185 | * @ngdoc method
186 | * @name angular.Module#controller
187 | * @methodOf angular.Module
188 | * @param {string} name Controller name.
189 | * @param {Function} constructor Controller constructor function.
190 | * @description
191 | * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
192 | */
193 | controller: invokeLater('$controllerProvider', 'register'),
194 |
195 | /**
196 | * @ngdoc method
197 | * @name angular.Module#directive
198 | * @methodOf angular.Module
199 | * @param {string} name directive name
200 | * @param {Function} directiveFactory Factory function for creating new instance of
201 | * directives.
202 | * @description
203 | * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
204 | */
205 | directive: invokeLater('$compileProvider', 'directive'),
206 |
207 | /**
208 | * @ngdoc method
209 | * @name angular.Module#config
210 | * @methodOf angular.Module
211 | * @param {Function} configFn Execute this function on module load. Useful for service
212 | * configuration.
213 | * @description
214 | * Use this method to register work which needs to be performed on module loading.
215 | */
216 | config: config,
217 |
218 | /**
219 | * @ngdoc method
220 | * @name angular.Module#run
221 | * @methodOf angular.Module
222 | * @param {Function} initializationFn Execute this function after injector creation.
223 | * Useful for application initialization.
224 | * @description
225 | * Use this method to register work which should be performed when the injector is done
226 | * loading all modules.
227 | */
228 | run: function(block) {
229 | runBlocks.push(block);
230 | return this;
231 | }
232 | };
233 |
234 | if (configFn) {
235 | config(configFn);
236 | }
237 |
238 | return moduleInstance;
239 |
240 | /**
241 | * @param {string} provider
242 | * @param {string} method
243 | * @param {String=} insertMethod
244 | * @returns {angular.Module}
245 | */
246 | function invokeLater(provider, method, insertMethod) {
247 | return function() {
248 | invokeQueue[insertMethod || 'push']([provider, method, arguments]);
249 | return moduleInstance;
250 | }
251 | }
252 | });
253 | };
254 | });
255 |
256 | }
257 |
258 | )(window);
259 |
260 | /**
261 | * Closure compiler type information
262 | *
263 | * @typedef { {
264 | * requires: !Array.,
265 | * invokeQueue: !Array.>,
266 | *
267 | * service: function(string, Function):angular.Module,
268 | * factory: function(string, Function):angular.Module,
269 | * value: function(string, *):angular.Module,
270 | *
271 | * filter: function(string, Function):angular.Module,
272 | *
273 | * init: function(Function):angular.Module
274 | * } }
275 | */
276 | angular.Module;
277 |
278 |
--------------------------------------------------------------------------------
/js/lib/angular/angular-loader.min.js:
--------------------------------------------------------------------------------
1 | /*
2 | AngularJS v1.0.7
3 | (c) 2010-2012 Google, Inc. http://angularjs.org
4 | License: MIT
5 | */
6 | (function(i){'use strict';function d(c,b,e){return c[b]||(c[b]=e())}return d(d(i,"angular",Object),"module",function(){var c={};return function(b,e,f){e&&c.hasOwnProperty(b)&&(c[b]=null);return d(c,b,function(){function a(a,b,d){return function(){c[d||"push"]([a,b,arguments]);return g}}if(!e)throw Error("No module: "+b);var c=[],d=[],h=a("$injector","invoke"),g={_invokeQueue:c,_runBlocks:d,requires:e,name:b,provider:a("$provide","provider"),factory:a("$provide","factory"),service:a("$provide","service"),
7 | value:a("$provide","value"),constant:a("$provide","constant","unshift"),filter:a("$filterProvider","register"),controller:a("$controllerProvider","register"),directive:a("$compileProvider","directive"),config:h,run:function(a){d.push(a);return this}};f&&h(f);return g})}})})(window);
8 |
--------------------------------------------------------------------------------
/js/lib/angular/angular-resource.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @license AngularJS v1.0.7
3 | * (c) 2010-2012 Google, Inc. http://angularjs.org
4 | * License: MIT
5 | */
6 | (function(window, angular, undefined) {
7 | 'use strict';
8 |
9 | /**
10 | * @ngdoc overview
11 | * @name ngResource
12 | * @description
13 | */
14 |
15 | /**
16 | * @ngdoc object
17 | * @name ngResource.$resource
18 | * @requires $http
19 | *
20 | * @description
21 | * A factory which creates a resource object that lets you interact with
22 | * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
23 | *
24 | * The returned resource object has action methods which provide high-level behaviors without
25 | * the need to interact with the low level {@link ng.$http $http} service.
26 | *
27 | * # Installation
28 | * To use $resource make sure you have included the `angular-resource.js` that comes in Angular
29 | * package. You can also find this file on Google CDN, bower as well as at
30 | * {@link http://code.angularjs.org/ code.angularjs.org}.
31 | *
32 | * Finally load the module in your application:
33 | *
34 | * angular.module('app', ['ngResource']);
35 | *
36 | * and you are ready to get started!
37 | *
38 | * @param {string} url A parameterized URL template with parameters prefixed by `:` as in
39 | * `/user/:username`. If you are using a URL with a port number (e.g.
40 | * `http://example.com:8080/api`), you'll need to escape the colon character before the port
41 | * number, like this: `$resource('http://example.com\\:8080/api')`.
42 | *
43 | * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
44 | * `actions` methods.
45 | *
46 | * Each key value in the parameter object is first bound to url template if present and then any
47 | * excess keys are appended to the url search query after the `?`.
48 | *
49 | * Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in
50 | * URL `/path/greet?salutation=Hello`.
51 | *
52 | * If the parameter value is prefixed with `@` then the value of that parameter is extracted from
53 | * the data object (useful for non-GET operations).
54 | *
55 | * @param {Object.