callpixelsjs-rails 0.0.8 → 0.0.9

data/src/callpixels/base/request.js

@@ -0,0 +1,215 @@
+(function () {
+    // Dependencies
+    var Base = window.Callpixels.Base;
+    var Cookies = window.Callpixels.Base.Cookies;
+    /**
+     * @constructor
+     * @memberof Callpixels.Base
+     * @param {String}  options.http_prefix - The http type (http || https).
+     * @param {String}  options.addr - The api hostname.
+     * @param {String}  options.urlregex - The url regex validator.
+     */
+    var Request = function (options) {
+
+        function initialize(options) {
+            // assert required keys and assign if valid
+            config = Base.assert_required_keys(options, 'http_prefix', 'addr', 'urlregex');
+        }
+
+        // INIT
+        var self = this;
+        var config = {};
+
+        /**
+         * Request data from the host
+         * @memberOf Callpixels.Base.Request
+         * @function getJSON
+         * @instance
+         * @param {String} request_url - The request uri
+         * @param {Object} payload - Post object
+         * @param {*} [callbacks] - Array or Function to be called after request
+         * @param {*} [context] - Context applied to callback
+         * @returns {Object} json
+         */
+        self.getJSON = function (request_url, payload, callbacks, context) {
+            // ensure callbacks are an array
+            if (typeof(callbacks) == "function") callbacks = [callbacks];
+            if (typeof(context) === 'undefined') context = self;
+            // request
+            var request = function () {
+                self.apiRequest(request_url, function (data) {
+                    // parse
+                    response = JSON.parse(data);
+                    // fire callbacks
+                    for (var i in callbacks) {
+                        if (typeof callbacks[i] == "function") callbacks[i].apply(context, [response]);
+                    }
+                }, payload)
+            };
+            if (Base.ieVersion() == 6 || Base.ieVersion() == 7) {
+                with_ie_scripts(request);
+            } else {
+                request();
+            }
+        };
+
+        // This is an alias for now to show intent
+        self.postJSON = function () {
+            return self.getJSON.apply(this, arguments);
+        };
+
+        /**
+         * Request data from the host
+         * @memberOf Callpixels.Base.Request
+         * @function apiRequest
+         * @instance
+         * @param {String} request_url - The request uri
+         * @param {Array} callbackFunctions - Array of callback functions
+         * @param {Object} payload - Post object
+         * @returns {String} string
+         */
+        self.apiRequest = function (request_uri, callbackFunctions, payload) {
+            // configure
+            var http_prefix = config['http_prefix'];
+            var addr = config['addr'];
+            var urlregex = eval(config['urlregex']);
+            var request_url = http_prefix + '://' + addr + request_uri;
+            // configure
+
+            if (payload && typeof(Cookies.get('CallPixels-vid')) !== 'undefined' && Cookies.get('CallPixels-vid') !== 'null') {
+                payload['visitor_id'] = Cookies.get('CallPixels-vid');
+            }
+
+            if (typeof(callbackFunctions) == "function") {
+                callbackFunctions = [callbackFunctions];
+            }
+
+            function ignored() {
+            }
+
+            function runCallbacks(response) {
+                for (var i in callbackFunctions) {
+                    if (typeof callbackFunctions[i] == "function") callbackFunctions[i](response);
+                }
+            }
+
+            function forwardResponse() {
+                runCallbacks(xdr.responseText);
+            }
+
+            function sendXdm() {
+                // create the rpc request
+                var remote = http_prefix + '://' + addr + '/ie_provider';
+                var swf = http_prefix + '://' + addr + "/easyxdm.swf";
+                var rpc = eval('new window.easyXDM.Rpc({ remote: "' + remote + '", swf: "' + swf + '"},{remote: {request: {}}});');
+
+                rpc['request']({
+                    url: ('/' + request_url.match(urlregex)[1]),
+                    method: "POST",
+                    data: payload
+                }, function (response) {
+                    runCallbacks(response.data);
+                });
+            }
+
+            if (window.XDomainRequest) {
+                // IE >= 8
+                // 1. Create XDR object
+                var xdr = new XDomainRequest();
+
+                xdr.onload = forwardResponse; //alertLoaded;
+                xdr.onprogress = ignored;
+                xdr.onerror = ignored;
+                xdr.ontimeout = ignored;
+                xdr.timeout = 30000;
+
+                // 2. Open connection with server using GET method
+                if (payload) {
+                    xdr.open("post", request_url);
+                    xdr.send(self.buildPost(payload));
+                } else {
+                    xdr.open("get", request_url);
+                    xdr.send();
+                }
+
+                // 3. Send string data to server
+
+            } else if (Base.ieVersion() == 6 || Base.ieVersion() == 7) {
+                with_ie_scripts(sendXdm);
+            } else {
+                var request = new XMLHttpRequest;
+
+                if (payload) {
+                    request.open("POST", request_url, false);
+                    request.setRequestHeader("Content-Type", "application/json");
+                    request.send(JSON.stringify(payload));
+                } else {
+                    request.open("GET", request_url, false);
+                    request.send();
+                }
+
+                runCallbacks(request.responseText);
+            }
+        };
+
+        function with_ie_scripts(callback) {
+            if (Callpixels['easyxdm_loaded']) {
+                callback();
+            } else {
+                self.loadScript(http_prefix + '://cdn.jsdelivr.net/easyxdm/2.4.17.1/easyXDM.min.js', function () {
+                    self.loadScript(http_prefix + '://cdn.jsdelivr.net/easyxdm/2.4.17.1/json2.js', function () {
+                        Callpixels['easyxdm_loaded'] = true;
+                        callback();
+                    });
+                });
+            }
+        };
+
+        self.buildPost = function (obj) {
+            var post_vars = '';
+            for (var k in obj) {
+                post_vars += k + "=" + obj[k] + '&';
+            }
+            return post_vars;
+        };
+
+        self.loadScript = function (scriptUrl, afterCallback) {
+            var firstScriptElement = document.getElementsByTagName('script')[0];
+            var scriptElement = document.createElement('script');
+            scriptElement.type = 'text/javascript';
+            scriptElement.async = false;
+            scriptElement.src = scriptUrl;
+
+            var ieLoadBugFix = function (scriptElement, callback) {
+                if (scriptElement.readyState == 'loaded' || scriptElement.readyState == 'complete') {
+                    callback();
+                } else {
+                    setTimeout(function () {
+                        ieLoadBugFix(scriptElement, callback);
+                    }, 100);
+                }
+            };
+
+            if (typeof afterCallback === "function") {
+                if (typeof scriptElement.addEventListener !== "undefined") {
+                    scriptElement.addEventListener("load", afterCallback, false)
+                } else {
+                    scriptElement.onreadystatechange = function () {
+                        scriptElement.onreadystatechange = null;
+                        ieLoadBugFix(scriptElement, afterCallback);
+                    }
+                }
+            }
+            firstScriptElement.parentNode.insertBefore(scriptElement, firstScriptElement);
+        };
+        initialize(options);
+        self.config = config;
+    };
+    Request.connection = function () {
+        if (typeof window.Callpixels._connection === 'undefined') {
+            window.Callpixels._connection = new Callpixels.Base.Request({addr: 'callpixels.com', http_prefix: 'http', urlregex: "/\\/\\/[^\\/]*\\/(.*)/" });
+        }
+        return window.Callpixels._connection;
+    };
+    Callpixels.Base.Request = Request;
+})();

