Stackedit/public/res/helpers/googleHelper.js

/*global gapi, google */
define([
    "underscore",
    "jquery",
    "constants",
    "core",
    "utils",
    "storage",
    "logger",
    "settings",
    "eventMgr",
    "classes/AsyncTask",
], function(_, $, constants, core, utils, storage, logger, settings, eventMgr, AsyncTask) {

    var connected = false;
    var authorizationMgrMap = {};
    function AuthorizationMgr(accountId) {
        var permissionList = {
            profile: true
        };
        var refreshFlag = true;
        _.each((storage[accountId + '.permissions'] || '').split(';'), function(permission) {
            permission && (permissionList[permission] = true);
        });
        this.setRefreshFlag = function() {
            refreshFlag = true;
        };
        this.isAuthorized = function(permission) {
            return refreshFlag === false && _.has(permissionList, permission);
        };
        this.add = function(permission) {
            permissionList[permission] = true;
            storage[accountId + '.permissions'] = _.keys(permissionList).join(';');
            refreshFlag = false;
        };
        this.getListWithNew = function(permission) {
            var result = _.keys(permissionList);
            if(!_.has(permissionList, permission)) {
                result.push(permission);
            }
            return result;
        };
        var userId = storage[accountId + '.userId'];
        this.setUserId = function(value) {
            userId = value;
            storage[accountId + '.userId'] = userId;
        };
        this.getUserId = function() {
            return userId;
        };
    }

    var googleHelper = {};

    // Listen to offline status changes
    var isOffline = false;
    eventMgr.addListener("onOfflineChanged", function(isOfflineParam) {
        isOffline = isOfflineParam;
    });

    // Try to connect by downloading client.js
    function connect(task) {
        task.onRun(function() {
            if(isOffline === true) {
                connected = false;
                task.error(new Error("Operation not available in offline mode.|stopPublish"));
                return;
            }
            if(connected === true) {
                task.chain();
                return;
            }
            window.delayedFunction = function() {
                gapi.load("client,drive-realtime", function() {
                    connected = true;
                    task.chain();
                });
            };
            $.ajax({
                url: "https://apis.google.com/js/api.js?onload=runDelayedFunction",
                dataType: "script",
                timeout: constants.AJAX_TIMEOUT
            }).fail(function(jqXHR) {
                var error = {
                    code: jqXHR.status,
                    message: jqXHR.statusText
                };
                handleError(error, task);
            });
        });
    }

    // Try to authenticate with Oauth
    var scopeMap = {
        profile: [
            'https://www.googleapis.com/auth/userinfo.profile'
        ],
        gdrive: [
            'https://www.googleapis.com/auth/drive.install',
            settings.gdriveFullAccess === true ? 'https://www.googleapis.com/auth/drive' : 'https://www.googleapis.com/auth/drive.file'
        ],
        blogger: [
            'https://www.googleapis.com/auth/blogger'
        ],
        picasa: [
            'https://picasaweb.google.com/data/'
        ]
    };
    function authenticate(task, permission, accountId) {
        var authorizationMgr = authorizationMgrMap[accountId];
        if(!authorizationMgr) {
            authorizationMgr = new AuthorizationMgr(accountId);
            authorizationMgrMap[accountId] = authorizationMgr;
        }
        task.onRun(function() {
            function loadGdriveClient() {
                if(gapi.client.drive) {
                    task.chain();
                    return;
                }
                gapi.client.load('drive', 'v2', function() {
                    task.chain();
                });
            }
            function getTokenInfo() {
                $.ajax({
                    url: 'https://www.googleapis.com/oauth2/v1/tokeninfo',
                    data: {
                        access_token: gapi.auth.getToken().access_token
                    },
                    timeout: constants.AJAX_TIMEOUT,
                    type: "GET"
                }).done(function(data) {
                    if(authorizationMgr.getUserId() && authorizationMgr.getUserId() != data.user_id) {
                        // Wrong user id, try again
                        startAuthenticate();
                    }
                    else {
                        authorizationMgr.setUserId(data.user_id);
                        authorizationMgr.add(permission);
                        authorizationMgr.token = gapi.auth.getToken();
                        task.chain(loadGdriveClient);
                    }
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    handleError(error, task);
                });
            }
            var authuser = 0;
            var immediate;
            function localAuthenticate() {
                if(authuser > 5) {
                    authuser = 0;
                    immediate = false;
                    eventMgr.onError('Unable to authenticate user ' + authorizationMgr.getUserId() + ', please use login form.');
                }
                if(immediate === false) {
                    task.timeout = constants.ASYNC_TASK_LONG_TIMEOUT;
                }
                var scopeList = _.chain(scopeMap).pick(authorizationMgr.getListWithNew(permission)).flatten().value();
                gapi.auth.authorize({
                    client_id: constants.GOOGLE_CLIENT_ID,
                    scope: scopeList,
                    immediate: immediate,
                    authuser: immediate === false ? '' : authuser
                }, function(authResult) {
                    if(!authResult || authResult.error) {
                        if(connected === true && immediate === true) {
                            // If immediate did not work retry without immediate
                            // flag
                            immediate = false;
                            task.chain(oauthRedirect);
                        }
                        else {
                            // Error
                            task.error(new Error("Access to Google account is not authorized."));
                        }
                    }
                    else {
                        // Success but we need to check the user id
                        immediate === true && authuser++;
                        task.chain(getTokenInfo);
                    }
                });
            }
            function oauthRedirect() {
                if(immediate === true) {
                    task.chain(localAuthenticate);
                    return;
                }
                core.redirectConfirm('You are being redirected to <strong>Google</strong> authorization page.', function() {
                    task.chain(localAuthenticate);
                }, function() {
                    task.error(new Error('Operation canceled.'));
                });
            }
            function startAuthenticate() {
                immediate = true;
                if(authorizationMgr.token && authorizationMgr.isAuthorized(permission)) {
                    gapi.auth.setToken(authorizationMgr.token);
                    task.chain();
                    return;
                }
                if(!authorizationMgr.getUserId()) {
                    immediate = false;
                }
                task.chain(oauthRedirect);
            }
            startAuthenticate();
        });
    }
    googleHelper.refreshGdriveToken = function(accountId) {
        var task = new AsyncTask();
        connect(task);
        var authorizationMgr = authorizationMgrMap[accountId];
        authorizationMgr && authorizationMgr.setRefreshFlag();
        authenticate(task, 'gdrive', accountId);
        task.enqueue();
    };

    googleHelper.upload = function(fileId, parentId, title, content, contentType, etag, accountId, callback) {
        var result;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'gdrive', accountId);
        task.onRun(function() {
            var boundary = '-------314159265358979323846';
            var delimiter = "\r\n--" + boundary + "\r\n";
            var close_delim = "\r\n--" + boundary + "--";
            contentType = contentType || 'text/x-markdown';
            var metadata = {
                title: title,
                mimeType: contentType
            };
            if(parentId) {
                // Specify the directory
                metadata.parents = [
                    {
                        kind: 'drive#fileLink',
                        id: parentId
                    }
                ];
            }
            var path = '/upload/drive/v2/files';
            var method = 'POST';
            if(fileId) {
                // If it's an update
                path += "/" + fileId;
                method = 'PUT';
            }
            var headers = {
                'Content-Type': 'multipart/mixed; boundary="' + boundary + '"',
            };
            // Sometimes we have error 412 from Google even with the correct
            // etag
            // if(etag !== undefined) {
            // headers["If-Match"] = etag;
            // }
            
            var base64Data = utils.encodeBase64(content);
            var multipartRequestBody = [
                delimiter,
                'Content-Type: application/json\r\n\r\n',
                JSON.stringify(metadata),
                delimiter,
                'Content-Type: ',
                contentType,
                '\r\n',
                'Content-Transfer-Encoding: base64\r\n',
                '\r\n',
                base64Data,
                close_delim
            ].join("");
            
            var request = gapi.client.request({
                'path': path,
                'method': method,
                'params': {
                    'uploadType': 'multipart',
                },
                'headers': headers,
                'body': multipartRequestBody,
            });
            request.execute(function(response) {
                if(response && response.id) {
                    // Upload success
                    result = response;
                    result.content = content;
                    task.chain();
                    return;
                }
                var error = response.error;
                // Handle error
                if(error !== undefined && fileId !== undefined) {
                    if(error.code === 404) {
                        error = 'File ID "' + fileId + '" not found on Google Drive.|removePublish';
                    }
                    else if(error.code === 412) {
                        // We may have missed a file update
                        storage.removeItem(accountId + ".gdrive.lastChangeId");
                        error = 'Conflict on file ID "' + fileId + '". Please restart the synchronization.';
                    }
                }
                handleError(error, task);
            });
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };
    
    googleHelper.rename = function(fileId, title, accountId, callback) {
        var result;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'gdrive', accountId);
        task.onRun(function() {
            var body = {'title': title};
            var request = gapi.client.drive.files.patch({
                'fileId': fileId,
                'resource': body
            });
            request.execute(function(response) {
                if(response && response.id) {
                    // Rename success
                    result = response;
                    task.chain();
                    return;
                }
                var error = response.error;
                // Handle error
                if(error !== undefined && fileId !== undefined) {
                    if(error.code === 404) {
                        error = 'File ID "' + fileId + '" not found on Google Drive.|removePublish';
                    }
                }
                handleError(error, task);
            });
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.createRealtimeFile = function(parentId, title, accountId, callback) {
        var result;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'gdrive', accountId);
        task.onRun(function() {
            var metadata = {
                title: title,
                mimeType: 'application/vnd.google-apps.drive-sdk',
            };
            if(parentId !== undefined) {
                // Specify the directory
                metadata.parents = [
                    {
                        kind: 'drive#fileLink',
                        id: parentId
                    }
                ];
            }
            var request = gapi.client.drive.files.insert({
                'resource': metadata
            });
            request.execute(function(response) {
                if(response && response.id) {
                    // Upload success
                    result = response;
                    task.chain();
                    return;
                }
                handleError(response.error, task);
            });
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.checkChanges = function(lastChangeId, accountId, callback) {
        var changes = [];
        var newChangeId = lastChangeId || 0;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'gdrive', accountId);
        task.onRun(function() {
            var nextPageToken;
            function retrievePageOfChanges() {
                var request;
                if(nextPageToken === undefined) {
                    request = gapi.client.drive.changes.list({
                        'startChangeId': newChangeId + 1
                    });
                }
                else {
                    request = gapi.client.drive.changes.list({
                        'pageToken': nextPageToken
                    });
                }

                request.execute(function(response) {
                    if(!response || !response.largestChangeId) {
                        // Handle error
                        handleError(response.error, task);
                        return;
                    }
                    // Retrieve success
                    newChangeId = response.largestChangeId;
                    nextPageToken = response.nextPageToken;
                    if(response.items !== undefined) {
                        changes = changes.concat(response.items);
                    }
                    if(nextPageToken !== undefined) {
                        task.chain(retrievePageOfChanges);
                    }
                    else {
                        task.chain();
                    }
                });
            }
            task.chain(retrievePageOfChanges);
        });
        task.onSuccess(function() {
            callback(undefined, changes, newChangeId);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.downloadMetadata = function(ids, accountId, callback, skipAuth) {
        var result = [];
        var task = new AsyncTask();
        connect(task);
        if(!skipAuth) {
            authenticate(task, 'gdrive', accountId);
        }
        task.onRun(function() {
            function recursiveDownloadMetadata() {
                if(ids.length === 0) {
                    task.chain();
                    return;
                }
                var id = ids[0];
                var headers = {};
                var token = gapi.auth.getToken();
                if(token) {
                    headers.Authorization = "Bearer " + token.access_token;
                }
                $.ajax({
                    url: "https://www.googleapis.com/drive/v2/files/" + id,
                    headers: headers,
                    data: {
                        key: constants.GOOGLE_API_KEY
                    },
                    dataType: "json",
                    timeout: constants.AJAX_TIMEOUT
                }).done(function(data) {
                    result.push(data);
                    ids.shift();
                    task.chain(recursiveDownloadMetadata);
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    // Handle error
                    if(error.code === 404) {
                        error = 'File ID "' + id + '" not found on Google Drive.';
                    }
                    handleError(error, task);
                });
            }
            task.chain(recursiveDownloadMetadata);
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.downloadContent = function(objects, accountId, callback, skipAuth) {
        var result = [];
        var task = new AsyncTask();
        // Add some time for user to choose his files
        task.timeout = constants.ASYNC_TASK_LONG_TIMEOUT;
        connect(task);
        if(!skipAuth) {
            authenticate(task, 'gdrive', accountId);
        }
        task.onRun(function() {
            function recursiveDownloadContent() {
                if(objects.length === 0) {
                    task.chain();
                    return;
                }
                var object = objects[0];
                result.push(object);
                var file;
                // object may be a file
                if(object.kind == "drive#file") {
                    file = object;
                }
                // object may be a change
                else if(object.kind == "drive#change") {
                    file = object.file;
                }
                if(!file) {
                    objects.shift();
                    task.chain(recursiveDownloadContent);
                    return;
                }
                // if file is a real time document
                if(file.mimeType.indexOf("application/vnd.google-apps.drive-sdk") === 0) {
                    file.content = "";
                    file.isRealtime = true;
                    objects.shift();
                    task.chain(recursiveDownloadContent);
                    return;
                }
                var headers = {};
                var token = gapi.auth.getToken();
                if(token) {
                    headers.Authorization = "Bearer " + token.access_token;
                }
                $.ajax({
                    url: file.downloadUrl,
                    headers: headers,
                    data: {
                        key: constants.GOOGLE_API_KEY
                    },
                    dataType: "text",
                    timeout: constants.AJAX_TIMEOUT
                }).done(function(data) {
                    file.content = data;
                    objects.shift();
                    task.chain(recursiveDownloadContent);
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    // Handle error
                    handleError(error, task);
                });
            }
            task.chain(recursiveDownloadContent);
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.loadRealtime = function(fileId, content, accountId, callback, errorCallback) {
        var doc;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'gdrive', accountId);
        task.onRun(function() {
            gapi.drive.realtime.load(fileId, function(result) {
                // onFileLoaded
                doc = result;
                task.chain();
            }, function(model) {
                // initializeModel
                var string = model.createString(content);
                model.getRoot().set('content', string);
            }, function(err) {
                errorCallback(err);
                task.error(new Error(err.message));
            });
        });
        task.onSuccess(function() {
            callback(undefined, doc);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.uploadImg = function(name, content, albumId, callback) {
        var result;
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'picasa', 'google.picasa0');
        task.onRun(function() {
            var headers = {
                "Slug": name
            };
            if(name.match(/.jpe?g$/i)) {
                headers["Content-Type"] = "image/jpeg";
            }
            else if(name.match(/.png$/i)) {
                headers["Content-Type"] = "image/png";
            }
            else if(name.match(/.gif$/i)) {
                headers["Content-Type"] = "image/gif";
            }
            var token = gapi.auth.getToken();
            if(token) {
                headers.Authorization = "Bearer " + token.access_token;
            }

            $.ajax({
                url: constants.PICASA_PROXY_URL + "upload/" + albumId,
                headers: headers,
                data: content,
                processData: false,
                dataType: "xml",
                timeout: constants.AJAX_TIMEOUT,
                type: "POST"
            }).done(function(data) {
                result = data;
                task.chain();
            }).fail(function(jqXHR) {
                var error = {
                    code: jqXHR.status,
                    message: jqXHR.statusText
                };
                if(error.code == 200) {
                    error.message = jqXHR.responseText;
                }
                handleError(error, task);
            });
        });
        task.onSuccess(function() {
            callback(undefined, result);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };

    function handleError(error, task) {
        var errorMsg;
        if(error) {
            logger.error(error);
            // Try to analyze the error
            if(typeof error === "string") {
                errorMsg = error;
            }
            else {
                errorMsg = "Google error (" + error.code + ": " + error.message + ").";
                if(error.code >= 500 && error.code < 600) {
                    // Retry as described in Google's best practices
                    task.retry(new Error(errorMsg));
                    return;
                }
                else if(error.code === 401 || error.code === 403 || error.code == "token_refresh_required") {
                    _.each(authorizationMgrMap, function(authorizationMgr) {
                        authorizationMgr.setRefreshFlag();
                    });
                    errorMsg = "Access to Google account is not authorized.";
                    task.retry(new Error(errorMsg), 1);
                    return;
                }
                else if(error.code === 0 || error.code === -1) {
                    connected = false;
                    _.each(authorizationMgrMap, function(authorizationMgr) {
                        authorizationMgr.setRefreshFlag();
                    });
                    core.setOffline();
                    errorMsg = "|stopPublish";
                }
            }
        }
        task.error(new Error(errorMsg));
    }

    var pickerLoaded = false;
    function loadPicker(task) {
        task.onRun(function() {
            if(pickerLoaded === true) {
                task.chain();
                return;
            }
            $.ajax({
                url: "//www.google.com/jsapi",
                data: {
                    key: constants.GOOGLE_API_KEY
                },
                dataType: "script",
                timeout: constants.AJAX_TIMEOUT
            }).done(function() {
                google.load('picker', '1', {
                    callback: function() {
                        task.chain();
                    }
                });
                pickerLoaded = true;
            }).fail(function(jqXHR) {
                var error = {
                    code: jqXHR.status,
                    message: jqXHR.statusText
                };
                handleError(error, task);
            });
        });
    }

    googleHelper.picker = function(callback, pickerType, accountId) {
        var docs = [];
        var picker;
        function hidePicker() {
            if(picker !== undefined) {
                picker.setVisible(false);
                $(".modal-backdrop, .picker").remove();
            }
        }
        var task = new AsyncTask();
        // Add some time for user to choose his files
        task.timeout = constants.ASYNC_TASK_LONG_TIMEOUT;
        connect(task);
        if(pickerType == 'doc' || pickerType == 'folder') {
            authenticate(task, 'gdrive', accountId);
        }
        loadPicker(task);
        task.onRun(function() {
            var pickerBuilder = new google.picker.PickerBuilder();
            pickerBuilder.setAppId(constants.GOOGLE_DRIVE_APP_ID);
            var view;
            if(pickerType == 'doc') {
                view = new google.picker.DocsView(google.picker.ViewId.DOCS);
                view.setIncludeFolders(true);
                view.setMimeTypes([
                    "text/x-markdown",
                    "text/plain",
                    "application/octet-stream",
                    "application/vnd.google-apps.drive-sdk." + constants.GOOGLE_DRIVE_APP_ID
                ].join(","));
                pickerBuilder.enableFeature(google.picker.Feature.NAV_HIDDEN);
                pickerBuilder.enableFeature(google.picker.Feature.MULTISELECT_ENABLED);
                pickerBuilder.addView(view);
                pickerBuilder.setOAuthToken(gapi.auth.getToken().access_token);
            }
            else if(pickerType == 'folder') {
                view = new google.picker.DocsView(google.picker.ViewId.FOLDERS);
                view.setIncludeFolders(true);
                view.setSelectFolderEnabled(true);
                view.setMimeTypes('application/vnd.google-apps.folder');
                pickerBuilder.enableFeature(google.picker.Feature.NAV_HIDDEN);
                pickerBuilder.addView(view);
                pickerBuilder.setOAuthToken(gapi.auth.getToken().access_token);
            }
            else if(pickerType == 'img') {
                view = new google.picker.PhotosView();
                view.setType('flat');
                pickerBuilder.addView(view);
                view = new google.picker.PhotosView();
                view.setType('ofuser');
                pickerBuilder.addView(view);
                pickerBuilder.addView(google.picker.ViewId.PHOTO_UPLOAD);
            }
            pickerBuilder.setCallback(function(data) {
                if(data.action == google.picker.Action.PICKED || data.action == google.picker.Action.CANCEL) {
                    if(data.action == google.picker.Action.PICKED) {
                        docs = data.docs;
                    }
                    hidePicker();
                    task.chain();
                }
            });
            picker = pickerBuilder.build();
            $(utils.createBackdrop()).click(function() {
                hidePicker();
                task.chain();
            });
            picker.setVisible(true);
        });
        task.onSuccess(function() {
            callback(undefined, docs);
        });
        task.onError(function(error) {
            hidePicker();
            callback(error);
        });
        task.enqueue();
    };

    googleHelper.uploadBlogger = function(blogUrl, blogId, postId, labelList, isDraft, publishDate, title, content, callback) {
        var task = new AsyncTask();
        connect(task);
        authenticate(task, 'blogger', 'google.blogger0');
        task.onRun(function() {
            var headers = {};
            var token = gapi.auth.getToken();
            if(token) {
                headers.Authorization = "Bearer " + token.access_token;
            }
            function uploadPost() {
                var url = "https://www.googleapis.com/blogger/v3/blogs/" + blogId + "/posts/";
                var data = {
                    kind: "blogger#post",
                    blog: {
                        id: blogId
                    },
                    labels: labelList,
                    title: title,
                    content: content
                };
                var type = "POST";
                // If it's an update
                if(postId !== undefined) {
                    url += postId;
                    data.id = postId;
                    type = "PUT";
                }
                $.ajax({
                    url: url,
                    data: JSON.stringify(data),
                    headers: headers,
                    type: type,
                    contentType: "application/json",
                    dataType: "json",
                    timeout: constants.AJAX_TIMEOUT
                }).done(function(post) {
                    postId = post.id;
                    task.chain(publish);
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    // Handle error
                    if(error.code === 404 && postId !== undefined) {
                        error = 'Post ' + postId + ' not found on Blogger.|removePublish';
                    }
                    handleError(error, task);
                });
            }
            function publish() {
                var url = "https://www.googleapis.com/blogger/v3/blogs/" + blogId + "/posts/" + postId;
                if(isDraft) {
                    url += "/revert";
                }
                else {
                    url += "/publish";
                    if(publishDate) {
                        url += '?publishDate=' + publishDate.toISOString();
                    }
                }
                $.ajax({
                    url: url,
                    headers: headers,
                    type: 'POST',
                    dataType: "json",
                    timeout: constants.AJAX_TIMEOUT
                }).done(function() {
                    task.chain();
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    // Handle error
                    if(error.code === 404) {
                        error = 'Post ' + postId + ' not found on Blogger.|removePublish';
                    }
                    handleError(error, task);
                });
            }
            function getBlogId() {
                if(blogId !== undefined) {
                    task.chain(uploadPost);
                    return;
                }
                $.ajax({
                    url: "https://www.googleapis.com/blogger/v3/blogs/byurl",
                    data: {
                        url: blogUrl
                    },
                    headers: headers,
                    dataType: "json",
                    timeout: constants.AJAX_TIMEOUT
                }).done(function(blog) {
                    blogId = blog.id;
                    task.chain(uploadPost);
                }).fail(function(jqXHR) {
                    var error = {
                        code: jqXHR.status,
                        message: jqXHR.statusText
                    };
                    // Handle error
                    if(error.code === 404) {
                        error = 'Blog "' + blogUrl + '" not found on Blogger.|removePublish';
                    }
                    handleError(error, task);
                });
            }
            task.chain(getBlogId);
        });
        task.onSuccess(function() {
            callback(undefined, blogId, postId);
        });
        task.onError(function(error) {
            callback(error);
        });
        task.enqueue();
    };
    
    // Use by Google's client.js
    window.delayedFunction = undefined;
    window.runDelayedFunction = function() {
        if(window.delayedFunction !== undefined) {
            window.delayedFunction();
        }
    };
    
    return googleHelper;
});