faalis 0.7.0

data/app/assets/javascripts/faalis/dashboard/lib/ng-quick-date.js

@@ -0,0 +1,297 @@
+(function() {
+  var app;
+
+  app = angular.module("ngQuickDate", []);
+
+  app.provider("ngQuickDateDefaults", function() {
+    return {
+      options: {
+        dateFormat: 'M/d/yyyy',
+        timeFormat: 'h:mm a',
+        labelFormat: null,
+        placeholder: 'Click to Set Date',
+        hoverText: null,
+        buttonIconHtml: null,
+        closeButtonHtml: 'X',
+        nextLinkHtml: 'Next',
+        prevLinkHtml: 'Prev',
+        disableTimepicker: false,
+        disableClearButton: false,
+        dayAbbreviations: ["Su", "M", "Tu", "W", "Th", "F", "Sa"],
+        parseDateFunction: function(str) {
+          var seconds;
+          seconds = Date.parse(str);
+          if (isNaN(seconds)) {
+            return null;
+          } else {
+            return new Date(seconds);
+          }
+        }
+      },
+      $get: function() {
+        return this.options;
+      },
+      set: function(keyOrHash, value) {
+        var k, v, _results;
+        if (typeof keyOrHash === 'object') {
+          _results = [];
+          for (k in keyOrHash) {
+            v = keyOrHash[k];
+            _results.push(this.options[k] = v);
+          }
+          return _results;
+        } else {
+          return this.options[keyOrHash] = value;
+        }
+      }
+    };
+  });
+
+  app.directive("datepicker", [
+    'ngQuickDateDefaults', '$filter', '$sce', function(ngQuickDateDefaults, $filter, $sce) {
+      return {
+        restrict: "E",
+        require: "ngModel",
+        scope: {
+          ngModel: "=",
+          onChange: "&"
+        },
+        replace: true,
+        link: function(scope, element, attrs, ngModel) {
+          var dateToString, datepickerClicked, datesAreEqual, debug, getDaysInMonth, initialize, parseDateString, setCalendarDateFromModel, setCalendarRows, setConfigOptions, setInputDateFromModel;
+          debug = attrs.debug && attrs.debug.length;
+          initialize = function() {
+            scope.toggleCalendar(false);
+            scope.weeks = [];
+            scope.inputDate = null;
+            if (typeof scope.ngModel === 'string') {
+              scope.ngModel = parseDateString(scope.ngModel);
+            }
+            setConfigOptions();
+            setInputDateFromModel();
+            return setCalendarDateFromModel();
+          };
+          setConfigOptions = function() {
+            var key, value;
+            for (key in ngQuickDateDefaults) {
+              value = ngQuickDateDefaults[key];
+              if (key.match(/[Hh]tml/)) {
+                scope[key] = $sce.trustAsHtml(ngQuickDateDefaults[key] || "");
+              } else if (attrs[key]) {
+                scope[key] = attrs[key];
+              } else {
+                scope[key] = ngQuickDateDefaults[key];
+              }
+            }
+            if (!scope.labelFormat) {
+              scope.labelFormat = scope.dateFormat;
+              if (!scope.disableTimepicker) {
+                scope.labelFormat += " " + scope.timeFormat;
+              }
+            }
+            if (attrs.iconClass && attrs.iconClass.length) {
+              return scope.buttonIconHtml = $sce.trustAsHtml("<i ng-show='iconClass' class='" + attrs.iconClass + "'></i>");
+            }
+          };
+          datepickerClicked = false;
+          window.document.addEventListener('click', function(event) {
+            if (!datepickerClicked) {
+              scope.toggleCalendar(false);
+              scope.$apply();
+            }
+            return datepickerClicked = false;
+          });
+          angular.element(element[0])[0].addEventListener('click', function(event) {
+            return datepickerClicked = true;
+          });
+          setInputDateFromModel = function() {
+            if (scope.ngModel) {
+              scope.inputDate = $filter('date')(scope.ngModel, ngQuickDateDefaults.dateFormat);
+              return scope.inputTime = $filter('date')(scope.ngModel, ngQuickDateDefaults.timeFormat);
+            } else {
+              scope.inputDate = null;
+              return scope.inputTime = null;
+            }
+          };
+          setCalendarDateFromModel = function() {
+            var d;
+            d = scope.ngModel ? new Date(scope.ngModel) : new Date();
+            if (d.toString() === "Invalid Date") {
+              d = new Date();
+            }
+            d.setDate(1);
+            return scope.calendarDate = new Date(d);
+          };
+          setCalendarRows = function() {
+            var curDate, d, day, daysInMonth, numRows, offset, row, selected, today, weeks, _i, _j, _ref;
+            offset = scope.calendarDate.getDay();
+            daysInMonth = getDaysInMonth(scope.calendarDate.getFullYear(), scope.calendarDate.getMonth());
+            numRows = Math.ceil((offset + daysInMonth) / 7);
+            weeks = [];
+            curDate = new Date(scope.calendarDate);
+            curDate.setDate(curDate.getDate() + (offset * -1));
+            for (row = _i = 0, _ref = numRows - 1; 0 <= _ref ? _i <= _ref : _i >= _ref; row = 0 <= _ref ? ++_i : --_i) {
+              weeks.push([]);
+              for (day = _j = 0; _j <= 6; day = ++_j) {
+                d = new Date(curDate);
+                selected = scope.ngModel && d && datesAreEqual(d, scope.ngModel);
+                today = datesAreEqual(d, new Date());
+                weeks[row].push({
+                  date: d,
+                  selected: selected,
+                  other: d.getMonth() !== scope.calendarDate.getMonth(),
+                  today: today
+                });
+                curDate.setDate(curDate.getDate() + 1);
+              }
+            }
+            return scope.weeks = weeks;
+          };
+          dateToString = function(date, format) {
+            return $filter('date')(date, format);
+          };
+          parseDateString = ngQuickDateDefaults.parseDateFunction;
+          datesAreEqual = function(d1, d2, compareTimes) {
+            if (compareTimes == null) {
+              compareTimes = false;
+            }
+            if (compareTimes) {
+              return (d1 - d2) === 0;
+            } else {
+              return d1 && d2 && (d1.getYear() === d2.getYear()) && (d1.getMonth() === d2.getMonth()) && (d1.getDate() === d2.getDate());
+            }
+          };
+          getDaysInMonth = function(year, month) {
+            return [31, ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0 ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
+          };
+          scope.$watch('ngModel', function(newVal, oldVal) {
+            if (newVal !== oldVal) {
+              setInputDateFromModel();
+              return setCalendarDateFromModel();
+            }
+          });
+          scope.$watch('calendarDate', function(newVal, oldVal) {
+            if (newVal !== oldVal) {
+              return setCalendarRows();
+            }
+          });
+          scope.$watch('calendarShown', function(newVal, oldVal) {
+            var dateInput;
+            dateInput = angular.element(element[0].querySelector(".quickdate-date-input"))[0];
+            return dateInput.select();
+          });
+          scope.mainButtonStr = function() {
+            if (scope.ngModel) {
+              return $filter('date')(scope.ngModel, scope.labelFormat);
+            } else {
+              return scope.placeholder;
+            }
+          };
+          scope.toggleCalendar = function(show) {
+            if (isFinite(show)) {
+              return scope.calendarShown = show;
+            } else {
+              return scope.calendarShown = !scope.calendarShown;
+            }
+          };
+          scope.setDate = function(date, closeCalendar) {
+            var changed;
+            if (closeCalendar == null) {
+              closeCalendar = true;
+            }
+            changed = (!scope.ngModel && date) || (scope.ngModel && !date) || (date.getTime() !== scope.ngModel.getTime());
+            scope.ngModel = date;
+            if (closeCalendar) {
+              scope.toggleCalendar(false);
+            }
+            if (changed && scope.onChange) {
+              return scope.onChange();
+            }
+          };
+          scope.setDateFromInput = function(closeCalendar) {
+            var err, tmpDate, tmpDateAndTime, tmpTime;
+            if (closeCalendar == null) {
+              closeCalendar = false;
+            }
+            try {
+              tmpDate = parseDateString(scope.inputDate);
+              if (!tmpDate) {
+                throw 'Invalid Date';
+              }
+              if (!scope.disableTimepicker && scope.inputTime && scope.inputTime.length && tmpDate) {
+                tmpTime = scope.disableTimepicker ? '00:00:00' : scope.inputTime;
+                tmpDateAndTime = parseDateString("" + scope.inputDate + " " + tmpTime);
+                if (!tmpDateAndTime) {
+                  throw 'Invalid Time';
+                }
+                scope.setDate(tmpDateAndTime, false);
+              } else {
+                scope.setDate(tmpDate, false);
+              }
+              if (closeCalendar) {
+                scope.toggleCalendar(false);
+              }
+              scope.inputDateErr = false;
+              return scope.inputTimeErr = false;
+            } catch (_error) {
+              err = _error;
+              if (err === 'Invalid Date') {
+                return scope.inputDateErr = true;
+              } else if (err === 'Invalid Time') {
+                return scope.inputTimeErr = true;
+              }
+            }
+          };
+          scope.onDateInputTab = function(param) {
+            if (scope.disableTimepicker) {
+              scope.toggleCalendar(false);
+            }
+            return true;
+          };
+          scope.onTimeInputTab = function(param) {
+            scope.toggleCalendar(false);
+            return true;
+          };
+          scope.nextMonth = function() {
+            return scope.calendarDate = new Date(new Date(scope.calendarDate).setMonth(scope.calendarDate.getMonth() + 1));
+          };
+          scope.prevMonth = function() {
+            return scope.calendarDate = new Date(new Date(scope.calendarDate).setMonth(scope.calendarDate.getMonth() - 1));
+          };
+          scope.clear = function() {
+            scope.ngModel = null;
+            return scope.toggleCalendar(false);
+          };
+          initialize();
+          setCalendarRows();
+          if (debug) {
+            return console.log("quick date scope:", scope);
+          }
+        },
+        template: "<div class='quickdate'>\n  <a href='' ng-focus='toggleCalendar(true)' ng-click='toggleCalendar()' class='quickdate-button' title='{{hoverText}}'><div ng-hide='iconClass' ng-bind-html='buttonIconHtml'></div>{{mainButtonStr()}}</a>\n  <div class='quickdate-popup' ng-class='{open: calendarShown}'>\n    <a href='' tabindex='-1' class='quickdate-close' ng-click='toggleCalendar()'><div ng-bind-html='closeButtonHtml'></div></a>\n    <div class='quickdate-text-inputs'>\n      <div class='quickdate-input-wrapper'>\n        <label>Date</label>\n        <input class='quickdate-date-input' name='inputDate' type='text' ng-model='inputDate' placeholder='1/1/2013' ng-blur=\"setDateFromInput()\" ng-enter=\"setDateFromInput(true)\" ng-class=\"{'ng-quick-date-error': inputDateErr}\"  ng-tab='onDateInputTab()' />\n      </div>\n      <div class='quickdate-input-wrapper' ng-hide='disableTimepicker'>\n        <label>Time</label>\n        <input class='quickdate-time-input' name='inputTime' type='text' ng-model='inputTime' placeholder='12:00 PM' ng-blur=\"setDateFromInput(false)\" ng-enter=\"setDateFromInput(true)\" ng-class=\"{'quickdate-error': inputTimeErr}\" ng-tab='onTimeInputTab()'>\n      </div>\n    </div>\n    <div class='quickdate-calendar-header'>\n      <a href='' class='quickdate-prev-month quickdate-action-link' tabindex='-1' ng-click='prevMonth()'><div ng-bind-html='prevLinkHtml'></div></a>\n      <span class='quickdate-month'>{{calendarDate | date:'MMMM yyyy'}}</span>\n      <a href='' class='quickdate-next-month quickdate-action-link' ng-click='nextMonth()' tabindex='-1' ><div ng-bind-html='nextLinkHtml'></div></a>\n    </div>\n    <table class='quickdate-calendar'>\n      <thead>\n        <tr>\n          <th ng-repeat='day in dayAbbreviations'>{{day}}</th>\n        </tr>\n      </thead>\n      <tbody>\n        <tr ng-repeat='week in weeks'>\n          <td ng-mousedown='setDate(day.date)' ng-class='{\"other-month\": day.other, \"selected\": day.selected, \"is-today\": day.today}' ng-repeat='day in week'>{{day.date | date:'d'}}</td>\n        </tr>\n      </tbody>\n    </table>\n    <div class='quickdate-popup-footer'>\n      <a href='' class='quickdate-clear' tabindex='-1' ng-hide='disableClearButton' ng-click='clear()'>Clear</a>\n    </div>\n  </div>\n</div>"
+      };
+    }
+  ]);
+
+  app.directive('ngEnter', function() {
+    return function(scope, element, attr) {
+      return element.bind('keydown keypress', function(e) {
+        if (e.which === 13) {
+          scope.$apply(attr.ngEnter);
+          return e.preventDefault();
+        }
+      });
+    };
+  });
+
+  app.directive('ngTab', function() {
+    return function(scope, element, attr) {
+      return element.bind('keydown keypress', function(e) {
+        if (e.which === 9) {
+          return scope.$apply(attr.ngTab);
+        }
+      });
+    };
+  });
+
+}).call(this);

data/app/assets/javascripts/faalis/dashboard/lib/restangular.js

@@ -0,0 +1,1066 @@
+(function() {
+
+var module = angular.module('restangular', []);
+
+module.provider('Restangular', function() {
+        // Configuration
+        var Configurer = {};
+        Configurer.init = function(object, config) {
+            /**
+             * Those are HTTP safe methods for which there is no need to pass any data with the request.
+             */
+
+            object.configuration = config;
+
+            var safeMethods= ["get", "head", "options", "trace", "getlist"];
+            config.isSafe = function(operation) {
+              return _.contains(safeMethods, operation.toLowerCase());
+            };
+
+            var absolutePattern = /^https?:\/\//i;
+            config.isAbsoluteUrl = function(string) {
+              return string && absolutePattern.test(string);
+            };
+            /**
+             * This is the BaseURL to be used with Restangular
+             */
+            config.baseUrl = _.isUndefined(config.baseUrl) ? "" : config.baseUrl;
+            object.setBaseUrl = function(newBaseUrl) {
+                config.baseUrl = /\/$/.test(newBaseUrl)
+                  ? newBaseUrl.substring(0, newBaseUrl.length-1)
+                  : newBaseUrl;
+                return this;
+            };
+
+            /**
+             * Sets the extra fields to keep from the parents
+             */
+            config.extraFields = config.extraFields || [];
+            object.setExtraFields = function(newExtraFields) {
+              config.extraFields = newExtraFields;
+              return this;
+            };
+
+            /**
+             * Some default $http parameter to be used in EVERY call
+            **/
+            config.defaultHttpFields = config.defaultHttpFields || {};
+            object.setDefaultHttpFields = function(values) {
+              config.defaultHttpFields = values;
+              return this;
+            };
+
+            config.withHttpValues = function(httpLocalConfig, obj) {
+              return _.defaults(obj, httpLocalConfig, config.defaultHttpFields);
+            };
+
+            config.encodeIds = _.isUndefined(config.encodeIds) ? true : config.encodeIds;
+            object.setEncodeIds = function(encode) {
+                config.encodeIds = encode;
+            }
+
+            config.defaultRequestParams = config.defaultRequestParams || {
+                get: {},
+                post: {},
+                put: {},
+                remove: {},
+                common: {}
+            };
+
+            object.setDefaultRequestParams = function(param1, param2) {
+              var methods = [],
+                  params = param2 || param1;
+              if (!_.isUndefined(param2)) {
+                if (_.isArray(param1)) {
+                  methods = param1;
+                } else {
+                  methods.push(param1);
+                }
+              } else {
+                methods.push('common');
+              }
+
+              _.each(methods, function (method) {
+                config.defaultRequestParams[method] = params;
+              });
+              return this;
+            }
+
+            object.requestParams = config.defaultRequestParams;
+
+
+            config.defaultHeaders = config.defaultHeaders || {};
+            object.setDefaultHeaders = function(headers) {
+              config.defaultHeaders = headers;
+              object.defaultHeaders = config.defaultHeaders;
+              return this;
+            };
+
+            object.defaultHeaders = config.defaultHeaders;
+
+            /**
+             * Method overriders will set which methods are sent via POST with an X-HTTP-Method-Override
+             **/
+            config.methodOverriders = config.methodOverriders || [];
+            object.setMethodOverriders = function(values) {
+              var overriders = _.extend([], values);
+              if (config.isOverridenMethod('delete', overriders)) {
+                overriders.push("remove");
+              }
+              config.methodOverriders = overriders;
+              return this;
+            };
+
+            config.isOverridenMethod = function(method, values) {
+              var search = values || config.methodOverriders;
+              return !_.isUndefined(_.find(search, function(one) {
+                return one.toLowerCase() === method.toLowerCase();
+              }));
+            };
+
+            /**
+             * Sets the URL creator type. For now, only Path is created. In the future we'll have queryParams
+            **/
+            config.urlCreator = config.urlCreator || "path";
+            object.setUrlCreator = function(name) {
+              if (!_.has(config.urlCreatorFactory, name)) {
+                  throw new Error("URL Path selected isn't valid");
+              }
+
+              config.urlCreator = name;
+              return this;
+            };
+
+            /**
+             * You can set the restangular fields here. The 3 required fields for Restangular are:
+             *
+             * id: Id of the element
+             * route: name of the route of this element
+             * parentResource: the reference to the parent resource
+             *
+             *  All of this fields except for id, are handled (and created) by Restangular. By default,
+             *  the field values will be id, route and parentResource respectively
+             */
+            config.restangularFields = config.restangularFields || {
+                id: "id",
+                route: "route",
+                parentResource: "parentResource",
+                restangularCollection: "restangularCollection",
+                cannonicalId: "__cannonicalId",
+                etag: "restangularEtag",
+                selfLink: "href",
+                get: "get",
+                getList: "getList",
+                put: "put",
+                post: "post",
+                remove: "remove",
+                head: "head",
+                trace: "trace",
+                options: "options",
+                patch: "patch",
+                getRestangularUrl: "getRestangularUrl",
+                putElement: "putElement",
+                addRestangularMethod: "addRestangularMethod",
+                getParentList: "getParentList",
+                clone: "clone",
+                ids: "ids",
+                httpConfig: '_$httpConfig'
+            };
+            object.setRestangularFields = function(resFields) {
+                config.restangularFields =
+                  _.extend(config.restangularFields, resFields);
+                return this;
+            };
+
+            config.setFieldToElem = function(field, elem, value) {
+              var properties = field.split('.');
+              var idValue = elem;
+              _.each(_.initial(properties), function(prop) {
+                idValue[prop] = {};
+                idValue = idValue[prop];
+              });
+              idValue[_.last(properties)] = value;
+              return this;
+            };
+
+            config.getFieldFromElem = function(field, elem) {
+              var properties = field.split('.');
+              var idValue = angular.copy(elem);
+              _.each(properties, function(prop) {
+                if (idValue) {
+                  idValue = idValue[prop];
+                }
+              });
+              return idValue;
+            };
+
+            config.setIdToElem = function(elem, id) {
+              config.setFieldToElem(config.restangularFields.id, elem, id);
+              return this;
+            };
+
+            config.getIdFromElem = function(elem) {
+              return config.getFieldFromElem(config.restangularFields.id, elem);
+            };
+
+            config.isValidId = function(elemId) {
+                return "" !== elemId && !_.isUndefined(elemId) && !_.isNull(elemId)
+            }
+
+            config.setUrlToElem = function(elem, url) {
+              config.setFieldToElem(config.restangularFields.selfLink, elem, url);
+              return this;
+            }
+
+            config.getUrlFromElem = function(elem) {
+              return config.getFieldFromElem(config.restangularFields.selfLink, elem);
+            }
+
+            config.useCannonicalId = _.isUndefined(config.useCannonicalId) ? false : config.useCannonicalId;
+            object.setUseCannonicalId = function(value) {
+                config.useCannonicalId = value;
+                return this;
+            }
+
+            config.getCannonicalIdFromElem = function(elem) {
+              var cannonicalId = elem[config.restangularFields.cannonicalId];
+              var actualId = config.isValidId(cannonicalId) ?
+                  cannonicalId : config.getIdFromElem(elem);
+              return actualId;
+            };
+
+            /**
+             * Sets the Response parser. This is used in case your response isn't directly the data.
+             * For example if you have a response like {meta: {'meta'}, data: {name: 'Gonto'}}
+             * you can extract this data which is the one that needs wrapping
+             *
+             * The ResponseExtractor is a function that receives the response and the method executed.
+             */
+
+            config.responseExtractor = config.responseExtractor || function(data, operation,
+                    what, url, response, deferred) {
+                return data;
+            };
+
+            object.setResponseExtractor = function(extractor) {
+              config.responseExtractor = extractor;
+              return this;
+            };
+
+            object.setResponseInterceptor = object.setResponseExtractor;
+
+            /**
+             * Response interceptor is called just before resolving promises.
+             */
+
+
+            /**
+             * Request interceptor is called before sending an object to the server.
+             */
+            config.fullRequestInterceptor = config.fullRequestInterceptor || function(element, operation,
+              path, url, headers, params, httpConfig) {
+                return {
+                  element: element,
+                  headers: headers,
+                  params: params,
+                  httpConfig: httpConfig
+                };
+            };
+
+            object.setRequestInterceptor = function(interceptor) {
+              config.fullRequestInterceptor = function(elem, operation, path, url, headers, params, httpConfig) {
+                return {
+                  headers: headers,
+                  params: params,
+                  element: interceptor(elem, operation, path, url),
+                  httpConfig: httpConfig
+                }
+              };
+              return this;
+            };
+
+            object.setFullRequestInterceptor = function(interceptor) {
+              config.fullRequestInterceptor = interceptor;
+              return this;
+            };
+
+            config.errorInterceptor = config.errorInterceptor || function() {};
+
+            object.setErrorInterceptor = function(interceptor) {
+              config.errorInterceptor = interceptor;
+              return this;
+            };
+
+            config.onBeforeElemRestangularized = config.onBeforeElemRestangularized || function(elem) {
+              return elem;
+            }
+            object.setOnBeforeElemRestangularized = function(post) {
+              config.onBeforeElemRestangularized = post;
+              return this;
+            };
+
+            /**
+             * This method is called after an element has been "Restangularized".
+             *
+             * It receives the element, a boolean indicating if it's an element or a collection
+             * and the name of the model
+             *
+             */
+            config.onElemRestangularized = config.onElemRestangularized || function(elem) {
+              return elem;
+            };
+            object.setOnElemRestangularized = function(post) {
+              config.onElemRestangularized = post;
+              return this;
+            };
+
+            /**
+             * Depracated. Don't use this!!
+             */
+            object.setListTypeIsArray = function(val) {
+
+            };
+
+            config.shouldSaveParent = config.shouldSaveParent || function() {
+                return true;
+            };
+            object.setParentless = function(values) {
+                if (_.isArray(values)) {
+                    config.shouldSaveParent = function(route) {
+                        return !_.contains(values, route);
+                    }
+                } else if (_.isBoolean(values)) {
+                    config.shouldSaveParent = function() {
+                        return !values;
+                    }
+                }
+                return this;
+            };
+
+            /**
+             * This lets you set a suffix to every request.
+             *
+             * For example, if your api requires that for JSon requests you do /users/123.json, you can set that
+             * in here.
+             *
+             *
+             * By default, the suffix is null
+             */
+            config.suffix = _.isUndefined(config.suffix) ? null : config.suffix;
+            object.setRequestSuffix = function(newSuffix) {
+                config.suffix = newSuffix;
+                return this;
+            };
+
+            /**
+             * Add element transformers for certain routes.
+             */
+            config.transformers = config.transformers || {};
+            object.addElementTransformer = function(type, secondArg, thirdArg) {
+                var isCollection = null;
+                var transformer = null;
+                if (arguments.length === 2) {
+                    transformer = secondArg;
+                } else {
+                    transformer = thirdArg;
+                    isCollection = secondArg;
+                }
+
+                var typeTransformers = config.transformers[type];
+                if (!typeTransformers) {
+                    typeTransformers = config.transformers[type] = [];
+                }
+
+                typeTransformers.push(function(coll, elem) {
+                    if (_.isNull(isCollection) || (coll == isCollection)) {
+                        return transformer(elem);
+                    }
+                    return elem;
+                });
+            };
+
+            object.extendCollection = function(route, fn) {
+              return object.addElementTransformer(route, true, fn);
+            };
+
+            object.extendModel = function(route, fn) {
+              return object.addElementTransformer(route, false, fn);
+            };
+
+            config.transformElem = function(elem, isCollection, route, Restangular) {
+                var typeTransformers = config.transformers[route];
+                var changedElem = elem;
+                if (typeTransformers) {
+                    _.each(typeTransformers, function(transformer) {
+                       changedElem = transformer(isCollection, changedElem);
+                    });
+                }
+                return config.onElemRestangularized(changedElem,
+                  isCollection, route, Restangular);
+            };
+
+            config.fullResponse = _.isUndefined(config.fullResponse) ? false : config.fullResponse;
+            object.setFullResponse = function(full) {
+                config.fullResponse = full;
+                return this;
+            };
+
+
+
+            //Internal values and functions
+            config.urlCreatorFactory = {};
+
+            /**
+             * Base URL Creator. Base prototype for everything related to it
+             **/
+
+             var BaseCreator = function() {
+             };
+
+             BaseCreator.prototype.setConfig = function(config) {
+                 this.config = config;
+                 return this;
+             };
+
+             BaseCreator.prototype.parentsArray = function(current) {
+                var parents = [];
+                while(current) {
+                    parents.push(current);
+                    current = current[this.config.restangularFields.parentResource];
+                }
+                return parents.reverse();
+            };
+
+            function RestangularResource(config, $http, url, configurer) {
+              var resource = {};
+              _.each(_.keys(configurer), function(key) {
+                  var value = configurer[key];
+
+                  // Add default parameters
+                  value.params = _.extend({}, value.params,
+                          config.defaultRequestParams[value.method.toLowerCase()]);
+                  // We don't want the ? if no params are there
+                  if (_.isEmpty(value.params)) {
+                    delete value.params;
+                  }
+
+                  if (config.isSafe(value.method)) {
+
+                      resource[key] = function() {
+                          return $http(_.extend(value, {
+                              url: url
+                          }));
+                      }
+
+                  } else {
+
+                      resource[key] = function(data) {
+                          return $http(_.extend(value, {
+                              url: url,
+                              data: data
+                          }));
+                      }
+
+                  }
+              });
+
+              return resource;
+            }
+
+            BaseCreator.prototype.resource = function(current, $http, localHttpConfig, callHeaders, callParams, what, etag, operation) {
+
+                var params = _.defaults(callParams || {}, this.config.defaultRequestParams.common);
+                var headers = _.defaults(callHeaders || {}, this.config.defaultHeaders);
+
+                if (etag) {
+                    if (!config.isSafe(operation)) {
+                      headers['If-Match'] = etag;
+                    } else {
+                      headers['If-None-Match'] = etag;
+                    }
+                }
+
+                var url = this.base(current);
+
+                if (what) {
+                  var add = '';
+                  if (!/\/$/.test(url)) {
+                    add += '/';
+                  }
+                  add += what;
+                  url += add;
+                }
+
+                if (this.config.suffix
+                  && url.indexOf(this.config.suffix, url.length - this.config.suffix.length) === -1) {
+
+                    url += this.config.suffix;
+                }
+
+                current[this.config.restangularFields.httpConfig] = undefined;
+
+
+                return RestangularResource(this.config, $http, url, {
+                    getList: this.config.withHttpValues(localHttpConfig,
+                      {method: 'GET',
+                      params: params,
+                      headers: headers}),
+
+                    get: this.config.withHttpValues(localHttpConfig,
+                      {method: 'GET',
+                      params: params,
+                      headers: headers}),
+
+                    put: this.config.withHttpValues(localHttpConfig,
+                      {method: 'PUT',
+                      params: params,
+                      headers: headers}),
+
+                    post: this.config.withHttpValues(localHttpConfig,
+                      {method: 'POST',
+                      params: params,
+                      headers: headers}),
+
+                    remove: this.config.withHttpValues(localHttpConfig,
+                      {method: 'DELETE',
+                      params: params,
+                      headers: headers}),
+
+                    head: this.config.withHttpValues(localHttpConfig,
+                      {method: 'HEAD',
+                      params: params,
+                      headers: headers}),
+
+                    trace: this.config.withHttpValues(localHttpConfig,
+                      {method: 'TRACE',
+                      params: params,
+                      headers: headers}),
+
+                    options: this.config.withHttpValues(localHttpConfig,
+                      {method: 'OPTIONS',
+                      params: params,
+                      headers: headers}),
+
+                    patch: this.config.withHttpValues(localHttpConfig,
+                      {method: 'PATCH',
+                      params: params,
+                      headers: headers})
+                });
+            };
+
+            /**
+             * This is the Path URL creator. It uses Path to show Hierarchy in the Rest API.
+             * This means that if you have an Account that then has a set of Buildings, a URL to a building
+             * would be /accounts/123/buildings/456
+            **/
+            var Path = function() {
+            };
+
+            Path.prototype = new BaseCreator();
+
+            Path.prototype.base = function(current) {
+                var __this = this;
+                return  _.reduce(this.parentsArray(current), function(acum, elem) {
+                    var elemUrl;
+                    var elemSelfLink = __this.config.getUrlFromElem(elem);
+                    if (elemSelfLink) {
+                      if (__this.config.isAbsoluteUrl(elemSelfLink)) {
+                        return elemSelfLink;
+                      } else {
+                        elemUrl = elemSelfLink;
+                      }
+                    } else {
+                      elemUrl = elem[__this.config.restangularFields.route];
+
+                      if (elem[__this.config.restangularFields.restangularCollection]) {
+                        var ids = elem[__this.config.restangularFields.ids];
+                        if (ids) {
+                          elemUrl += "/" + ids.join(",");
+                        }
+                      } else {
+                          var elemId;
+                          if (__this.config.useCannonicalId) {
+                              elemId = __this.config.getCannonicalIdFromElem(elem);
+                          } else {
+                              elemId = __this.config.getIdFromElem(elem);
+                          }
+
+                          if (config.isValidId(elemId)) {
+                              elemUrl += "/" + (__this.config.encodeIds ? encodeURIComponent(elemId) : elemId);
+                          }
+                      }
+                    }
+
+                    return acum + "/" + elemUrl;
+
+                }, this.config.baseUrl);
+            };
+
+
+
+            Path.prototype.fetchUrl = function(current, what) {
+                var baseUrl = this.base(current);
+                if (what) {
+                    baseUrl += "/" + what;
+                }
+                return baseUrl;
+            };
+
+
+
+            config.urlCreatorFactory.path = Path;
+
+        }
+
+        var globalConfiguration = {};
+
+        Configurer.init(this, globalConfiguration);
+
+
+
+
+       this.$get = ['$http', '$q', function($http, $q) {
+
+          function createServiceForConfiguration(config) {
+              var service = {};
+
+              var urlHandler = new config.urlCreatorFactory[config.urlCreator]();
+              urlHandler.setConfig(config);
+
+              function restangularizeBase(parent, elem, route) {
+                  elem[config.restangularFields.route] = route;
+                  elem[config.restangularFields.getRestangularUrl] = _.bind(urlHandler.fetchUrl, urlHandler, elem);
+                  elem[config.restangularFields.addRestangularMethod] = _.bind(addRestangularMethodFunction, elem);
+                  elem[config.restangularFields.clone] = _.bind(copyRestangularizedElement, elem, elem);
+                  elem.withHttpConfig = _.bind(withHttpConfig, elem);
+
+                  // RequestLess connection
+                  elem.one = _.bind(one, elem, elem);
+                  elem.all = _.bind(all, elem, elem);
+                  elem.several = _.bind(several, elem, elem);
+                  elem.oneUrl = _.bind(oneUrl, elem, elem);
+                  elem.allUrl = _.bind(allUrl, elem, elem);
+
+                  if (parent && config.shouldSaveParent(route)) {
+                      var parentId = config.getIdFromElem(parent);
+                      var parentUrl = config.getUrlFromElem(parent);
+
+                      var restangularFieldsForParent = _.union(
+                        _.values( _.pick(config.restangularFields, ['route', 'parentResource']) ),
+                        config.extraFields
+                      );
+                      var parentResource = _.pick(parent, restangularFieldsForParent);
+
+                      if (config.isValidId(parentId)) {
+                          config.setIdToElem(parentResource, parentId);
+                      }
+                      if (config.isValidId(parentUrl)) {
+                          config.setUrlToElem(parentResource, parentUrl);
+                      }
+
+                      elem[config.restangularFields.parentResource] = parentResource;
+                  } else {
+                    elem[config.restangularFields.parentResource] = null;
+                  }
+                  return elem;
+              }
+
+
+
+              function one(parent, route, id) {
+                  var elem = {};
+                  config.setIdToElem(elem, id);
+                  return restangularizeElem(parent, elem , route);
+              }
+
+
+              function all(parent, route) {
+                  return restangularizeCollection(parent, [] , route, true);
+              }
+
+              function several(parent, route, ids) {
+                var collection = [];
+                collection[config.restangularFields.ids] =
+                  Array.prototype.splice.call(arguments, 2);
+                return restangularizeCollection(parent, collection , route, true);
+              }
+
+              function oneUrl(parent, route, url) {
+                  var elem = {};
+                  config.setUrlToElem(elem, url);
+                  return restangularizeElem(parent, elem , route);
+              }
+
+
+              function allUrl(parent, route, url) {
+                  var elem = {};
+                  config.setUrlToElem(elem, url);
+                  return restangularizeCollection(parent, elem , route, true);
+              }
+              // Promises
+              function restangularizePromise(promise, isCollection) {
+                  promise.call = _.bind(promiseCall, promise);
+                  promise.get = _.bind(promiseGet, promise);
+                  promise[config.restangularFields.restangularCollection] = isCollection;
+                  if (isCollection) {
+                      promise.push = _.bind(promiseCall, promise, "push");
+                  }
+                  return promise;
+              }
+
+              function promiseCall(method) {
+                  var deferred = $q.defer();
+                  var callArgs = arguments;
+                  this.then(function(val) {
+                      var params = Array.prototype.slice.call(callArgs, 1);
+                      var func = val[method];
+                      func.apply(val, params);
+                      deferred.resolve(val);
+                  });
+                  return restangularizePromise(deferred.promise, this[config.restangularFields.restangularCollection]);
+              }
+
+              function promiseGet(what) {
+                  var deferred = $q.defer();
+                  this.then(function(val) {
+                      deferred.resolve(val[what]);
+                  });
+                  return restangularizePromise(deferred.promise, this[config.restangularFields.restangularCollection]);
+              }
+
+              function resolvePromise(deferred, response, data) {
+
+                // Trigger the full response interceptor.
+                if (config.fullResponse) {
+                  return deferred.resolve(_.extend(response, {
+                    data: data
+                  }));
+                } else {
+                  deferred.resolve(data);
+                }
+              }
+
+
+              // Elements
+
+              function stripRestangular(elem) {
+                return _.omit(elem, _.values(_.omit(config.restangularFields, 'id')));
+              }
+
+              function addCustomOperation(elem) {
+                  elem.customOperation = _.bind(customFunction, elem);
+                  _.each(["put", "post", "get", "delete"], function(oper) {
+                      _.each(["do", "custom"], function(alias) {
+                          var callOperation = oper === 'delete' ? 'remove' : oper;
+                          var name = alias + oper.toUpperCase();
+                          var callFunction;
+
+                          if (callOperation !== 'put' && callOperation !== 'post') {
+                              callFunction = customFunction;
+                          } else {
+                              callFunction = function(operation, elem, path, params, headers) {
+                                return _.bind(customFunction, this)(operation, path, params, headers, elem);
+                              }
+                          }
+                          elem[name] = _.bind(callFunction, elem, callOperation);
+                      });
+                  });
+                  elem.customGETLIST = _.bind(fetchFunction, elem);
+                  elem.doGETLIST = elem.customGETLIST;
+              }
+
+              function copyRestangularizedElement(fromElement) {
+                  var copiedElement = angular.copy(fromElement);
+                  return restangularizeElem(copiedElement[config.restangularFields.parentResource],
+                          copiedElement, copiedElement[config.restangularFields.route]);
+              }
+
+              function restangularizeElem(parent, element, route, collection) {
+                  var elem = config.onBeforeElemRestangularized(element, false, route);
+
+                  var localElem = restangularizeBase(parent, elem, route);
+
+                  if (config.useCannonicalId) {
+                      localElem[config.restangularFields.cannonicalId] = config.getIdFromElem(localElem)
+                  }
+
+                  if (collection) {
+                      localElem[config.restangularFields.getParentList] = function() {
+                          return collection;
+                      }
+                  }
+
+
+                  localElem[config.restangularFields.restangularCollection] = false;
+                  localElem[config.restangularFields.get] = _.bind(getFunction, localElem);
+                  localElem[config.restangularFields.getList] = _.bind(fetchFunction, localElem);
+                  localElem[config.restangularFields.put] = _.bind(putFunction, localElem);
+                  localElem[config.restangularFields.post] = _.bind(postFunction, localElem);
+                  localElem[config.restangularFields.remove] = _.bind(deleteFunction, localElem);
+                  localElem[config.restangularFields.head] = _.bind(headFunction, localElem);
+                  localElem[config.restangularFields.trace] = _.bind(traceFunction, localElem);
+                  localElem[config.restangularFields.options] = _.bind(optionsFunction, localElem);
+                  localElem[config.restangularFields.patch] = _.bind(patchFunction, localElem);
+
+                  addCustomOperation(localElem);
+                  return config.transformElem(localElem, false, route, service);
+              }
+
+              function restangularizeCollection(parent, element, route) {
+                  var elem = config.onBeforeElemRestangularized(element, true, route);
+
+                  var localElem = restangularizeBase(parent, elem, route);
+                  localElem[config.restangularFields.restangularCollection] = true;
+                  localElem[config.restangularFields.post] = _.bind(postFunction, localElem, null);
+                  localElem[config.restangularFields.head] = _.bind(headFunction, localElem);
+                  localElem[config.restangularFields.trace] = _.bind(traceFunction, localElem);
+                  localElem[config.restangularFields.putElement] = _.bind(putElementFunction, localElem);
+                  localElem[config.restangularFields.options] = _.bind(optionsFunction, localElem);
+                  localElem[config.restangularFields.patch] = _.bind(patchFunction, localElem);
+                  localElem[config.restangularFields.get] = _.bind(getById, localElem);
+                  localElem[config.restangularFields.getList] = _.bind(fetchFunction, localElem, null);
+
+                  addCustomOperation(localElem);
+                  return config.transformElem(localElem, true, route, service);
+              }
+
+              function getById(id, reqParams, headers){
+                  return this.customGET(id.toString(), reqParams, headers);
+              }
+
+              function putElementFunction(idx, params, headers) {
+                  var __this = this;
+                  var elemToPut = this[idx];
+                  var deferred = $q.defer();
+                  elemToPut.put(params, headers).then(function(serverElem) {
+                      var newArray = copyRestangularizedElement(__this);
+                      newArray[idx] = serverElem;
+                      deferred.resolve(newArray);
+                  }, function(response) {
+                      deferred.reject(response);
+                  });
+
+                  return restangularizePromise(deferred.promise, true)
+              }
+
+              function parseResponse(resData, operation, route, fetchUrl, response, deferred) {
+                  var data = config.responseExtractor(resData, operation, route, fetchUrl, response, deferred);
+                  var etag = response.headers("ETag");
+                  if (data && etag) {
+                      data[config.restangularFields.etag] = etag;
+                  }
+                  return data;
+              }
+
+
+              function fetchFunction(what, reqParams, headers) {
+                  var __this = this;
+                  var deferred = $q.defer();
+                  var operation = 'getList';
+                  var url = urlHandler.fetchUrl(this, what);
+                  var whatFetched = what || __this[config.restangularFields.route];
+
+
+                  var request = config.fullRequestInterceptor(null, operation,
+                      whatFetched, url, headers || {}, reqParams || {}, this[config.restangularFields.httpConfig] || {});
+
+                  urlHandler.resource(this, $http, request.httpConfig, request.headers, request.params, what,
+                          this[config.restangularFields.etag], operation).getList().then(function(response) {
+                      var resData = response.data;
+                      var data = parseResponse(resData, operation, whatFetched, url, response, deferred);
+                      var processedData = _.map(data, function(elem) {
+                          if (!__this[config.restangularFields.restangularCollection]) {
+                              return restangularizeElem(__this, elem, what, data);
+                          } else {
+                              return restangularizeElem(__this[config.restangularFields.parentResource],
+                                elem, __this[config.restangularFields.route], data);
+                          }
+
+                      });
+
+                      processedData = _.extend(data, processedData);
+                      if (!__this[config.restangularFields.restangularCollection]) {
+                          resolvePromise(deferred, response, restangularizeCollection(__this, processedData, what));
+                      } else {
+                          resolvePromise(deferred, response, restangularizeCollection(__this[config.restangularFields.parentResource], processedData, __this[config.restangularFields.route]));
+                      }
+                  }, function error(response) {
+                      if ( config.errorInterceptor(response) !== false ) {
+                          deferred.reject(response);
+                      }
+                  });
+
+                  return restangularizePromise(deferred.promise, true);
+              }
+
+              function withHttpConfig(httpConfig) {
+                 this[config.restangularFields.httpConfig] = httpConfig;
+                 return this;
+              }
+
+              function elemFunction(operation, what, params, obj, headers) {
+                  var __this = this;
+                  var deferred = $q.defer();
+                  var resParams = params || {};
+                  var route = what || this[config.restangularFields.route];
+                  var fetchUrl = urlHandler.fetchUrl(this, what);
+
+                  var callObj = obj || this;
+                  var etag = callObj[config.restangularFields.etag];
+                  if (_.isObject(callObj)) {
+                      callObj = stripRestangular(callObj);
+                  }
+                  var request = config.fullRequestInterceptor(callObj, operation, route, fetchUrl,
+                    headers || {}, resParams || {}, this[config.restangularFields.httpConfig] || {});
+
+                  var okCallback = function(response) {
+                      var resData = response.data;
+                      var elem = parseResponse(resData, operation, route, fetchUrl, response, deferred);
+                      if (elem) {
+
+                        if (operation === "post" && !__this[config.restangularFields.restangularCollection]) {
+                          resolvePromise(deferred, response, restangularizeElem(__this, elem, what));
+                        } else {
+                          resolvePromise(deferred, response, restangularizeElem(__this[config.restangularFields.parentResource], elem, __this[config.restangularFields.route]));
+                        }
+
+                      } else {
+                        resolvePromise(deferred, response, undefined);
+                      }
+                  };
+
+                  var errorCallback = function(response) {
+                      if ( config.errorInterceptor(response) !== false ) {
+                          deferred.reject(response);
+                      }
+                  };
+                  // Overring HTTP Method
+                  var callOperation = operation;
+                  var callHeaders = _.extend({}, request.headers);
+                  var isOverrideOperation = config.isOverridenMethod(operation);
+                  if (isOverrideOperation) {
+                    callOperation = 'post';
+                    callHeaders = _.extend(callHeaders, {'X-HTTP-Method-Override': operation === 'remove' ? 'DELETE' : operation});
+                  }
+
+                  if (config.isSafe(operation)) {
+                    if (isOverrideOperation) {
+                      urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params,
+                        what, etag, callOperation)[callOperation]({}).then(okCallback, errorCallback);
+                    } else {
+                      urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params,
+                        what, etag, callOperation)[callOperation]().then(okCallback, errorCallback);
+                    }
+                  } else {
+                      urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params,
+                        what, etag, callOperation)[callOperation](request.element).then(okCallback, errorCallback);
+                  }
+
+                  return restangularizePromise(deferred.promise);
+              }
+
+              function getFunction(params, headers) {
+                  return _.bind(elemFunction, this)("get", undefined, params, undefined, headers);
+              }
+
+              function deleteFunction(params, headers) {
+                  return _.bind(elemFunction, this)("remove", undefined, params, undefined, headers);
+              }
+
+              function putFunction(params, headers) {
+                  return _.bind(elemFunction, this)("put", undefined, params, undefined, headers);
+              }
+
+              function postFunction(what, elem, params, headers) {
+                  return _.bind(elemFunction, this)("post", what, params, elem, headers);
+              }
+
+             function headFunction(params, headers) {
+               return _.bind(elemFunction, this)("head", undefined, params, undefined, headers);
+             }
+
+             function traceFunction(params, headers) {
+               return _.bind(elemFunction, this)("trace", undefined, params, undefined, headers);
+             }
+
+             function optionsFunction(params, headers) {
+               return _.bind(elemFunction, this)("options", undefined, params, undefined, headers);
+             }
+
+             function patchFunction(elem, params, headers) {
+               return _.bind(elemFunction, this)("patch", undefined, params, elem, headers);
+             }
+
+             function customFunction(operation, path, params, headers, elem) {
+                 return _.bind(elemFunction, this)(operation, path, params, elem, headers);
+             }
+
+             function addRestangularMethodFunction(name, operation, path, defaultParams, defaultHeaders, defaultElem) {
+                 var bindedFunction;
+                 if (operation === 'getList') {
+                     bindedFunction = _.bind(fetchFunction, this, path);
+                 } else {
+                     bindedFunction = _.bind(customFunction, this, operation, path);
+                 }
+
+                 var createdFunction = function(params, headers, elem) {
+                     var callParams = _.defaults({
+                         params: params,
+                         headers: headers,
+                         elem: elem
+                     }, {
+                         params: defaultParams,
+                         headers: defaultHeaders,
+                         elem: defaultElem
+                     });
+                     return bindedFunction(callParams.params, callParams.headers, callParams.elem);
+                 };
+
+                 if (config.isSafe(operation)) {
+                     this[name] = createdFunction;
+                 } else {
+                     this[name] = function(elem, params, headers) {
+                         return createdFunction(params, headers, elem);
+                     }
+                 }
+
+             }
+
+             function withConfigurationFunction(configurer) {
+                 var newConfig = angular.copy(globalConfiguration);
+                 Configurer.init(newConfig, newConfig);
+                 configurer(newConfig);
+                 return createServiceForConfiguration(newConfig);
+             }
+
+
+              Configurer.init(service, config);
+
+              service.copy = _.bind(copyRestangularizedElement, service);
+
+              service.withConfig = _.bind(withConfigurationFunction, service);
+
+              service.one = _.bind(one, service, null);
+
+              service.all = _.bind(all, service, null);
+
+              service.several = _.bind(several, service, null);
+
+              service.oneUrl = _.bind(oneUrl, service, null);
+
+              service.allUrl = _.bind(allUrl, service, null);
+
+              service.restangularizeElement = _.bind(restangularizeElem, service);
+
+              service.restangularizeCollection = _.bind(restangularizeCollection, service);
+
+              return service;
+          }
+
+          return createServiceForConfiguration(globalConfiguration);
+
+        }];
+    }
+);
+
+})();