data/src/callpixels/base/request_number.js

@@ -0,0 +1,193 @@
+(function () {
+    // Dependencies
+    var Base = Callpixels.Base;
+    var Cookies = Callpixels.Base.Cookies;
+    var Base64 = Callpixels.Base.Base64;
+    var Request = Callpixels.Base.Request;
+    /**
+     * @constructor
+     * @memberof Callpixels.Base
+     * @param {Object}  options
+     * @param {String}  options.campaign_key - The campaign uuid.
+     * @param {Object}  options.tags - The tags to search for.
+     * @param {String}  [options.default_number_replacement]
+     * @param {String}  [options.message_replacement]
+     * @param {Array}   [options.target_map]
+     * @param {Array}   [options.target_map_cs]
+     * @param {String}  [options.timer_offset]
+     * @param {String}  [options.timer_offset_cs]
+     */
+    var RequestNumber = function (options) {
+
+        function initialize(options) {
+            // assert required keys and assign if valid
+            config = Base.assert_required_keys(options, 'campaign_key');
+        }
+
+        // INIT
+        var self = this;
+        var config = {};
+        var resource_url = '/api/v1/numbers?';
+
+        /**
+         * Request the number
+         * @memberOf Callpixels.Base.RequestNumber
+         * @function perform
+         * @instance
+         * @param {Function} callback - Callback to fire after request
+         */
+        self.perform = function (callback) {
+            if (typeof callback !== 'function') {
+                throw "ArgumentError: Expected to receive a callback function"
+            }
+            var request_url = resource_url + '&campaign_key=' + config['campaign_key'];
+
+            // append configs to url if provided
+            if (config['default_number_replacement']) {
+                request_url = request_url + "&default_number=" + config['default_number_replacement'];
+            }
+            if (config['message_replacement']) {
+                request_url = request_url + "&message=" + config['message_replacement'];
+            }
+
+            var body = new Object();
+
+            var uri = document.location.href;
+
+            body['u'] = Base64.encode(uri);
+            body['st'] = Base64.encode(tags_to_script_tags(config.number_matching_tags));
+
+            var ou = Cookies.get('CallPixels-ou');
+            if (getParts([document.location.href])['cpreset'] || !ou) {
+                Cookies.set('CallPixels-ou', body['u']);
+            } else {
+                body['ou'] = ou;
+            }
+
+            function sendGARequest(ga_acct, ga_cookies) {
+                body['ga'] = Base64.encode(ga_acct);
+                body['c'] = Base64.encode(JSON.stringify(ga_cookies));
+                Request.connection().getJSON(request_url, body, callback);
+            }
+
+
+            var ga_acct = 'FAILED';
+
+            try {
+                _gaq.push(function () {
+                    ga_acct = eval('_gat._getTrackerByName()._getAccount()');
+
+                    sendGARequest(ga_acct, getGACookies());
+                });
+
+            } catch (e) {
+
+                try {
+                    ga(function (tracker) {
+                        var clientId = tracker.get('clientId');
+                        var allTrackers = eval('ga.getAll()');
+                        ga_acct = allTrackers[0].get('trackingId');
+
+                        var ga_cookies = {};
+                        ga_cookies['__utma'] = clientId;
+                        ga_cookies['mp'] = 'yes';
+                        sendGARequest(ga_acct, ga_cookies);
+                    });
+
+                } catch (f) {
+                    // Post back with failed ga_acct.
+                    Request.connection().getJSON(request_url, body, callback);
+                }
+            }
+
+        };
+
+        function getParts(urls) {
+            var all_parts = {};
+            for (var i = 0; i < urls.length; i++) {
+                var url_parts = getUrlParts(urls[i]);
+                for (var attrname in url_parts) {
+                    all_parts[attrname] = url_parts[attrname];
+                }
+            }
+            return all_parts;
+        }
+
+        function getUrlParts(url) {
+            // url contains your data.
+            var objURL = new Object();
+            try {
+                //REGEX_1: /\?(.*)/
+                url = url.match(eval("/\\?(.*)/"))[0];
+            } catch (e) {
+                return objURL;
+                //Ignored
+            }
+
+            // Use the String::replace method to iterate over each
+            // name-value pair in the query string. Location.search
+            // gives us the query string (if it exists).
+            url.replace(
+                new RegExp("([^?=&]+)(=([^&]*))?", "g"),
+
+                // For each matched query string pair, add that
+                // pair to the URL struct using the pre-equals
+                // value as the key.
+                function ($0, $1, $2, $3) {
+                    objURL[ $1.toLowerCase() ] = $3;
+                }
+            );
+
+            return objURL;
+        }
+
+        function getGACookies() {
+            var ga_cookies = ['__utma', '__utmb', '__utmc', '__utmz', '__utmv'];
+            var cookies = new Object();
+            for (var i in ga_cookies) {
+                var cookie_val = extractCookie(ga_cookies[i]);
+
+                if (cookie_val || i > 0) {
+                    if (cookie_val) cookies[ga_cookies[i]] = cookie_val;
+                } else {
+                    break;
+                }
+            }
+            return cookies;
+        }
+
+        function extractCookie(name) {
+            var regex = new RegExp(name + '=([^;]*)', 'g');
+            try {
+                return regex.exec(document.cookie)[1];
+            } catch (e) {
+                return false;
+            }
+        }
+
+        function findOne(all_parts, var_arr) {
+            for (var look_for in var_arr) {
+                for (var attrname in all_parts) {
+                    if (attrname == var_arr[look_for]) {
+                        return all_parts[attrname];
+                    }
+                }
+            }
+            return false
+        }
+
+        initialize(options);
+    };
+
+    function tags_to_script_tags(tags) {
+        var script_tags = '';
+        for (var key in tags) {
+            var value = tags[key];
+            script_tags = script_tags + '&' + key + '=' + value
+        }
+        return script_tags;
+    }
+
+    Callpixels.Base.RequestNumber = RequestNumber;
+})();
+

