callpixelsjs-rails 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f6287796f175818600067aa9594990e32aeae7e
-  data.tar.gz: ab56843df5e9f583836c244b70535d56f1053eb5
+  metadata.gz: c6a41733ab787f91ab95a3855af0b2e5544acaf6
+  data.tar.gz: 21a4460eeab8a0f36c9a18665e1c4efdb468601b
 SHA512:
-  metadata.gz: 58ae9e3ff3ea6fdab9f85240e307b2d5e327a52fdce62f6e080c65cf022ee0d898c7be6f499e018c98aa319762d6255e7d51f0177686197b2c9d277f480d8963
-  data.tar.gz: 23d84cb95ad22db604a4bfa24864a2748cdd3265a7ca05f3ee7c13070db8afefcc8128530e0534f5dcb896f50645e21e26f5d961d26f5e2303c80602186f566f
+  metadata.gz: 53756d5317a7b60b72d0b235e81d2dbc6da46a0c668b7fbf6ffb48322b65600cf8726dbe61b2e32998518aef4e97b53864bf385e1668194bf1724853e5bb2da3
+  data.tar.gz: 32683275156731330c843f267b49342af2edb88c653feaf9f9dc47b2a7935b7868031310aeb770ed1f1e87208af1fb70afe1b632ee293d168a373bef1e10eff6

data/lib/callpixelsjs/rails/version.rb

@@ -1,5 +1,5 @@
 module Callpixelsjs
   module Rails
-    VERSION = "0.0.8"
+    VERSION = "0.0.9"
   end
 end

data/src/callpixels/base/base64.js

