diff --git a/local/media/images/module/logo-2.png b/local/media/images/module/logo-2.png new file mode 100644 index 00000000..1fe1879f Binary files /dev/null and b/local/media/images/module/logo-2.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/.source-stamp b/web/assets/backOffice/default/PayPal/assets/.source-stamp new file mode 100644 index 00000000..e12bcbcb --- /dev/null +++ b/web/assets/backOffice/default/PayPal/assets/.source-stamp @@ -0,0 +1 @@ +77a4c77393db8bfa78a3c48da30a8f93 \ No newline at end of file diff --git a/web/assets/backOffice/default/PayPal/assets/1fb2500.png b/web/assets/backOffice/default/PayPal/assets/1fb2500.png new file mode 100644 index 00000000..e39588ed Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/1fb2500.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/71dbb05.png b/web/assets/backOffice/default/PayPal/assets/71dbb05.png new file mode 100644 index 00000000..e7546deb Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/71dbb05.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/a15af4a.png b/web/assets/backOffice/default/PayPal/assets/a15af4a.png new file mode 100644 index 00000000..7904991f Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/a15af4a.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/e522c4d.png b/web/assets/backOffice/default/PayPal/assets/e522c4d.png new file mode 100644 index 00000000..47dad7a1 Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/e522c4d.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_agreement.jpeg b/web/assets/backOffice/default/PayPal/assets/paypal_agreement.jpeg new file mode 100644 index 00000000..eaa3af22 Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_agreement.jpeg differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_conf1.png b/web/assets/backOffice/default/PayPal/assets/paypal_conf1.png new file mode 100644 index 00000000..7904991f Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_conf1.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_conf2.png b/web/assets/backOffice/default/PayPal/assets/paypal_conf2.png new file mode 100644 index 00000000..47dad7a1 Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_conf2.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_conf3.png b/web/assets/backOffice/default/PayPal/assets/paypal_conf3.png new file mode 100644 index 00000000..e7546deb Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_conf3.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_live_button.png b/web/assets/backOffice/default/PayPal/assets/paypal_live_button.png new file mode 100644 index 00000000..e39588ed Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_live_button.png differ diff --git a/web/assets/backOffice/default/PayPal/assets/paypal_webhook.png b/web/assets/backOffice/default/PayPal/assets/paypal_webhook.png new file mode 100644 index 00000000..419d33c7 Binary files /dev/null and b/web/assets/backOffice/default/PayPal/assets/paypal_webhook.png differ diff --git a/web/assets/backOffice/default/template-assets/assets/js/4f20017.js b/web/assets/backOffice/default/template-assets/assets/js/4f20017.js new file mode 100644 index 00000000..3e68289a --- /dev/null +++ b/web/assets/backOffice/default/template-assets/assets/js/4f20017.js @@ -0,0 +1,1758 @@ +;(function(){ + + /** + * Require the given path. + * + * @param {String} path + * @return {Object} exports + * @api public + */ + + function require(path, parent, orig) { + var resolved = require.resolve(path); + + // lookup failed + if (null == resolved) { + orig = orig || path; + parent = parent || 'root'; + var err = new Error('Failed to require "' + orig + '" from "' + parent + '"'); + err.path = orig; + err.parent = parent; + err.require = true; + throw err; + } + + var module = require.modules[resolved]; + + // perform real require() + // by invoking the module's + // registered function + if (!module.exports) { + module.exports = {}; + module.client = module.component = true; + module.call(this, module.exports, require.relative(resolved), module); + } + + return module.exports; + } + + /** + * Registered modules. + */ + + require.modules = {}; + + /** + * Registered aliases. + */ + + require.aliases = {}; + + /** + * Resolve `path`. + * + * Lookup: + * + * - PATH/index.js + * - PATH.js + * - PATH + * + * @param {String} path + * @return {String} path or null + * @api private + */ + + require.resolve = function(path) { + if (path.charAt(0) === '/') path = path.slice(1); + + var paths = [ + path, + path + '.js', + path + '.json', + path + '/index.js', + path + '/index.json' + ]; + + for (var i = 0; i < paths.length; i++) { + var path = paths[i]; + if (require.modules.hasOwnProperty(path)) return path; + if (require.aliases.hasOwnProperty(path)) return require.aliases[path]; + } + }; + + /** + * Normalize `path` relative to the current path. + * + * @param {String} curr + * @param {String} path + * @return {String} + * @api private + */ + + require.normalize = function(curr, path) { + var segs = []; + + if ('.' != path.charAt(0)) return path; + + curr = curr.split('/'); + path = path.split('/'); + + for (var i = 0; i < path.length; ++i) { + if ('..' == path[i]) { + curr.pop(); + } else if ('.' != path[i] && '' != path[i]) { + segs.push(path[i]); + } + } + + return curr.concat(segs).join('/'); + }; + + /** + * Register module at `path` with callback `definition`. + * + * @param {String} path + * @param {Function} definition + * @api private + */ + + require.register = function(path, definition) { + require.modules[path] = definition; + }; + + /** + * Alias a module definition. + * + * @param {String} from + * @param {String} to + * @api private + */ + + require.alias = function(from, to) { + if (!require.modules.hasOwnProperty(from)) { + throw new Error('Failed to alias "' + from + '", it does not exist'); + } + require.aliases[to] = from; + }; + + /** + * Return a require function relative to the `parent` path. + * + * @param {String} parent + * @return {Function} + * @api private + */ + + require.relative = function(parent) { + var p = require.normalize(parent, '..'); + + /** + * lastIndexOf helper. + */ + + function lastIndexOf(arr, obj) { + var i = arr.length; + while (i--) { + if (arr[i] === obj) return i; + } + return -1; + } + + /** + * The relative require() itself. + */ + + function localRequire(path) { + var resolved = localRequire.resolve(path); + return require(resolved, parent, path); + } + + /** + * Resolve relative to the parent. + */ + + localRequire.resolve = function(path) { + var c = path.charAt(0); + if ('/' == c) return path.slice(1); + if ('.' == c) return require.normalize(p, path); + + // resolve deps by returning + // the dep in the nearest "deps" + // directory + var segs = parent.split('/'); + var i = lastIndexOf(segs, 'deps') + 1; + if (!i) i = 0; + path = segs.slice(0, i + 1).join('/') + '/deps/' + path; + return path; + }; + + /** + * Check if module is defined at `path`. + */ + + localRequire.exists = function(path) { + return require.modules.hasOwnProperty(localRequire.resolve(path)); + }; + + return localRequire; + }; + require.register("component-emitter/index.js", function(exports, require, module){ + + /** + * Expose `Emitter`. + */ + + module.exports = Emitter; + + /** + * Initialize a new `Emitter`. + * + * @api public + */ + + function Emitter(obj) { + if (obj) return mixin(obj); + }; + + /** + * Mixin the emitter properties. + * + * @param {Object} obj + * @return {Object} + * @api private + */ + + function mixin(obj) { + for (var key in Emitter.prototype) { + obj[key] = Emitter.prototype[key]; + } + return obj; + } + + /** + * Listen on the given `event` with `fn`. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + + Emitter.prototype.on = function(event, fn){ + this._callbacks = this._callbacks || {}; + (this._callbacks[event] = this._callbacks[event] || []) + .push(fn); + return this; + }; + + /** + * Adds an `event` listener that will be invoked a single + * time then automatically removed. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + + Emitter.prototype.once = function(event, fn){ + var self = this; + this._callbacks = this._callbacks || {}; + + function on() { + self.off(event, on); + fn.apply(this, arguments); + } + + fn._off = on; + this.on(event, on); + return this; + }; + + /** + * Remove the given callback for `event` or all + * registered callbacks. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + + Emitter.prototype.off = + Emitter.prototype.removeListener = + Emitter.prototype.removeAllListeners = function(event, fn){ + this._callbacks = this._callbacks || {}; + var callbacks = this._callbacks[event]; + if (!callbacks) return this; + + // remove all handlers + if (1 == arguments.length) { + delete this._callbacks[event]; + return this; + } + + // remove specific handler + var i = callbacks.indexOf(fn._off || fn); + if (~i) callbacks.splice(i, 1); + return this; + }; + + /** + * Emit `event` with the given args. + * + * @param {String} event + * @param {Mixed} ... + * @return {Emitter} + */ + + Emitter.prototype.emit = function(event){ + this._callbacks = this._callbacks || {}; + var args = [].slice.call(arguments, 1) + , callbacks = this._callbacks[event]; + + if (callbacks) { + callbacks = callbacks.slice(0); + for (var i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, args); + } + } + + return this; + }; + + /** + * Return array of callbacks for `event`. + * + * @param {String} event + * @return {Array} + * @api public + */ + + Emitter.prototype.listeners = function(event){ + this._callbacks = this._callbacks || {}; + return this._callbacks[event] || []; + }; + + /** + * Check if this emitter has `event` handlers. + * + * @param {String} event + * @return {Boolean} + * @api public + */ + + Emitter.prototype.hasListeners = function(event){ + return !! this.listeners(event).length; + }; + + }); + require.register("dropzone/index.js", function(exports, require, module){ + + + /** + * Exposing dropzone + */ + module.exports = require("./lib/dropzone.js"); + + }); + require.register("dropzone/lib/dropzone.js", function(exports, require, module){ + /* + # + # More info at [www.dropzonejs.com](http://www.dropzonejs.com) + # + # Copyright (c) 2012, Matias Meno + # + # Permission is hereby granted, free of charge, to any person obtaining a copy + # of this software and associated documentation files (the "Software"), to deal + # in the Software without restriction, including without limitation the rights + # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + # copies of the Software, and to permit persons to whom the Software is + # furnished to do so, subject to the following conditions: + # + # The above copyright notice and this permission notice shall be included in + # all copies or substantial portions of the Software. + # + # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + # THE SOFTWARE. + # + */ + + + (function() { + var Dropzone, Em, camelize, contentLoaded, noop, without, + __hasProp = {}.hasOwnProperty, + __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + __slice = [].slice; + + Em = typeof Emitter !== "undefined" && Emitter !== null ? Emitter : require("emitter"); + + noop = function() {}; + + Dropzone = (function(_super) { + var extend; + + __extends(Dropzone, _super); + + /* + This is a list of all available events you can register on a dropzone object. + + You can register an event handler like this: + + dropzone.on("dragEnter", function() { }); + */ + + + Dropzone.prototype.events = ["drop", "dragstart", "dragend", "dragenter", "dragover", "dragleave", "selectedfiles", "addedfile", "removedfile", "thumbnail", "error", "errormultiple", "processing", "processingmultiple", "uploadprogress", "totaluploadprogress", "sending", "sendingmultiple", "success", "successmultiple", "canceled", "canceledmultiple", "complete", "completemultiple", "reset", "maxfilesexceeded"]; + + Dropzone.prototype.defaultOptions = { + url: null, + method: "post", + withCredentials: false, + parallelUploads: 2, + uploadMultiple: false, + maxFilesize: 256, + paramName: "file", + createImageThumbnails: true, + maxThumbnailFilesize: 10, + thumbnailWidth: 100, + thumbnailHeight: 100, + maxFiles: null, + params: {}, + clickable: true, + ignoreHiddenFiles: true, + acceptedFiles: null, + acceptedMimeTypes: null, + autoProcessQueue: true, + addRemoveLinks: false, + previewsContainer: null, + dictDefaultMessage: "Drop files here to upload", + dictFallbackMessage: "Your browser does not support drag'n'drop file uploads.", + dictFallbackText: "Please use the fallback form below to upload your files like in the olden days.", + dictFileTooBig: "File is too big ({{filesize}}MB). Max filesize: {{maxFilesize}}MB.", + dictInvalidFileType: "You can't upload files of this type.", + dictResponseError: "Server responded with {{statusCode}} code.", + dictCancelUpload: "Cancel upload", + dictCancelUploadConfirmation: "Are you sure you want to cancel this upload?", + dictRemoveFile: "Remove file", + dictRemoveFileConfirmation: null, + dictMaxFilesExceeded: "You can only upload {{maxFiles}} files.", + accept: function(file, done) { + return done(); + }, + init: function() { + return noop; + }, + forceFallback: false, + fallback: function() { + var child, messageElement, span, _i, _len, _ref; + this.element.className = "" + this.element.className + " dz-browser-not-supported"; + _ref = this.element.getElementsByTagName("div"); + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + child = _ref[_i]; + if (/(^| )dz-message($| )/.test(child.className)) { + messageElement = child; + child.className = "dz-message"; + continue; + } + } + if (!messageElement) { + messageElement = Dropzone.createElement("
"); + this.element.appendChild(messageElement); + } + span = messageElement.getElementsByTagName("span")[0]; + if (span) { + span.textContent = this.options.dictFallbackMessage; + } + return this.element.appendChild(this.getFallbackForm()); + }, + resize: function(file) { + var info, srcRatio, trgRatio; + info = { + srcX: 0, + srcY: 0, + srcWidth: file.width, + srcHeight: file.height + }; + srcRatio = file.width / file.height; + trgRatio = this.options.thumbnailWidth / this.options.thumbnailHeight; + if (file.height < this.options.thumbnailHeight || file.width < this.options.thumbnailWidth) { + info.trgHeight = info.srcHeight; + info.trgWidth = info.srcWidth; + } else { + if (srcRatio > trgRatio) { + info.srcHeight = file.height; + info.srcWidth = info.srcHeight * trgRatio; + } else { + info.srcWidth = file.width; + info.srcHeight = info.srcWidth / trgRatio; + } + } + info.srcX = (file.width - info.srcWidth) / 2; + info.srcY = (file.height - info.srcHeight) / 2; + return info; + }, + /* + Those functions register themselves to the events on init and handle all + the user interface specific stuff. Overwriting them won't break the upload + but can break the way it's displayed. + You can overwrite them if you don't like the default behavior. If you just + want to add an additional event handler, register it on the dropzone object + and don't overwrite those options. + */ + + drop: function(e) { + return this.element.classList.remove("dz-drag-hover"); + }, + dragstart: noop, + dragend: function(e) { + return this.element.classList.remove("dz-drag-hover"); + }, + dragenter: function(e) { + return this.element.classList.add("dz-drag-hover"); + }, + dragover: function(e) { + return this.element.classList.add("dz-drag-hover"); + }, + dragleave: function(e) { + return this.element.classList.remove("dz-drag-hover"); + }, + selectedfiles: function(files) { + if (this.element === this.previewsContainer) { + return this.element.classList.add("dz-started"); + } + }, + reset: function() { + return this.element.classList.remove("dz-started"); + }, + addedfile: function(file) { + var _this = this; + file.previewElement = Dropzone.createElement(this.options.previewTemplate); + file.previewTemplate = file.previewElement; + this.previewsContainer.appendChild(file.previewElement); + file.previewElement.querySelector("[data-dz-name]").textContent = file.name; + file.previewElement.querySelector("[data-dz-size]").innerHTML = this.filesize(file.size); + if (this.options.addRemoveLinks) { + file._removeLink = Dropzone.createElement("" + this.options.dictRemoveFile + ""); + file._removeLink.addEventListener("click", function(e) { + e.preventDefault(); + e.stopPropagation(); + if (file.status === Dropzone.UPLOADING) { + return Dropzone.confirm(_this.options.dictCancelUploadConfirmation, function() { + return _this.removeFile(file); + }); + } else { + if (_this.options.dictRemoveFileConfirmation) { + return Dropzone.confirm(_this.options.dictRemoveFileConfirmation, function() { + return _this.removeFile(file); + }); + } else { + return _this.removeFile(file); + } + } + }); + file.previewElement.appendChild(file._removeLink); + } + return this._updateMaxFilesReachedClass(); + }, + removedfile: function(file) { + var _ref; + if ((_ref = file.previewElement) != null) { + _ref.parentNode.removeChild(file.previewElement); + } + return this._updateMaxFilesReachedClass(); + }, + thumbnail: function(file, dataUrl) { + var thumbnailElement; + file.previewElement.classList.remove("dz-file-preview"); + file.previewElement.classList.add("dz-image-preview"); + thumbnailElement = file.previewElement.querySelector("[data-dz-thumbnail]"); + thumbnailElement.alt = file.name; + return thumbnailElement.src = dataUrl; + }, + error: function(file, message) { + file.previewElement.classList.add("dz-error"); + return file.previewElement.querySelector("[data-dz-errormessage]").textContent = message; + }, + errormultiple: noop, + processing: function(file) { + file.previewElement.classList.add("dz-processing"); + if (file._removeLink) { + return file._removeLink.textContent = this.options.dictCancelUpload; + } + }, + processingmultiple: noop, + uploadprogress: function(file, progress, bytesSent) { + return file.previewElement.querySelector("[data-dz-uploadprogress]").style.width = "" + progress + "%"; + }, + totaluploadprogress: noop, + sending: noop, + sendingmultiple: noop, + success: function(file) { + return file.previewElement.classList.add("dz-success"); + }, + successmultiple: noop, + canceled: function(file) { + return this.emit("error", file, "Upload canceled."); + }, + canceledmultiple: noop, + complete: function(file) { + if (file._removeLink) { + return file._removeLink.textContent = this.options.dictRemoveFile; + } + }, + completemultiple: noop, + maxfilesexceeded: noop, + previewTemplate: "" + this.options.dictFallbackText + "
"; + } + fieldsString += "