data/src/callpixels/cache.js

@@ -0,0 +1 @@
+window.Callpixels.Cache = {};

data/src/callpixels/campaign.js

@@ -0,0 +1,98 @@
+(function () {
+    // Dependencies
+    var RequestNumber = Callpixels.Base.RequestNumber;
+    /**
+     * @constructor
+     * @memberOf Callpixels
+     * @param {Object} options
+     * @param {String} options.campaign_key - Campaign key
+     * @example
+     * var campaign = new Callpixels.Campaign({ campaign_key: '67d9fb1917ae8f4eaff36831b41788c3' });
+     */
+    var Campaign = function (options) {
+
+        function initialize(data) {
+            // initialize data store
+            self.store(data);
+        }
+
+        var self = this;
+        self.type = 'campaigns';
+        self.primary_key('campaign_key');
+        self.numbers = [];
+
+        /**
+         * Fetch a campaign number.
+         * @memberOf Callpixels.Campaign
+         * @function request_number
+         * @instance
+         * @param {Object} tags - A collection of tags as key-value pairs. The number returned will match these tags.
+         * @param {getNumberCallback} callback - Callback fired if the request completes successfully.
+         * @param {Function} error_callback - Callback fired if the request raises an error.
+         * @example
+         * campaign.request_number({calling_about: 'support'}, function (number) {
+         *   alert(number.get('number'))
+         * }, function(response){
+         *   alert('something went wrong: ' + response);
+         * };
+         */
+        self.request_number = function (tags, callback, error_callback) {
+            // assign the tags (this is important since it runs it through set_number_matching_tags)
+            self.set('number_matching_tags', tags);
+            // request the number
+            new RequestNumber(self.get('campaign_key', 'number_matching_tags')).perform(function (data) {
+                // did callpixels return a valid number?
+                if (typeof(data) !== 'undefined' && typeof(data.number) !== 'undefined' && data.number !== '') {
+                    // initialize number
+                    var number = new Callpixels.Number(data.number);
+                    // call callback
+                    callback.apply(self, [number]);
+                }
+                // otherwise fire the error callback
+                else if (typeof(error_callback) === 'function') {
+                    error_callback.apply(self, [data]);
+                }
+            });
+        };
+        /**
+         * Callpixels.Campaign#request_number callback fired after the request completes.
+         * @callback getNumberCallback
+         * @param {Callpixels.Number} - The number that was returned
+         */
+
+        self.numbers = function () {
+            var output = [];
+            if (typeof(Callpixels.Base.Data._store) !== 'undefined') {
+                // get numbers
+                var numbers = Callpixels.Base.Data._store['numbers'];
+                // present?
+                if (typeof(numbers) !== 'undefined') {
+                    // collect numbers matching this campaign
+                    for (var primary_key in numbers) {
+                        var number = numbers[primary_key];
+                        if (self.get('campaign_key') == number.campaign_key) {
+                            output.push(new Callpixels.Number(number));
+                        }
+                    }
+                }
+            }
+            return output;
+        };
+
+        self.set_number_matching_tags = function (tags) {
+            if (typeof(tags) === 'string') {
+                tags = Callpixels.Number.extract_tags_from_string(tags);
+            }
+            if (tags && (typeof tags === "object") && !(tags instanceof Array)) {
+                return tags
+            }
+            else {
+                throw "ArgumentError: Expected number_matching_tags to be an object. eg: {tag: 'value'}";
+            }
+        };
+
+        initialize(options);
+    };
+    Campaign.prototype = new Callpixels.Base.Model();
+    Callpixels.Campaign = Campaign;
+})();