@@ -0,0 +1,126 @@
+// http://www.webtoolkit.info/javascript-base64.html#.U-qwzYBdUwQ
+(function () {
+    var Base64 = {
+        _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+    };
+    // public method for encoding
+    Base64.encode = function (input) {
+        var output = "";
+        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+        var i = 0;
+
+        input = Base64._utf8_encode(input);
+
+        while (i < input.length) {
+
+            chr1 = input.charCodeAt(i++);
+            chr2 = input.charCodeAt(i++);
+            chr3 = input.charCodeAt(i++);
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) {
+                enc3 = enc4 = 64;
+            } else if (isNaN(chr3)) {
+                enc4 = 64;
+            }
+            output = output +
+                Base64._keyStr.charAt(enc1) + Base64._keyStr.charAt(enc2) +
+                Base64._keyStr.charAt(enc3) + Base64._keyStr.charAt(enc4);
+
+        }
+        return output;
+    };
+    Base64.decode = function (input) {
+        var output = "";
+        var chr1, chr2, chr3;
+        var enc1, enc2, enc3, enc4;
+        var i = 0;
+
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+        while (i < input.length) {
+
+            enc1 = Base64._keyStr.indexOf(input.charAt(i++));
+            enc2 = Base64._keyStr.indexOf(input.charAt(i++));
+            enc3 = Base64._keyStr.indexOf(input.charAt(i++));
+            enc4 = Base64._keyStr.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            output = output + String.fromCharCode(chr1);
+
+            if (enc3 != 64) {
+                output = output + String.fromCharCode(chr2);
+            }
+            if (enc4 != 64) {
+                output = output + String.fromCharCode(chr3);
+            }
+
+        }
+
+        output = Base64._utf8_decode(output);
+
+        return output;
+    };
+    Base64._utf8_encode = function (string) {
+        //REGEX_2: /\r\n/g NEWLINE: "\n"
+        string = string.replace(eval("/\\r\\n/g"),eval("String('\\n')"));
+        var utftext = "";
+
+        for (var n = 0; n < string.length; n++) {
+
+            var c = string.charCodeAt(n);
+
+            if (c < 128) {
+                utftext += String.fromCharCode(c);
+            }
+            else if ((c > 127) && (c < 2048)) {
+                utftext += String.fromCharCode((c >> 6) | 192);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+            else {
+                utftext += String.fromCharCode((c >> 12) | 224);
+                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+
+        }
+
+        return utftext;
+    };
+    Base64._utf8_decode = function (utftext) {
+        var string = "";
+        var i = 0;
+        var c = c1 = c2 = 0;
+
+        while (i < utftext.length) {
+
+            c = utftext.charCodeAt(i);
+
+            if (c < 128) {
+                string += String.fromCharCode(c);
+                i++;
+            }
+            else if ((c > 191) && (c < 224)) {
+                c2 = utftext.charCodeAt(i + 1);
+                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+                i += 2;
+            }
+            else {
+                c2 = utftext.charCodeAt(i + 1);
+                c3 = utftext.charCodeAt(i + 2);
+                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+                i += 3;
+            }
+
+        }
+        return string;
+    };
+    Callpixels.Base.Base64 = Base64;
+})();

data/src/callpixels/base/cookies.js

@@ -0,0 +1,59 @@
+// https://github.com/evertton/cookiejs
+(function (f) {
+    var a = function (b, c, d) {
+        return 1 === arguments.length ? a.get(b) : a.set(b, c, d)
+    };
+    a._document = document;
+    a._navigator = navigator;
+    a.defaults = {path: "/"};
+    a.get = function (b) {
+        a._cachedDocumentCookie !== a._document.cookie && a._renewCache();
+        return a._cache[b]
+    };
+    a.set = function (b, c, d) {
+        d = a._getExtendedOptions(d);
+        a._document.cookie = a._generateCookieString(b, c, d);
+        return a
+    };
+    a._getExtendedOptions = function (b) {
+        return{path: b && b.path || a.defaults.path, domain: b && b.domain || a.defaults.domain, secure: b && b.secure !== f ? b.secure :
+            a.defaults.secure}
+    };
+    a._isValidDate = function (a) {
+        return"[object Date]" === Object.prototype.toString.call(a) && !isNaN(a.getTime())
+    };
+    a._generateCookieString = function (a, c, d) {
+        a = encodeURIComponent(a);
+        c = (c + "").replace(/[^!#$&-+\--:<-\[\]-~]/g, encodeURIComponent);
+        d = d || {};
+        a = a + "=" + c + (d.path ? ";path=" + d.path : "");
+        a += d.domain ? ";domain=" + d.domain : "";
+        return a += d.secure ? ";secure" : ""
+    };
+    a._getCookieObjectFromString = function (b) {
+        var c = {};
+        b = b ? b.split("; ") : [];
+        for (var d = 0; d < b.length; d++) {
+            var e = a._getKeyValuePairFromCookieString(b[d]);
+            c[e.key] === f && (c[e.key] = e.value)
+        }
+        return c
+    };
+    a._getKeyValuePairFromCookieString = function (a) {
+        var c = a.indexOf("="), c = 0 > c ? a.length : c;
+        return{key: decodeURIComponent(a.substr(0, c)), value: decodeURIComponent(a.substr(c + 1))}
+    };
+    a._renewCache = function () {
+        a._cache = a._getCookieObjectFromString(a._document.cookie);
+        a._cachedDocumentCookie = a._document.cookie
+    };
+    a._areEnabled = function () {
+        return a._navigator.cookieEnabled || "1" === a.set("cookies.js", 1).get("cookies.js")
+    };
+    a.enabled = a._areEnabled();
+    "function" === typeof define &&
+    define.amd ? define(function () {
+        return a
+    }) : "undefined" !== typeof exports ? ("undefined" !== typeof module && module.exports && (exports = module.exports = a), exports.Cookies = a) : a;
+    Callpixels.Base.Cookies = a;
+})();

data/src/callpixels/base/data.js

@@ -0,0 +1,81 @@
+(function () {
+    // Dependencies
+    var Base = Callpixels.Base;
+    /**
+     * @constructor
+     * @memberof Callpixels.Base
+     * @param {Object}  config - Configuration hash
+     * @param {String}  config.type - The data type
+     * @param {Numeric}  config.primary_key - The primary_key
+     */
+    var Data = function (config) {
+
+        function initialize() {
+            Base.assert_required_keys(config, 'type', 'primary_key');
+            if (typeof Callpixels.Base.Data._store[config.type] === 'undefined') {
+                Callpixels.Base.Data._store[config.type] = {};
+            }
+            if (typeof Callpixels.Base.Data._store[config.type][config.primary_key] === 'undefined') {
+                Callpixels.Base.Data._store[config.type][config.primary_key] = {};
+            }
+        }
+
+        var self = this;
+
+        /**
+         * Request data from the host
+         * @memberOf Callpixels.Base.Data
+         * @function get
+         * @instance
+         * @param {String} key - The key to retrieve
+         * @returns {*}
+         */
+        self.get = function () {
+            var output = {};
+            if (typeof arguments[0] === 'undefined') {
+                output = Callpixels.Base.Data._store[config.type][config.primary_key];
+            } else if (arguments.length === 1) {
+                output = Callpixels.Base.Data._store[config.type][config.primary_key][arguments[0]];
+            } else {
+                for (var i = 0; i < arguments.length; i++) {
+                    var key = arguments[i];
+                    output[key] = Callpixels.Base.Data._store[config.type][config.primary_key][key];
+                }
+            }
+            return output;
+        };
+
+        /**
+         * Request data from the host
+         * @memberOf Callpixels.Base.Data
+         * @function set
+         * @instance
+         * @param {String} key - The key to retrieve
+         * @param {String} value - The value to assign
+         * @returns {*}
+         */
+        self.set = function (key, value) {
+            Callpixels.Base.Data._store[config.type][config.primary_key][key] = value;
+            return value;
+        };
+
+        /**
+         * Merge data
+         * @memberOf Callpixels.Base.Data
+         * @function set
+         * @instance
+         * @param {String} object - The object to merge
+         * @returns {*}
+         */
+        self.merge = function (object) {
+            for (var key in object) {
+                Callpixels.Base.Data._store[config.type][config.primary_key][key] = object[key];
+            }
+            return object;
+        };
+
+        initialize();
+    };
+    Data._store = {};
+    Callpixels.Base.Data = Data;
+})();

data/src/callpixels/base/helpers.js

@@ -0,0 +1,55 @@
+(function () {
+    // ensure namespace is present
+    if (typeof window.Callpixels === 'undefined') window.Callpixels = {};
+    var Base = {};
+    // define helpers
+    Base.assert_required_keys = function () {
+        var args = Array.prototype.slice.call(arguments);
+        var object = args.shift();
+        for (var i = 0; i < args.length; i++) {
+            var key = args[i];
+            if (typeof object === 'undefined' || typeof object[key] === 'undefined') {
+                throw  "ArgumentError: Required keys are not defined: " + args.join(', ');
+            }
+        }
+        return object;
+    };
+    Base.merge = function (obj1, obj2) {
+        for (var p in obj2) {
+            try {
+                if (obj2[p].constructor == Object) {
+                    obj1[p] = Base.merge(obj1[p], obj2[p]);
+                } else {
+                    obj1[p] = obj2[p];
+                }
+            } catch (e) {
+                obj1[p] = obj2[p];
+            }
+        }
+        return obj1;
+    };
+    Base.isArray = function (arg) {
+        return Object.prototype.toString.call(arg) === '[object Array]';
+    };
+    Base.ieVersion = function () {
+        if (Base._ieVersion == null) {
+            Base._ieVersion = (function () {
+                var v = 3,
+                    div = document.createElement('div'),
+                    all = div.getElementsByTagName('i');
+
+                while (
+                    div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
+                        all[0]
+                    ) {
+                }
+                return v > 4 ? v : false;
+            }());
+        }
+        if (Base._ieVersion == 6 || Base._ieVersion == 7) {
+            if (Callpixels['easyxdm_loaded'] == null) Callpixels['easyxdm_loaded'] = false;
+        }
+        return Base._ieVersion;
+    };
+    Callpixels.Base = Base;
+})();

data/src/callpixels/base/model.js

@@ -0,0 +1,113 @@
+(function () {
+    // Dependencies
+    var Base = Callpixels.Base;
+    var Data = Callpixels.Base.Data;
+
+    /**
+     * @constructor
+     * @memberof Callpixels.Base
+     */
+    var Model = function () {
+
+        this.api_host_uri = '/api/v1/';
+        this.type = 'model';
+
+        this.primary_key = function (primary_key) {
+            return Model.primary_key(this.type, primary_key);
+        };
+
+        this.store = function (data) {
+            // do we have data to store?
+            if (typeof(data) !== 'undefined') {
+                // does the data contain the required primary_key?
+                var key = this.primary_key();
+                if (typeof(data[key]) === 'undefined') {
+                    throw("ArgumentError: Expected to receive primary_key " + key);
+                }
+                // has a store been initialized?
+                else if (typeof(this._store) === 'undefined') {
+                    this._store = new Callpixels.Base.Data({type: this.type, primary_key: data[key] });
+                }
+                // merge the data
+                this._store.merge(data);
+                // update visitor is token present
+                Model.update_visitor_id(data);
+            }
+            return this._store;
+        };
+
+        this.get_data = function (path, callback) {
+            return this.connection().getJSON(this.api_host_uri + path, null, [Model.update, callback], this);
+        };
+
+        this.post_data = function (path, data, callback) {
+            return this.connection().postJSON(this.api_host_uri + path, data, [Model.update, callback], this);
+        };
+
+        this.set = function () {
+            if (typeof(this["set_" + arguments[0]]) === 'function') {
+                arguments[1] = this["set_" + arguments[0]].apply(this, [arguments[1]]);
+            }
+            return this._store.set.apply(this, arguments);
+        };
+        this.get = function () {
+            return this._store.get.apply(this, arguments);
+        };
+        this.connection = function () {
+            return Callpixels.Base.Request.connection();
+        };
+    };
+    Model.inflections = {
+        'number': 'numbers',
+        'campaign': 'campaigns'
+    };
+    Model.update = function (data) {
+        for (var key in data) {
+            var type = key;
+            var value = data[key];
+            if (typeof Model.inflections[key] !== 'undefined') {
+                type = Model.inflections[key];
+            }
+            if (typeof Data._store[type] !== 'undefined') {
+                if (Base.isArray(value)) {
+                    for (var i = 0; i < value.length; i++) {
+                        Model.update_record(type, value[i]);
+                    }
+                } else {
+                    Model.update_record(type, value[i]);
+                }
+            }
+        }
+        return data;
+    };
+    Model.update_record = function (type, record) {
+        // update visitor is token present
+        Model.update_visitor_id(record);
+        // update data store
+        if (typeof record.id !== 'undefined') {
+            var primary_key = Model.primary_key(type);
+            for (var key in record) {
+                Callpixels.Base.Data._store[type][record[primary_key]][key] = record[key];
+            }
+            return true
+        } else {
+            return false
+        }
+        return record;
+    };
+    Model.update_visitor_id = function (record) {
+        if (typeof(record) !== 'undefined' && typeof(record.visitor_id) !== 'undefined') {
+            Callpixels.Base.Cookies.set('CallPixels-vid', record.visitor_id);
+        }
+    };
+    Model.primary_key = function (type, primary_key) {
+        if (typeof(Model.primary_keys) === 'undefined') Model.primary_keys = {};
+        // default key
+        if (typeof(Model.primary_keys[type]) === 'undefined') Model.primary_keys[type] = 'id';
+        // assign key if passed
+        if (typeof(primary_key) !== 'undefined') Model.primary_keys[type] = primary_key;
+        // return value
+        return Model.primary_keys[type];
+    }
+    Callpixels.Base.Model = Model;
+})();