Claudio Boggian
5652 lines
222 KiB
JavaScript
5652 lines
222 KiB
JavaScript
/* Project specific JavaScript API library */
|
|
/* Version: 16.0.6222.1000 */
|
|
/*
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
/*
|
|
Your use of this file is governed by the Microsoft Services Agreement http://go.microsoft.com/fwlink/?LinkId=266419.
|
|
*/
|
|
|
|
var __extends = this.__extends || function (d, b) {
|
|
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
|
function __() { this.constructor = d; }
|
|
__.prototype = b.prototype;
|
|
d.prototype = new __();
|
|
};
|
|
var OfficeExt;
|
|
(function (OfficeExt) {
|
|
var MicrosoftAjaxFactory = (function () {
|
|
function MicrosoftAjaxFactory() {
|
|
}
|
|
MicrosoftAjaxFactory.prototype.isMsAjaxLoaded = function () {
|
|
if (typeof (Sys) !== 'undefined' && typeof (Type) !== 'undefined' && Sys.StringBuilder && typeof (Sys.StringBuilder) === "function" && Type.registerNamespace && typeof (Type.registerNamespace) === "function" && Type.registerClass && typeof (Type.registerClass) === "function" && typeof (Function._validateParams) === "function") {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
MicrosoftAjaxFactory.prototype.loadMsAjaxFull = function (callback) {
|
|
var msAjaxCDNPath = (window.location.protocol.toLowerCase() === 'https:' ? 'https:' : 'http:') + '//ajax.aspnetcdn.com/ajax/3.5/MicrosoftAjax.js';
|
|
OSF.OUtil.loadScript(msAjaxCDNPath, callback);
|
|
};
|
|
Object.defineProperty(MicrosoftAjaxFactory.prototype, "msAjaxError", {
|
|
get: function () {
|
|
if (this._msAjaxError == null && this.isMsAjaxLoaded()) {
|
|
this._msAjaxError = Error;
|
|
}
|
|
return this._msAjaxError;
|
|
},
|
|
set: function (errorClass) {
|
|
this._msAjaxError = errorClass;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(MicrosoftAjaxFactory.prototype, "msAjaxSerializer", {
|
|
get: function () {
|
|
if (this._msAjaxSerializer == null && this.isMsAjaxLoaded()) {
|
|
this._msAjaxSerializer = Sys.Serialization.JavaScriptSerializer;
|
|
}
|
|
return this._msAjaxSerializer;
|
|
},
|
|
set: function (serializerClass) {
|
|
this._msAjaxSerializer = serializerClass;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(MicrosoftAjaxFactory.prototype, "msAjaxString", {
|
|
get: function () {
|
|
if (this._msAjaxString == null && this.isMsAjaxLoaded()) {
|
|
this._msAjaxSerializer = String;
|
|
}
|
|
return this._msAjaxString;
|
|
},
|
|
set: function (stringClass) {
|
|
this._msAjaxString = stringClass;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(MicrosoftAjaxFactory.prototype, "msAjaxDebug", {
|
|
get: function () {
|
|
if (this._msAjaxDebug == null && this.isMsAjaxLoaded()) {
|
|
this._msAjaxDebug = Sys.Debug;
|
|
}
|
|
return this._msAjaxDebug;
|
|
},
|
|
set: function (debugClass) {
|
|
this._msAjaxDebug = debugClass;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
return MicrosoftAjaxFactory;
|
|
})();
|
|
OfficeExt.MicrosoftAjaxFactory = MicrosoftAjaxFactory;
|
|
})(OfficeExt || (OfficeExt = {}));
|
|
var OsfMsAjaxFactory = new OfficeExt.MicrosoftAjaxFactory();
|
|
var OSF = OSF || {};
|
|
var OfficeExt;
|
|
(function (OfficeExt) {
|
|
var SafeStorage = (function () {
|
|
function SafeStorage(_internalStorage) {
|
|
this._internalStorage = _internalStorage;
|
|
}
|
|
SafeStorage.prototype.getItem = function (key) {
|
|
try {
|
|
return this._internalStorage && this._internalStorage.getItem(key);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
};
|
|
SafeStorage.prototype.setItem = function (key, data) {
|
|
try {
|
|
this._internalStorage && this._internalStorage.setItem(key, data);
|
|
} catch (e) {
|
|
}
|
|
};
|
|
SafeStorage.prototype.clear = function () {
|
|
try {
|
|
this._internalStorage && this._internalStorage.clear();
|
|
} catch (e) {
|
|
}
|
|
};
|
|
SafeStorage.prototype.removeItem = function (key) {
|
|
try {
|
|
this._internalStorage && this._internalStorage.removeItem(key);
|
|
} catch (e) {
|
|
}
|
|
};
|
|
SafeStorage.prototype.getKeysWithPrefix = function (keyPrefix) {
|
|
var keyList = [];
|
|
try {
|
|
var len = this._internalStorage && this._internalStorage.length || 0;
|
|
for (var i = 0; i < len; i++) {
|
|
var key = this._internalStorage.key(i);
|
|
if (key.indexOf(keyPrefix) === 0) {
|
|
keyList.push(key);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return keyList;
|
|
};
|
|
return SafeStorage;
|
|
})();
|
|
OfficeExt.SafeStorage = SafeStorage;
|
|
})(OfficeExt || (OfficeExt = {}));
|
|
OSF.OUtil = (function () {
|
|
var _uniqueId = -1;
|
|
var _xdmInfoKey = '&_xdm_Info=';
|
|
var _serializerVersionKey = '&_serializer_version=';
|
|
var _xdmSessionKeyPrefix = '_xdm_';
|
|
var _serializerVersionKeyPrefix = '_serializer_version=';
|
|
var _fragmentSeparator = '#';
|
|
var _loadedScripts = {};
|
|
var _defaultScriptLoadingTimeout = 30000;
|
|
var _safeSessionStorage = null;
|
|
var _safeLocalStorage = null;
|
|
|
|
var _rndentropy = new Date().getTime();
|
|
function _random() {
|
|
var nextrand = 0x7fffffff * (Math.random());
|
|
nextrand ^= _rndentropy ^ ((new Date().getMilliseconds()) << Math.floor(Math.random() * (31 - 10)));
|
|
|
|
return nextrand.toString(16);
|
|
}
|
|
;
|
|
function _getSessionStorage() {
|
|
if (!_safeSessionStorage) {
|
|
try {
|
|
var sessionStorage = window.sessionStorage;
|
|
} catch (ex) {
|
|
sessionStorage = null;
|
|
}
|
|
_safeSessionStorage = new OfficeExt.SafeStorage(sessionStorage);
|
|
}
|
|
return _safeSessionStorage;
|
|
}
|
|
;
|
|
return {
|
|
set_entropy: function OSF_OUtil$set_entropy(entropy) {
|
|
if (typeof entropy == "string") {
|
|
for (var i = 0; i < entropy.length; i += 4) {
|
|
var temp = 0;
|
|
for (var j = 0; j < 4 && i + j < entropy.length; j++) {
|
|
temp = (temp << 8) + entropy.charCodeAt(i + j);
|
|
}
|
|
_rndentropy ^= temp;
|
|
}
|
|
} else if (typeof entropy == "number") {
|
|
_rndentropy ^= entropy;
|
|
} else {
|
|
_rndentropy ^= 0x7fffffff * Math.random();
|
|
}
|
|
_rndentropy &= 0x7fffffff;
|
|
},
|
|
extend: function OSF_OUtil$extend(child, parent) {
|
|
var F = function () {
|
|
};
|
|
F.prototype = parent.prototype;
|
|
child.prototype = new F();
|
|
child.prototype.constructor = child;
|
|
child.uber = parent.prototype;
|
|
if (parent.prototype.constructor === Object.prototype.constructor) {
|
|
parent.prototype.constructor = parent;
|
|
}
|
|
},
|
|
setNamespace: function OSF_OUtil$setNamespace(name, parent) {
|
|
if (parent && name && !parent[name]) {
|
|
parent[name] = {};
|
|
}
|
|
},
|
|
unsetNamespace: function OSF_OUtil$unsetNamespace(name, parent) {
|
|
if (parent && name && parent[name]) {
|
|
delete parent[name];
|
|
}
|
|
},
|
|
loadScript: function OSF_OUtil$loadScript(url, callback, timeoutInMs) {
|
|
if (url && callback) {
|
|
var doc = window.document;
|
|
var _loadedScriptEntry = _loadedScripts[url];
|
|
if (!_loadedScriptEntry) {
|
|
var script = doc.createElement("script");
|
|
script.type = "text/javascript";
|
|
_loadedScriptEntry = { loaded: false, pendingCallbacks: [callback], timer: null };
|
|
_loadedScripts[url] = _loadedScriptEntry;
|
|
var onLoadCallback = function OSF_OUtil_loadScript$onLoadCallback() {
|
|
if (_loadedScriptEntry.timer != null) {
|
|
clearTimeout(_loadedScriptEntry.timer);
|
|
delete _loadedScriptEntry.timer;
|
|
}
|
|
_loadedScriptEntry.loaded = true;
|
|
var pendingCallbackCount = _loadedScriptEntry.pendingCallbacks.length;
|
|
for (var i = 0; i < pendingCallbackCount; i++) {
|
|
var currentCallback = _loadedScriptEntry.pendingCallbacks.shift();
|
|
currentCallback();
|
|
}
|
|
};
|
|
var onLoadError = function OSF_OUtil_loadScript$onLoadError() {
|
|
delete _loadedScripts[url];
|
|
if (_loadedScriptEntry.timer != null) {
|
|
clearTimeout(_loadedScriptEntry.timer);
|
|
delete _loadedScriptEntry.timer;
|
|
}
|
|
var pendingCallbackCount = _loadedScriptEntry.pendingCallbacks.length;
|
|
for (var i = 0; i < pendingCallbackCount; i++) {
|
|
var currentCallback = _loadedScriptEntry.pendingCallbacks.shift();
|
|
currentCallback();
|
|
}
|
|
};
|
|
if (script.readyState) {
|
|
script.onreadystatechange = function () {
|
|
if (script.readyState == "loaded" || script.readyState == "complete") {
|
|
script.onreadystatechange = null;
|
|
onLoadCallback();
|
|
}
|
|
};
|
|
} else {
|
|
script.onload = onLoadCallback;
|
|
}
|
|
script.onerror = onLoadError;
|
|
|
|
timeoutInMs = timeoutInMs || _defaultScriptLoadingTimeout;
|
|
_loadedScriptEntry.timer = setTimeout(onLoadError, timeoutInMs);
|
|
script.src = url;
|
|
doc.getElementsByTagName("head")[0].appendChild(script);
|
|
} else if (_loadedScriptEntry.loaded) {
|
|
callback();
|
|
} else {
|
|
_loadedScriptEntry.pendingCallbacks.push(callback);
|
|
}
|
|
}
|
|
},
|
|
loadCSS: function OSF_OUtil$loadCSS(url) {
|
|
if (url) {
|
|
var doc = window.document;
|
|
var link = doc.createElement("link");
|
|
link.type = "text/css";
|
|
link.rel = "stylesheet";
|
|
link.href = url;
|
|
doc.getElementsByTagName("head")[0].appendChild(link);
|
|
}
|
|
},
|
|
parseEnum: function OSF_OUtil$parseEnum(str, enumObject) {
|
|
var parsed = enumObject[str.trim()];
|
|
if (typeof (parsed) == 'undefined') {
|
|
OsfMsAjaxFactory.msAjaxDebug.trace("invalid enumeration string:" + str);
|
|
throw OsfMsAjaxFactory.msAjaxError.argument("str");
|
|
}
|
|
return parsed;
|
|
},
|
|
delayExecutionAndCache: function OSF_OUtil$delayExecutionAndCache() {
|
|
var obj = { calc: arguments[0] };
|
|
return function () {
|
|
if (obj.calc) {
|
|
obj.val = obj.calc.apply(this, arguments);
|
|
delete obj.calc;
|
|
}
|
|
return obj.val;
|
|
};
|
|
},
|
|
getUniqueId: function OSF_OUtil$getUniqueId() {
|
|
_uniqueId = _uniqueId + 1;
|
|
return _uniqueId.toString();
|
|
},
|
|
formatString: function OSF_OUtil$formatString() {
|
|
var args = arguments;
|
|
var source = args[0];
|
|
return source.replace(/{(\d+)}/gm, function (match, number) {
|
|
var index = parseInt(number, 10) + 1;
|
|
return args[index] === undefined ? '{' + number + '}' : args[index];
|
|
});
|
|
},
|
|
generateConversationId: function OSF_OUtil$generateConversationId() {
|
|
return [_random(), _random(), (new Date()).getTime().toString()].join('_');
|
|
},
|
|
getFrameNameAndConversationId: function OSF_OUtil$getFrameNameAndConversationId(cacheKey, frame) {
|
|
var frameName = _xdmSessionKeyPrefix + cacheKey + this.generateConversationId();
|
|
frame.setAttribute("name", frameName);
|
|
return this.generateConversationId();
|
|
},
|
|
addXdmInfoAsHash: function OSF_OUtil$addXdmInfoAsHash(url, xdmInfoValue) {
|
|
return OSF.OUtil.addInfoAsHash(url, _xdmInfoKey, xdmInfoValue);
|
|
},
|
|
addSerializerVersionAsHash: function OSF_OUtil$addSerializerVersionAsHash(url, serializerVersion) {
|
|
return OSF.OUtil.addInfoAsHash(url, _serializerVersionKey, serializerVersion);
|
|
},
|
|
addInfoAsHash: function OSF_OUtil$addInfoAsHash(url, keyName, infoValue) {
|
|
url = url.trim() || '';
|
|
var urlParts = url.split(_fragmentSeparator);
|
|
var urlWithoutFragment = urlParts.shift();
|
|
var fragment = urlParts.join(_fragmentSeparator);
|
|
return [urlWithoutFragment, _fragmentSeparator, fragment, keyName, infoValue].join('');
|
|
},
|
|
parseXdmInfo: function OSF_OUtil$parseXdmInfo(skipSessionStorage) {
|
|
return OSF.OUtil.parseXdmInfoWithGivenFragment(skipSessionStorage, window.location.hash);
|
|
},
|
|
parseXdmInfoWithGivenFragment: function OSF_OUtil$parseXdmInfoWithGivenFragment(skipSessionStorage, fragment) {
|
|
return OSF.OUtil.parseInfoWithGivenFragment(_xdmInfoKey, _xdmSessionKeyPrefix, skipSessionStorage, fragment);
|
|
},
|
|
parseSerializerVersion: function OSF_OUtil$parseSerializerVersion(skipSessionStorage) {
|
|
return OSF.OUtil.parseSerializerVersionWithGivenFragment(skipSessionStorage, window.location.hash);
|
|
},
|
|
parseSerializerVersionWithGivenFragment: function OSF_OUtil$parseSerializerVersionWithGivenFragment(skipSessionStorage, fragment) {
|
|
return parseInt(OSF.OUtil.parseInfoWithGivenFragment(_serializerVersionKey, _serializerVersionKeyPrefix, skipSessionStorage, fragment));
|
|
},
|
|
parseInfoWithGivenFragment: function OSF_OUtil$parseInfoWithGivenFragment(infoKey, infoKeyPrefix, skipSessionStorage, fragment) {
|
|
var fragmentParts = fragment.split(infoKey);
|
|
var xdmInfoValue = fragmentParts.length > 1 ? fragmentParts[fragmentParts.length - 1] : null;
|
|
var osfSessionStorage = _getSessionStorage();
|
|
if (!skipSessionStorage && osfSessionStorage) {
|
|
var sessionKeyStart = window.name.indexOf(infoKeyPrefix);
|
|
if (sessionKeyStart > -1) {
|
|
var sessionKeyEnd = window.name.indexOf(";", sessionKeyStart);
|
|
if (sessionKeyEnd == -1) {
|
|
sessionKeyEnd = window.name.length;
|
|
}
|
|
var sessionKey = window.name.substring(sessionKeyStart, sessionKeyEnd);
|
|
if (xdmInfoValue) {
|
|
osfSessionStorage.setItem(sessionKey, xdmInfoValue);
|
|
} else {
|
|
xdmInfoValue = osfSessionStorage.getItem(sessionKey);
|
|
}
|
|
}
|
|
}
|
|
return xdmInfoValue;
|
|
},
|
|
getConversationId: function OSF_OUtil$getConversationId() {
|
|
var searchString = window.location.search;
|
|
var conversationId = null;
|
|
if (searchString) {
|
|
var index = searchString.indexOf("&");
|
|
|
|
conversationId = index > 0 ? searchString.substring(1, index) : searchString.substr(1);
|
|
if (conversationId && conversationId.charAt(conversationId.length - 1) === '=') {
|
|
conversationId = conversationId.substring(0, conversationId.length - 1);
|
|
if (conversationId) {
|
|
conversationId = decodeURIComponent(conversationId);
|
|
}
|
|
}
|
|
}
|
|
return conversationId;
|
|
},
|
|
getInfoItems: function OSF_OUtil$getInfoItems(strInfo) {
|
|
var items = strInfo.split("$");
|
|
if (typeof items[1] == "undefined") {
|
|
items = strInfo.split("|");
|
|
}
|
|
return items;
|
|
},
|
|
getConversationUrl: function OSF_OUtil$getConversationUrl() {
|
|
var conversationUrl = '';
|
|
var xdmInfoValue = OSF.OUtil.parseXdmInfo(true);
|
|
if (xdmInfoValue) {
|
|
var items = OSF.OUtil.getInfoItems(xdmInfoValue);
|
|
if (items != undefined && items.length >= 3) {
|
|
conversationUrl = items[2];
|
|
}
|
|
}
|
|
return conversationUrl;
|
|
},
|
|
validateParamObject: function OSF_OUtil$validateParamObject(params, expectedProperties, callback) {
|
|
var e = Function._validateParams(arguments, [
|
|
{ name: "params", type: Object, mayBeNull: false },
|
|
{ name: "expectedProperties", type: Object, mayBeNull: false },
|
|
{ name: "callback", type: Function, mayBeNull: true }
|
|
]);
|
|
if (e)
|
|
throw e;
|
|
for (var p in expectedProperties) {
|
|
e = Function._validateParameter(params[p], expectedProperties[p], p);
|
|
if (e)
|
|
throw e;
|
|
}
|
|
},
|
|
writeProfilerMark: function OSF_OUtil$writeProfilerMark(text) {
|
|
if (window.msWriteProfilerMark) {
|
|
window.msWriteProfilerMark(text);
|
|
OsfMsAjaxFactory.msAjaxDebug.trace(text);
|
|
}
|
|
},
|
|
outputDebug: function OSF_OUtil$outputDebug(text) {
|
|
if (typeof (Sys) !== 'undefined' && Sys && Sys.Debug) {
|
|
OsfMsAjaxFactory.msAjaxDebug.trace(text);
|
|
}
|
|
},
|
|
defineNondefaultProperty: function OSF_OUtil$defineNondefaultProperty(obj, prop, descriptor, attributes) {
|
|
descriptor = descriptor || {};
|
|
for (var nd in attributes) {
|
|
var attribute = attributes[nd];
|
|
if (descriptor[attribute] == undefined) {
|
|
descriptor[attribute] = true;
|
|
}
|
|
}
|
|
Object.defineProperty(obj, prop, descriptor);
|
|
return obj;
|
|
},
|
|
defineNondefaultProperties: function OSF_OUtil$defineNondefaultProperties(obj, descriptors, attributes) {
|
|
descriptors = descriptors || {};
|
|
for (var prop in descriptors) {
|
|
OSF.OUtil.defineNondefaultProperty(obj, prop, descriptors[prop], attributes);
|
|
}
|
|
return obj;
|
|
},
|
|
defineEnumerableProperty: function OSF_OUtil$defineEnumerableProperty(obj, prop, descriptor) {
|
|
return OSF.OUtil.defineNondefaultProperty(obj, prop, descriptor, ["enumerable"]);
|
|
},
|
|
defineEnumerableProperties: function OSF_OUtil$defineEnumerableProperties(obj, descriptors) {
|
|
return OSF.OUtil.defineNondefaultProperties(obj, descriptors, ["enumerable"]);
|
|
},
|
|
defineMutableProperty: function OSF_OUtil$defineMutableProperty(obj, prop, descriptor) {
|
|
return OSF.OUtil.defineNondefaultProperty(obj, prop, descriptor, ["writable", "enumerable", "configurable"]);
|
|
},
|
|
defineMutableProperties: function OSF_OUtil$defineMutableProperties(obj, descriptors) {
|
|
return OSF.OUtil.defineNondefaultProperties(obj, descriptors, ["writable", "enumerable", "configurable"]);
|
|
},
|
|
finalizeProperties: function OSF_OUtil$finalizeProperties(obj, descriptor) {
|
|
descriptor = descriptor || {};
|
|
var props = Object.getOwnPropertyNames(obj);
|
|
var propsLength = props.length;
|
|
for (var i = 0; i < propsLength; i++) {
|
|
var prop = props[i];
|
|
var desc = Object.getOwnPropertyDescriptor(obj, prop);
|
|
if (!desc.get && !desc.set) {
|
|
desc.writable = descriptor.writable || false;
|
|
}
|
|
desc.configurable = descriptor.configurable || false;
|
|
desc.enumerable = descriptor.enumerable || true;
|
|
Object.defineProperty(obj, prop, desc);
|
|
}
|
|
return obj;
|
|
},
|
|
mapList: function OSF_OUtil$MapList(list, mapFunction) {
|
|
var ret = [];
|
|
if (list) {
|
|
for (var item in list) {
|
|
ret.push(mapFunction(list[item]));
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
listContainsKey: function OSF_OUtil$listContainsKey(list, key) {
|
|
for (var item in list) {
|
|
if (key == item) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
listContainsValue: function OSF_OUtil$listContainsElement(list, value) {
|
|
for (var item in list) {
|
|
if (value == list[item]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
augmentList: function OSF_OUtil$augmentList(list, addenda) {
|
|
var add = list.push ? function (key, value) {
|
|
list.push(value);
|
|
} : function (key, value) {
|
|
list[key] = value;
|
|
};
|
|
for (var key in addenda) {
|
|
add(key, addenda[key]);
|
|
}
|
|
},
|
|
redefineList: function OSF_Outil$redefineList(oldList, newList) {
|
|
for (var key1 in oldList) {
|
|
delete oldList[key1];
|
|
}
|
|
for (var key2 in newList) {
|
|
oldList[key2] = newList[key2];
|
|
}
|
|
},
|
|
isArray: function OSF_OUtil$isArray(obj) {
|
|
return Object.prototype.toString.apply(obj) === "[object Array]";
|
|
},
|
|
isFunction: function OSF_OUtil$isFunction(obj) {
|
|
return Object.prototype.toString.apply(obj) === "[object Function]";
|
|
},
|
|
isDate: function OSF_OUtil$isDate(obj) {
|
|
return Object.prototype.toString.apply(obj) === "[object Date]";
|
|
},
|
|
addEventListener: function OSF_OUtil$addEventListener(element, eventName, listener) {
|
|
if (element.addEventListener) {
|
|
element.addEventListener(eventName, listener, false);
|
|
} else if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) && element.attachEvent) {
|
|
element.attachEvent("on" + eventName, listener);
|
|
} else {
|
|
element["on" + eventName] = listener;
|
|
}
|
|
},
|
|
removeEventListener: function OSF_OUtil$removeEventListener(element, eventName, listener) {
|
|
if (element.removeEventListener) {
|
|
element.removeEventListener(eventName, listener, false);
|
|
} else if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) && element.detachEvent) {
|
|
element.detachEvent("on" + eventName, listener);
|
|
} else {
|
|
element["on" + eventName] = null;
|
|
}
|
|
},
|
|
xhrGet: function OSF_OUtil$xhrGet(url, onSuccess, onError) {
|
|
var xmlhttp;
|
|
try {
|
|
xmlhttp = new XMLHttpRequest();
|
|
xmlhttp.onreadystatechange = function () {
|
|
if (xmlhttp.readyState == 4) {
|
|
if (xmlhttp.status == 200) {
|
|
onSuccess(xmlhttp.responseText);
|
|
} else {
|
|
onError(xmlhttp.status);
|
|
}
|
|
}
|
|
};
|
|
xmlhttp.open("GET", url, true);
|
|
xmlhttp.send();
|
|
} catch (ex) {
|
|
onError(ex);
|
|
}
|
|
},
|
|
encodeBase64: function OSF_Outil$encodeBase64(input) {
|
|
if (!input)
|
|
return input;
|
|
var codex = "ABCDEFGHIJKLMNOP" + "QRSTUVWXYZabcdef" + "ghijklmnopqrstuv" + "wxyz0123456789+/=";
|
|
var output = [];
|
|
var temp = [];
|
|
var index = 0;
|
|
var c1, c2, c3, a, b, c;
|
|
var i;
|
|
var length = input.length;
|
|
do {
|
|
c1 = input.charCodeAt(index++);
|
|
c2 = input.charCodeAt(index++);
|
|
c3 = input.charCodeAt(index++);
|
|
i = 0;
|
|
a = c1 & 255;
|
|
b = c1 >> 8;
|
|
c = c2 & 255;
|
|
temp[i++] = a >> 2;
|
|
temp[i++] = ((a & 3) << 4) | (b >> 4);
|
|
temp[i++] = ((b & 15) << 2) | (c >> 6);
|
|
temp[i++] = c & 63;
|
|
if (!isNaN(c2)) {
|
|
a = c2 >> 8;
|
|
b = c3 & 255;
|
|
c = c3 >> 8;
|
|
temp[i++] = a >> 2;
|
|
temp[i++] = ((a & 3) << 4) | (b >> 4);
|
|
temp[i++] = ((b & 15) << 2) | (c >> 6);
|
|
temp[i++] = c & 63;
|
|
}
|
|
if (isNaN(c2)) {
|
|
temp[i - 1] = 64;
|
|
} else if (isNaN(c3)) {
|
|
temp[i - 2] = 64;
|
|
temp[i - 1] = 64;
|
|
}
|
|
for (var t = 0; t < i; t++) {
|
|
output.push(codex.charAt(temp[t]));
|
|
}
|
|
} while(index < length);
|
|
return output.join("");
|
|
},
|
|
getSessionStorage: function OSF_Outil$getSessionStorage() {
|
|
return _getSessionStorage();
|
|
},
|
|
getLocalStorage: function OSF_Outil$getLocalStorage() {
|
|
if (!_safeLocalStorage) {
|
|
try {
|
|
var localStorage = window.localStorage;
|
|
} catch (ex) {
|
|
localStorage = null;
|
|
}
|
|
_safeLocalStorage = new OfficeExt.SafeStorage(localStorage);
|
|
}
|
|
return _safeLocalStorage;
|
|
},
|
|
convertIntToCssHexColor: function OSF_Outil$convertIntToCssHexColor(val) {
|
|
var hex = "#" + (Number(val) + 0x1000000).toString(16).slice(-6);
|
|
return hex;
|
|
},
|
|
attachClickHandler: function OSF_Outil$attachClickHandler(element, handler) {
|
|
element.onclick = function (e) {
|
|
handler();
|
|
};
|
|
element.ontouchend = function (e) {
|
|
handler();
|
|
e.preventDefault();
|
|
};
|
|
},
|
|
getQueryStringParamValue: function OSF_Outil$getQueryStringParamValue(queryString, paramName) {
|
|
var e = Function._validateParams(arguments, [
|
|
{ name: "queryString", type: String, mayBeNull: false },
|
|
{ name: "paramName", type: String, mayBeNull: false }
|
|
]);
|
|
if (e) {
|
|
OsfMsAjaxFactory.msAjaxDebug.trace("OSF_Outil_getQueryStringParamValue: Parameters cannot be null.");
|
|
return "";
|
|
}
|
|
var queryExp = new RegExp("[\\?&]" + paramName + "=([^&#]*)", "i");
|
|
if (!queryExp.test(queryString)) {
|
|
OsfMsAjaxFactory.msAjaxDebug.trace("OSF_Outil_getQueryStringParamValue: The parameter is not found.");
|
|
return "";
|
|
}
|
|
return queryExp.exec(queryString)[1];
|
|
},
|
|
isiOS: function OSF_Outil$isiOS() {
|
|
return (window.navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? true : false);
|
|
},
|
|
shallowCopy: function OSF_Outil$shallowCopy(sourceObj) {
|
|
var copyObj = sourceObj.constructor();
|
|
for (var property in sourceObj) {
|
|
if (sourceObj.hasOwnProperty(property)) {
|
|
copyObj[property] = sourceObj[property];
|
|
}
|
|
}
|
|
return copyObj;
|
|
}
|
|
};
|
|
})();
|
|
|
|
OSF.OUtil.Guid = (function () {
|
|
var hexCode = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
|
|
return {
|
|
generateNewGuid: function OSF_Outil_Guid$generateNewGuid() {
|
|
var result = "";
|
|
var tick = (new Date()).getTime();
|
|
var index = 0;
|
|
|
|
for (; index < 32 && tick > 0; index++) {
|
|
if (index == 8 || index == 12 || index == 16 || index == 20) {
|
|
result += "-";
|
|
}
|
|
result += hexCode[tick % 16];
|
|
tick = Math.floor(tick / 16);
|
|
}
|
|
|
|
for (; index < 32; index++) {
|
|
if (index == 8 || index == 12 || index == 16 || index == 20) {
|
|
result += "-";
|
|
}
|
|
result += hexCode[Math.floor(Math.random() * 16)];
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
})();
|
|
window.OSF = OSF;
|
|
OSF.OUtil.setNamespace("OSF", window);
|
|
|
|
OSF.AppName = {
|
|
Unsupported: 0,
|
|
Excel: 1,
|
|
Word: 2,
|
|
PowerPoint: 4,
|
|
Outlook: 8,
|
|
ExcelWebApp: 16,
|
|
WordWebApp: 32,
|
|
OutlookWebApp: 64,
|
|
Project: 128,
|
|
AccessWebApp: 256,
|
|
PowerpointWebApp: 512,
|
|
ExcelIOS: 1024,
|
|
Sway: 2048,
|
|
WordIOS: 4096,
|
|
PowerPointIOS: 8192,
|
|
Access: 16384,
|
|
Lync: 32768,
|
|
OutlookIOS: 65536,
|
|
OneNoteWebApp: 131072
|
|
};
|
|
OSF.InternalPerfMarker = {
|
|
DataCoercionBegin: "Agave.HostCall.CoerceDataStart",
|
|
DataCoercionEnd: "Agave.HostCall.CoerceDataEnd"
|
|
};
|
|
OSF.HostCallPerfMarker = {
|
|
IssueCall: "Agave.HostCall.IssueCall",
|
|
ReceiveResponse: "Agave.HostCall.ReceiveResponse",
|
|
RuntimeExceptionRaised: "Agave.HostCall.RuntimeExecptionRaised"
|
|
};
|
|
|
|
OSF.AgaveHostAction = {
|
|
"Select": 0,
|
|
"UnSelect": 1,
|
|
"CancelDialog": 2,
|
|
"InsertAgave": 3,
|
|
"CtrlF6In": 4,
|
|
"CtrlF6Exit": 5,
|
|
"CtrlF6ExitShift": 6,
|
|
"SelectWithError": 7,
|
|
"NotifyHostError": 8
|
|
};
|
|
|
|
OSF.SharedConstants = {
|
|
"NotificationConversationIdSuffix": '_ntf'
|
|
};
|
|
|
|
OSF.OfficeAppContext = function OSF_OfficeAppContext(id, appName, appVersion, appUILocale, dataLocale, docUrl, clientMode, settings, reason, osfControlType, eToken, correlationId, appInstanceId, touchEnabled, commerceAllowed, appMinorVersion, requirementMatrix) {
|
|
this._id = id;
|
|
this._appName = appName;
|
|
this._appVersion = appVersion;
|
|
this._appUILocale = appUILocale;
|
|
this._dataLocale = dataLocale;
|
|
this._docUrl = docUrl;
|
|
this._clientMode = clientMode;
|
|
this._settings = settings;
|
|
this._reason = reason;
|
|
this._osfControlType = osfControlType;
|
|
this._eToken = eToken;
|
|
this._correlationId = correlationId;
|
|
this._appInstanceId = appInstanceId;
|
|
this._touchEnabled = touchEnabled;
|
|
this._commerceAllowed = commerceAllowed;
|
|
this._appMinorVersion = appMinorVersion;
|
|
this._requirementMatrix = requirementMatrix;
|
|
this.get_id = function get_id() {
|
|
return this._id;
|
|
};
|
|
this.get_appName = function get_appName() {
|
|
return this._appName;
|
|
};
|
|
this.get_appVersion = function get_appVersion() {
|
|
return this._appVersion;
|
|
};
|
|
this.get_appUILocale = function get_appUILocale() {
|
|
return this._appUILocale;
|
|
};
|
|
this.get_dataLocale = function get_dataLocale() {
|
|
return this._dataLocale;
|
|
};
|
|
this.get_docUrl = function get_docUrl() {
|
|
return this._docUrl;
|
|
};
|
|
this.get_clientMode = function get_clientMode() {
|
|
return this._clientMode;
|
|
};
|
|
this.get_bindings = function get_bindings() {
|
|
return this._bindings;
|
|
};
|
|
this.get_settings = function get_settings() {
|
|
return this._settings;
|
|
};
|
|
this.get_reason = function get_reason() {
|
|
return this._reason;
|
|
};
|
|
this.get_osfControlType = function get_osfControlType() {
|
|
return this._osfControlType;
|
|
};
|
|
this.get_eToken = function get_eToken() {
|
|
return this._eToken;
|
|
};
|
|
this.get_correlationId = function get_correlationId() {
|
|
return this._correlationId;
|
|
};
|
|
this.get_appInstanceId = function get_appInstanceId() {
|
|
return this._appInstanceId;
|
|
};
|
|
this.get_touchEnabled = function get_touchEnabled() {
|
|
return this._touchEnabled;
|
|
};
|
|
this.get_commerceAllowed = function get_commerceAllowed() {
|
|
return this._commerceAllowed;
|
|
};
|
|
this.get_appMinorVersion = function get_appMinorVersion() {
|
|
return this._appMinorVersion;
|
|
};
|
|
this.get_requirementMatrix = function get_requirementMatrix() {
|
|
return this._requirementMatrix;
|
|
};
|
|
};
|
|
OSF.OsfControlType = {
|
|
DocumentLevel: 0,
|
|
ContainerLevel: 1
|
|
};
|
|
|
|
OSF.ClientMode = {
|
|
ReadOnly: 0,
|
|
ReadWrite: 1
|
|
};
|
|
|
|
OSF.OUtil.setNamespace("Microsoft", window);
|
|
OSF.OUtil.setNamespace("Office", Microsoft);
|
|
OSF.OUtil.setNamespace("Client", Microsoft.Office);
|
|
OSF.OUtil.setNamespace("WebExtension", Microsoft.Office);
|
|
|
|
Microsoft.Office.WebExtension.InitializationReason = {
|
|
Inserted: "inserted",
|
|
DocumentOpened: "documentOpened"
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.ValueFormat = {
|
|
Unformatted: "unformatted",
|
|
Formatted: "formatted"
|
|
};
|
|
Microsoft.Office.WebExtension.FilterType = {
|
|
All: "all"
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.Parameters = {
|
|
BindingType: "bindingType",
|
|
CoercionType: "coercionType",
|
|
ValueFormat: "valueFormat",
|
|
FilterType: "filterType",
|
|
Columns: "columns",
|
|
SampleData: "sampleData",
|
|
GoToType: "goToType",
|
|
SelectionMode: "selectionMode",
|
|
Id: "id",
|
|
PromptText: "promptText",
|
|
ItemName: "itemName",
|
|
FailOnCollision: "failOnCollision",
|
|
StartRow: "startRow",
|
|
StartColumn: "startColumn",
|
|
RowCount: "rowCount",
|
|
ColumnCount: "columnCount",
|
|
Callback: "callback",
|
|
AsyncContext: "asyncContext",
|
|
Data: "data",
|
|
Rows: "rows",
|
|
OverwriteIfStale: "overwriteIfStale",
|
|
FileType: "fileType",
|
|
EventType: "eventType",
|
|
Handler: "handler",
|
|
SliceSize: "sliceSize",
|
|
SliceIndex: "sliceIndex",
|
|
ActiveView: "activeView",
|
|
Status: "status",
|
|
Xml: "xml",
|
|
Namespace: "namespace",
|
|
Prefix: "prefix",
|
|
XPath: "xPath",
|
|
ImageLeft: "imageLeft",
|
|
ImageTop: "imageTop",
|
|
ImageWidth: "imageWidth",
|
|
ImageHeight: "imageHeight",
|
|
TaskId: "taskId",
|
|
FieldId: "fieldId",
|
|
FieldValue: "fieldValue",
|
|
ServerUrl: "serverUrl",
|
|
ListName: "listName",
|
|
ResourceId: "resourceId",
|
|
ViewType: "viewType",
|
|
ViewName: "viewName",
|
|
GetRawValue: "getRawValue",
|
|
CellFormat: "cellFormat",
|
|
TableOptions: "tableOptions",
|
|
TaskIndex: "taskIndex",
|
|
ResourceIndex: "resourceIndex"
|
|
};
|
|
OSF.OUtil.setNamespace("DDA", OSF);
|
|
|
|
OSF.DDA.DocumentMode = {
|
|
ReadOnly: 1,
|
|
ReadWrite: 0
|
|
};
|
|
|
|
OSF.DDA.PropertyDescriptors = {
|
|
AsyncResultStatus: "AsyncResultStatus"
|
|
};
|
|
OSF.DDA.EventDescriptors = {};
|
|
OSF.DDA.ListDescriptors = {};
|
|
|
|
OSF.DDA.getXdmEventName = function OSF_DDA$GetXdmEventName(bindingId, eventType) {
|
|
if (eventType == Microsoft.Office.WebExtension.EventType.BindingSelectionChanged || eventType == Microsoft.Office.WebExtension.EventType.BindingDataChanged) {
|
|
return bindingId + "_" + eventType;
|
|
} else {
|
|
return eventType;
|
|
}
|
|
};
|
|
OSF.DDA.MethodDispId = {
|
|
dispidMethodMin: 64,
|
|
dispidGetSelectedDataMethod: 64,
|
|
dispidSetSelectedDataMethod: 65,
|
|
dispidAddBindingFromSelectionMethod: 66,
|
|
dispidAddBindingFromPromptMethod: 67,
|
|
dispidGetBindingMethod: 68,
|
|
dispidReleaseBindingMethod: 69,
|
|
dispidGetBindingDataMethod: 70,
|
|
dispidSetBindingDataMethod: 71,
|
|
dispidAddRowsMethod: 72,
|
|
dispidClearAllRowsMethod: 73,
|
|
dispidGetAllBindingsMethod: 74,
|
|
dispidLoadSettingsMethod: 75,
|
|
dispidSaveSettingsMethod: 76,
|
|
dispidGetDocumentCopyMethod: 77,
|
|
dispidAddBindingFromNamedItemMethod: 78,
|
|
dispidAddColumnsMethod: 79,
|
|
dispidGetDocumentCopyChunkMethod: 80,
|
|
dispidReleaseDocumentCopyMethod: 81,
|
|
dispidNavigateToMethod: 82,
|
|
dispidGetActiveViewMethod: 83,
|
|
dispidGetDocumentThemeMethod: 84,
|
|
dispidGetOfficeThemeMethod: 85,
|
|
dispidGetFilePropertiesMethod: 86,
|
|
dispidClearFormatsMethod: 87,
|
|
dispidSetTableOptionsMethod: 88,
|
|
dispidSetFormatsMethod: 89,
|
|
dispidExecuteRichApiRequestMethod: 93,
|
|
dispidAppCommandInvocationCompletedMethod: 94,
|
|
dispidAddDataPartMethod: 128,
|
|
dispidGetDataPartByIdMethod: 129,
|
|
dispidGetDataPartsByNamespaceMethod: 130,
|
|
dispidGetDataPartXmlMethod: 131,
|
|
dispidGetDataPartNodesMethod: 132,
|
|
dispidDeleteDataPartMethod: 133,
|
|
dispidGetDataNodeValueMethod: 134,
|
|
dispidGetDataNodeXmlMethod: 135,
|
|
dispidGetDataNodesMethod: 136,
|
|
dispidSetDataNodeValueMethod: 137,
|
|
dispidSetDataNodeXmlMethod: 138,
|
|
dispidAddDataNamespaceMethod: 139,
|
|
dispidGetDataUriByPrefixMethod: 140,
|
|
dispidGetDataPrefixByUriMethod: 141,
|
|
dispidMethodMax: 141,
|
|
dispidGetSelectedTaskMethod: 110,
|
|
dispidGetSelectedResourceMethod: 111,
|
|
dispidGetTaskMethod: 112,
|
|
dispidGetResourceFieldMethod: 113,
|
|
dispidGetWSSUrlMethod: 114,
|
|
dispidGetTaskFieldMethod: 115,
|
|
dispidGetProjectFieldMethod: 116,
|
|
dispidGetSelectedViewMethod: 117,
|
|
dispidGetTaskByIndexMethod: 118,
|
|
dispidGetResourceByIndexMethod: 119,
|
|
dispidSetTaskFieldMethod: 120,
|
|
dispidSetResourceFieldMethod: 121,
|
|
dispidGetMaxTaskIndexMethod: 122,
|
|
dispidGetMaxResourceIndexMethod: 123
|
|
};
|
|
OSF.DDA.EventDispId = {
|
|
dispidEventMin: 0,
|
|
dispidInitializeEvent: 0,
|
|
dispidSettingsChangedEvent: 1,
|
|
dispidDocumentSelectionChangedEvent: 2,
|
|
dispidBindingSelectionChangedEvent: 3,
|
|
dispidBindingDataChangedEvent: 4,
|
|
dispidDocumentOpenEvent: 5,
|
|
dispidDocumentCloseEvent: 6,
|
|
dispidActiveViewChangedEvent: 7,
|
|
dispidDocumentThemeChangedEvent: 8,
|
|
dispidOfficeThemeChangedEvent: 9,
|
|
dispidActivationStatusChangedEvent: 32,
|
|
dispidAppCommandInvokedEvent: 39,
|
|
dispidTaskSelectionChangedEvent: 56,
|
|
dispidResourceSelectionChangedEvent: 57,
|
|
dispidViewSelectionChangedEvent: 58,
|
|
dispidDataNodeAddedEvent: 60,
|
|
dispidDataNodeReplacedEvent: 61,
|
|
dispidDataNodeDeletedEvent: 62,
|
|
dispidEventMax: 63
|
|
};
|
|
OSF.DDA.ErrorCodeManager = (function () {
|
|
var _errorMappings = {};
|
|
return {
|
|
getErrorArgs: function OSF_DDA_ErrorCodeManager$getErrorArgs(errorCode) {
|
|
return _errorMappings[errorCode] || _errorMappings[this.errorCodes.ooeInternalError];
|
|
},
|
|
addErrorMessage: function OSF_DDA_ErrorCodeManager$addErrorMessage(errorCode, errorNameMessage) {
|
|
_errorMappings[errorCode] = errorNameMessage;
|
|
},
|
|
errorCodes: {
|
|
ooeSuccess: 0,
|
|
ooeChunkResult: 1,
|
|
ooeCoercionTypeNotSupported: 1000,
|
|
ooeGetSelectionNotMatchDataType: 1001,
|
|
ooeCoercionTypeNotMatchBinding: 1002,
|
|
ooeInvalidGetRowColumnCounts: 1003,
|
|
ooeSelectionNotSupportCoercionType: 1004,
|
|
ooeInvalidGetStartRowColumn: 1005,
|
|
ooeNonUniformPartialGetNotSupported: 1006,
|
|
ooeGetDataIsTooLarge: 1008,
|
|
ooeFileTypeNotSupported: 1009,
|
|
ooeGetDataParametersConflict: 1010,
|
|
ooeInvalidGetColumns: 1011,
|
|
ooeInvalidGetRows: 1012,
|
|
ooeInvalidReadForBlankRow: 1013,
|
|
ooeUnsupportedDataObject: 2000,
|
|
ooeCannotWriteToSelection: 2001,
|
|
ooeDataNotMatchSelection: 2002,
|
|
ooeOverwriteWorksheetData: 2003,
|
|
ooeDataNotMatchBindingSize: 2004,
|
|
ooeInvalidSetStartRowColumn: 2005,
|
|
ooeInvalidDataFormat: 2006,
|
|
ooeDataNotMatchCoercionType: 2007,
|
|
ooeDataNotMatchBindingType: 2008,
|
|
ooeSetDataIsTooLarge: 2009,
|
|
ooeNonUniformPartialSetNotSupported: 2010,
|
|
ooeInvalidSetColumns: 2011,
|
|
ooeInvalidSetRows: 2012,
|
|
ooeSetDataParametersConflict: 2013,
|
|
ooeCellDataAmountBeyondLimits: 2014,
|
|
ooeSelectionCannotBound: 3000,
|
|
ooeBindingNotExist: 3002,
|
|
ooeBindingToMultipleSelection: 3003,
|
|
ooeInvalidSelectionForBindingType: 3004,
|
|
ooeOperationNotSupportedOnThisBindingType: 3005,
|
|
ooeNamedItemNotFound: 3006,
|
|
ooeMultipleNamedItemFound: 3007,
|
|
ooeInvalidNamedItemForBindingType: 3008,
|
|
ooeUnknownBindingType: 3009,
|
|
ooeOperationNotSupportedOnMatrixData: 3010,
|
|
ooeInvalidColumnsForBinding: 3011,
|
|
ooeSettingNameNotExist: 4000,
|
|
ooeSettingsCannotSave: 4001,
|
|
ooeSettingsAreStale: 4002,
|
|
ooeOperationNotSupported: 5000,
|
|
ooeInternalError: 5001,
|
|
ooeDocumentReadOnly: 5002,
|
|
ooeEventHandlerNotExist: 5003,
|
|
ooeInvalidApiCallInContext: 5004,
|
|
ooeShuttingDown: 5005,
|
|
ooeUnsupportedEnumeration: 5007,
|
|
ooeIndexOutOfRange: 5008,
|
|
ooeBrowserAPINotSupported: 5009,
|
|
ooeInvalidParam: 5010,
|
|
ooeRequestTimeout: 5011,
|
|
ooeTooManyIncompleteRequests: 5100,
|
|
ooeRequestTokenUnavailable: 5101,
|
|
ooeActivityLimitReached: 5102,
|
|
ooeCustomXmlNodeNotFound: 6000,
|
|
ooeCustomXmlError: 6100,
|
|
ooeCustomXmlExceedQuota: 6101,
|
|
ooeCustomXmlOutOfDate: 6102,
|
|
ooeNoCapability: 7000,
|
|
ooeCannotNavTo: 7001,
|
|
ooeSpecifiedIdNotExist: 7002,
|
|
ooeNavOutOfBound: 7004,
|
|
ooeElementMissing: 8000,
|
|
ooeProtectedError: 8001,
|
|
ooeInvalidCellsValue: 8010,
|
|
ooeInvalidTableOptionValue: 8011,
|
|
ooeInvalidFormatValue: 8012,
|
|
ooeRowIndexOutOfRange: 8020,
|
|
ooeColIndexOutOfRange: 8021,
|
|
ooeFormatValueOutOfRange: 8022,
|
|
ooeCellFormatAmountBeyondLimits: 8023,
|
|
ooeMemoryFileLimit: 11000,
|
|
ooeNetworkProblemRetrieveFile: 11001,
|
|
ooeInvalidSliceSize: 11002,
|
|
ooeInvalidCallback: 11101
|
|
},
|
|
initializeErrorMessages: function OSF_DDA_ErrorCodeManager$initializeErrorMessages(stringNS) {
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCoercionTypeNotSupported] = { name: stringNS.L_InvalidCoercion, message: stringNS.L_CoercionTypeNotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeGetSelectionNotMatchDataType] = { name: stringNS.L_DataReadError, message: stringNS.L_GetSelectionNotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCoercionTypeNotMatchBinding] = { name: stringNS.L_InvalidCoercion, message: stringNS.L_CoercionTypeNotMatchBinding };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidGetRowColumnCounts] = { name: stringNS.L_DataReadError, message: stringNS.L_InvalidGetRowColumnCounts };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSelectionNotSupportCoercionType] = { name: stringNS.L_DataReadError, message: stringNS.L_SelectionNotSupportCoercionType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidGetStartRowColumn] = { name: stringNS.L_DataReadError, message: stringNS.L_InvalidGetStartRowColumn };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNonUniformPartialGetNotSupported] = { name: stringNS.L_DataReadError, message: stringNS.L_NonUniformPartialGetNotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeGetDataIsTooLarge] = { name: stringNS.L_DataReadError, message: stringNS.L_GetDataIsTooLarge };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeFileTypeNotSupported] = { name: stringNS.L_DataReadError, message: stringNS.L_FileTypeNotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeGetDataParametersConflict] = { name: stringNS.L_DataReadError, message: stringNS.L_GetDataParametersConflict };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidGetColumns] = { name: stringNS.L_DataReadError, message: stringNS.L_InvalidGetColumns };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidGetRows] = { name: stringNS.L_DataReadError, message: stringNS.L_InvalidGetRows };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidReadForBlankRow] = { name: stringNS.L_DataReadError, message: stringNS.L_InvalidReadForBlankRow };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeUnsupportedDataObject] = { name: stringNS.L_DataWriteError, message: stringNS.L_UnsupportedDataObject };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCannotWriteToSelection] = { name: stringNS.L_DataWriteError, message: stringNS.L_CannotWriteToSelection };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeDataNotMatchSelection] = { name: stringNS.L_DataWriteError, message: stringNS.L_DataNotMatchSelection };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeOverwriteWorksheetData] = { name: stringNS.L_DataWriteError, message: stringNS.L_OverwriteWorksheetData };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeDataNotMatchBindingSize] = { name: stringNS.L_DataWriteError, message: stringNS.L_DataNotMatchBindingSize };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidSetStartRowColumn] = { name: stringNS.L_DataWriteError, message: stringNS.L_InvalidSetStartRowColumn };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidDataFormat] = { name: stringNS.L_InvalidFormat, message: stringNS.L_InvalidDataFormat };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeDataNotMatchCoercionType] = { name: stringNS.L_InvalidDataObject, message: stringNS.L_DataNotMatchCoercionType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeDataNotMatchBindingType] = { name: stringNS.L_InvalidDataObject, message: stringNS.L_DataNotMatchBindingType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSetDataIsTooLarge] = { name: stringNS.L_DataWriteError, message: stringNS.L_SetDataIsTooLarge };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNonUniformPartialSetNotSupported] = { name: stringNS.L_DataWriteError, message: stringNS.L_NonUniformPartialSetNotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidSetColumns] = { name: stringNS.L_DataWriteError, message: stringNS.L_InvalidSetColumns };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidSetRows] = { name: stringNS.L_DataWriteError, message: stringNS.L_InvalidSetRows };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSetDataParametersConflict] = { name: stringNS.L_DataWriteError, message: stringNS.L_SetDataParametersConflict };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSelectionCannotBound] = { name: stringNS.L_BindingCreationError, message: stringNS.L_SelectionCannotBound };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeBindingNotExist] = { name: stringNS.L_InvalidBindingError, message: stringNS.L_BindingNotExist };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeBindingToMultipleSelection] = { name: stringNS.L_BindingCreationError, message: stringNS.L_BindingToMultipleSelection };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidSelectionForBindingType] = { name: stringNS.L_BindingCreationError, message: stringNS.L_InvalidSelectionForBindingType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeOperationNotSupportedOnThisBindingType] = { name: stringNS.L_InvalidBindingOperation, message: stringNS.L_OperationNotSupportedOnThisBindingType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNamedItemNotFound] = { name: stringNS.L_BindingCreationError, message: stringNS.L_NamedItemNotFound };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeMultipleNamedItemFound] = { name: stringNS.L_BindingCreationError, message: stringNS.L_MultipleNamedItemFound };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidNamedItemForBindingType] = { name: stringNS.L_BindingCreationError, message: stringNS.L_InvalidNamedItemForBindingType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeUnknownBindingType] = { name: stringNS.L_InvalidBinding, message: stringNS.L_UnknownBindingType };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeOperationNotSupportedOnMatrixData] = { name: stringNS.L_InvalidBindingOperation, message: stringNS.L_OperationNotSupportedOnMatrixData };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidColumnsForBinding] = { name: stringNS.L_InvalidBinding, message: stringNS.L_InvalidColumnsForBinding };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSettingNameNotExist] = { name: stringNS.L_ReadSettingsError, message: stringNS.L_SettingNameNotExist };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSettingsCannotSave] = { name: stringNS.L_SaveSettingsError, message: stringNS.L_SettingsCannotSave };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSettingsAreStale] = { name: stringNS.L_SettingsStaleError, message: stringNS.L_SettingsAreStale };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeOperationNotSupported] = { name: stringNS.L_HostError, message: stringNS.L_OperationNotSupported };
|
|
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError] = { name: stringNS.L_InternalError, message: stringNS.L_InternalErrorDescription };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeDocumentReadOnly] = { name: stringNS.L_PermissionDenied, message: stringNS.L_DocumentReadOnly };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeEventHandlerNotExist] = { name: stringNS.L_EventRegistrationError, message: stringNS.L_EventHandlerNotExist };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidApiCallInContext] = { name: stringNS.L_InvalidAPICall, message: stringNS.L_InvalidApiCallInContext };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeShuttingDown] = { name: stringNS.L_ShuttingDown, message: stringNS.L_ShuttingDown };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeUnsupportedEnumeration] = { name: stringNS.L_UnsupportedEnumeration, message: stringNS.L_UnsupportedEnumerationMessage };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeIndexOutOfRange] = { name: stringNS.L_IndexOutOfRange, message: stringNS.L_IndexOutOfRange };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeBrowserAPINotSupported] = { name: stringNS.L_APINotSupported, message: stringNS.L_BrowserAPINotSupported };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeRequestTimeout] = { name: stringNS.L_APICallFailed, message: stringNS.L_RequestTimeout };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeTooManyIncompleteRequests] = { name: stringNS.L_APICallFailed, message: stringNS.L_TooManyIncompleteRequests };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeRequestTokenUnavailable] = { name: stringNS.L_APICallFailed, message: stringNS.L_RequestTokenUnavailable };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeActivityLimitReached] = { name: stringNS.L_APICallFailed, message: stringNS.L_ActivityLimitReached };
|
|
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCustomXmlNodeNotFound] = { name: stringNS.L_InvalidNode, message: stringNS.L_CustomXmlNodeNotFound };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCustomXmlError] = { name: stringNS.L_CustomXmlError, message: stringNS.L_CustomXmlError };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCustomXmlExceedQuota] = { name: stringNS.L_CustomXmlError, message: stringNS.L_CustomXmlError };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCustomXmlOutOfDate] = { name: stringNS.L_CustomXmlError, message: stringNS.L_CustomXmlError };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNoCapability] = { name: stringNS.L_PermissionDenied, message: stringNS.L_NoCapability };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCannotNavTo] = { name: stringNS.L_CannotNavigateTo, message: stringNS.L_CannotNavigateTo };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeSpecifiedIdNotExist] = { name: stringNS.L_SpecifiedIdNotExist, message: stringNS.L_SpecifiedIdNotExist };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNavOutOfBound] = { name: stringNS.L_NavOutOfBound, message: stringNS.L_NavOutOfBound };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCellDataAmountBeyondLimits] = { name: stringNS.L_DataWriteReminder, message: stringNS.L_CellDataAmountBeyondLimits };
|
|
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeElementMissing] = { name: stringNS.L_MissingParameter, message: stringNS.L_ElementMissing };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeProtectedError] = { name: stringNS.L_PermissionDenied, message: stringNS.L_NoCapability };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidCellsValue] = { name: stringNS.L_InvalidValue, message: stringNS.L_InvalidCellsValue };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidTableOptionValue] = { name: stringNS.L_InvalidValue, message: stringNS.L_InvalidTableOptionValue };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidFormatValue] = { name: stringNS.L_InvalidValue, message: stringNS.L_InvalidFormatValue };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeRowIndexOutOfRange] = { name: stringNS.L_OutOfRange, message: stringNS.L_RowIndexOutOfRange };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeColIndexOutOfRange] = { name: stringNS.L_OutOfRange, message: stringNS.L_ColIndexOutOfRange };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeFormatValueOutOfRange] = { name: stringNS.L_OutOfRange, message: stringNS.L_FormatValueOutOfRange };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeCellFormatAmountBeyondLimits] = { name: stringNS.L_FormattingReminder, message: stringNS.L_CellFormatAmountBeyondLimits };
|
|
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeMemoryFileLimit] = { name: stringNS.L_MemoryLimit, message: stringNS.L_CloseFileBeforeRetrieve };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeNetworkProblemRetrieveFile] = { name: stringNS.L_NetworkProblem, message: stringNS.L_NetworkProblemRetrieveFile };
|
|
_errorMappings[OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidSliceSize] = { name: stringNS.L_InvalidValue, message: stringNS.L_SliceSizeNotSupported };
|
|
}
|
|
};
|
|
})();
|
|
var OfficeExt;
|
|
(function (OfficeExt) {
|
|
(function (Requirement) {
|
|
var RequirementMatrix = (function () {
|
|
function RequirementMatrix(_setMap) {
|
|
this.isSetSupported = function _isSetSupported(name, minVersion) {
|
|
if (name == undefined) {
|
|
return false;
|
|
}
|
|
if (minVersion == undefined) {
|
|
minVersion = 0;
|
|
}
|
|
var setSupportArray = this._setMap;
|
|
var sets = setSupportArray._sets;
|
|
if (sets.hasOwnProperty(name.toLowerCase())) {
|
|
var setMaxVersion = sets[name.toLowerCase()];
|
|
return setMaxVersion > 0 && setMaxVersion >= minVersion;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
this._setMap = _setMap;
|
|
}
|
|
return RequirementMatrix;
|
|
})();
|
|
Requirement.RequirementMatrix = RequirementMatrix;
|
|
var DefaultSetRequirement = (function () {
|
|
function DefaultSetRequirement(setMap) {
|
|
this._sets = setMap;
|
|
}
|
|
return DefaultSetRequirement;
|
|
})();
|
|
Requirement.DefaultSetRequirement = DefaultSetRequirement;
|
|
|
|
var ExcelClientDefaultSetRequirement = (function (_super) {
|
|
__extends(ExcelClientDefaultSetRequirement, _super);
|
|
function ExcelClientDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"documentevents": 1.1,
|
|
"excelapi": 1.1,
|
|
"matrixbindings": 1.1,
|
|
"matrixcoercion": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1,
|
|
"textbindings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return ExcelClientDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.ExcelClientDefaultSetRequirement = ExcelClientDefaultSetRequirement;
|
|
var OutlookClientDefaultSetRequirement = (function (_super) {
|
|
__extends(OutlookClientDefaultSetRequirement, _super);
|
|
function OutlookClientDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"mailbox": 1.3
|
|
});
|
|
}
|
|
return OutlookClientDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.OutlookClientDefaultSetRequirement = OutlookClientDefaultSetRequirement;
|
|
var WordClientDefaultSetRequirement = (function (_super) {
|
|
__extends(WordClientDefaultSetRequirement, _super);
|
|
function WordClientDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"compressedfile": 1.1,
|
|
"customxmlparts": 1.1,
|
|
"documentevents": 1.1,
|
|
"file": 1.1,
|
|
"htmlcoercion": 1.1,
|
|
"matrixbindings": 1.1,
|
|
"matrixcoercion": 1.1,
|
|
"ooxmlcoercion": 1.1,
|
|
"pdffile": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1,
|
|
"textbindings": 1.1,
|
|
"textcoercion": 1.1,
|
|
"textfile": 1.1,
|
|
"wordapi": 1.1
|
|
});
|
|
}
|
|
return WordClientDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.WordClientDefaultSetRequirement = WordClientDefaultSetRequirement;
|
|
var PowerpointClientDefaultSetRequirement = (function (_super) {
|
|
__extends(PowerpointClientDefaultSetRequirement, _super);
|
|
function PowerpointClientDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"activeview": 1.1,
|
|
"compressedfile": 1.1,
|
|
"documentevents": 1.1,
|
|
"file": 1.1,
|
|
"pdffile": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return PowerpointClientDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.PowerpointClientDefaultSetRequirement = PowerpointClientDefaultSetRequirement;
|
|
var ProjectClientDefaultSetRequirement = (function (_super) {
|
|
__extends(ProjectClientDefaultSetRequirement, _super);
|
|
function ProjectClientDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"selection": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return ProjectClientDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.ProjectClientDefaultSetRequirement = ProjectClientDefaultSetRequirement;
|
|
var ExcelWebDefaultSetRequirement = (function (_super) {
|
|
__extends(ExcelWebDefaultSetRequirement, _super);
|
|
function ExcelWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"documentevents": 1.1,
|
|
"matrixbindings": 1.1,
|
|
"matrixcoercion": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1,
|
|
"textbindings": 1.1,
|
|
"textcoercion": 1.1,
|
|
"file": 1.1
|
|
});
|
|
}
|
|
return ExcelWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.ExcelWebDefaultSetRequirement = ExcelWebDefaultSetRequirement;
|
|
var WordWebDefaultSetRequirement = (function (_super) {
|
|
__extends(WordWebDefaultSetRequirement, _super);
|
|
function WordWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"customxmlparts": 1.1,
|
|
"documentevents": 1.1,
|
|
"file": 1.1,
|
|
"ooxmlcoercion": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return WordWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.WordWebDefaultSetRequirement = WordWebDefaultSetRequirement;
|
|
var PowerpointWebDefaultSetRequirement = (function (_super) {
|
|
__extends(PowerpointWebDefaultSetRequirement, _super);
|
|
function PowerpointWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"activeview": 1.1,
|
|
"settings": 1.1
|
|
});
|
|
}
|
|
return PowerpointWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.PowerpointWebDefaultSetRequirement = PowerpointWebDefaultSetRequirement;
|
|
var OutlookWebDefaultSetRequirement = (function (_super) {
|
|
__extends(OutlookWebDefaultSetRequirement, _super);
|
|
function OutlookWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"mailbox": 1.3
|
|
});
|
|
}
|
|
return OutlookWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.OutlookWebDefaultSetRequirement = OutlookWebDefaultSetRequirement;
|
|
var SwayWebDefaultSetRequirement = (function (_super) {
|
|
__extends(SwayWebDefaultSetRequirement, _super);
|
|
function SwayWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"activeview": 1.1,
|
|
"documentevents": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return SwayWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.SwayWebDefaultSetRequirement = SwayWebDefaultSetRequirement;
|
|
var AccessWebDefaultSetRequirement = (function (_super) {
|
|
__extends(AccessWebDefaultSetRequirement, _super);
|
|
function AccessWebDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"partialtablebindings": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1
|
|
});
|
|
}
|
|
return AccessWebDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.AccessWebDefaultSetRequirement = AccessWebDefaultSetRequirement;
|
|
var ExcelIOSDefaultSetRequirement = (function (_super) {
|
|
__extends(ExcelIOSDefaultSetRequirement, _super);
|
|
function ExcelIOSDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"documentevents": 1.1,
|
|
"matrixbindings": 1.1,
|
|
"matrixcoercion": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1,
|
|
"textbindings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return ExcelIOSDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.ExcelIOSDefaultSetRequirement = ExcelIOSDefaultSetRequirement;
|
|
var WordIOSDefaultSetRequirement = (function (_super) {
|
|
__extends(WordIOSDefaultSetRequirement, _super);
|
|
function WordIOSDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"bindingevents": 1.1,
|
|
"compressedfile": 1.1,
|
|
"customxmlparts": 1.1,
|
|
"documentevents": 1.1,
|
|
"file": 1.1,
|
|
"htmlcoercion": 1.1,
|
|
"matrixbindings": 1.1,
|
|
"matrixcoercion": 1.1,
|
|
"ooxmlcoercion": 1.1,
|
|
"pdffile": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"tablebindings": 1.1,
|
|
"tablecoercion": 1.1,
|
|
"textbindings": 1.1,
|
|
"textcoercion": 1.1,
|
|
"textfile": 1.1
|
|
});
|
|
}
|
|
return WordIOSDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.WordIOSDefaultSetRequirement = WordIOSDefaultSetRequirement;
|
|
var PowerpointIOSDefaultSetRequirement = (function (_super) {
|
|
__extends(PowerpointIOSDefaultSetRequirement, _super);
|
|
function PowerpointIOSDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"activeview": 1.1,
|
|
"compressedfile": 1.1,
|
|
"documentevents": 1.1,
|
|
"file": 1.1,
|
|
"pdffile": 1.1,
|
|
"selection": 1.1,
|
|
"settings": 1.1,
|
|
"textcoercion": 1.1
|
|
});
|
|
}
|
|
return PowerpointIOSDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.PowerpointIOSDefaultSetRequirement = PowerpointIOSDefaultSetRequirement;
|
|
var OutlookIOSDefaultSetRequirement = (function (_super) {
|
|
__extends(OutlookIOSDefaultSetRequirement, _super);
|
|
function OutlookIOSDefaultSetRequirement() {
|
|
_super.call(this, {
|
|
"mailbox": 1.1
|
|
});
|
|
}
|
|
return OutlookIOSDefaultSetRequirement;
|
|
})(DefaultSetRequirement);
|
|
Requirement.OutlookIOSDefaultSetRequirement = OutlookIOSDefaultSetRequirement;
|
|
|
|
var RequirementsMatrixFactory = (function () {
|
|
function RequirementsMatrixFactory() {
|
|
}
|
|
RequirementsMatrixFactory.initializeOsfDda = function () {
|
|
OSF.OUtil.setNamespace("Requirement", OSF.DDA);
|
|
};
|
|
|
|
RequirementsMatrixFactory.getDefaultRequirementMatrix = function (appContext) {
|
|
this.initializeDefaultSetMatrix();
|
|
var defaultRequirementMatrix = undefined;
|
|
if (appContext.get_requirementMatrix() != undefined && typeof (JSON) !== "undefined") {
|
|
var matrixItem = JSON.parse(appContext.get_requirementMatrix());
|
|
defaultRequirementMatrix = new RequirementMatrix(new DefaultSetRequirement(matrixItem));
|
|
} else {
|
|
var appMinorVersion = appContext.get_appMinorVersion();
|
|
var appMinorVersionString = "";
|
|
if (appMinorVersion < 10) {
|
|
appMinorVersionString = "0" + appMinorVersion;
|
|
} else {
|
|
appMinorVersionString = "" + appMinorVersion;
|
|
}
|
|
|
|
var appFullVersion = appContext.get_appVersion() + "." + appMinorVersionString;
|
|
var appLocator = appContext.get_appName() + "-" + appFullVersion;
|
|
if (RequirementsMatrixFactory.DefaultSetArrayMatrix != undefined && RequirementsMatrixFactory.DefaultSetArrayMatrix[appLocator] != undefined) {
|
|
defaultRequirementMatrix = new RequirementMatrix(RequirementsMatrixFactory.DefaultSetArrayMatrix[appLocator]);
|
|
} else {
|
|
defaultRequirementMatrix = new RequirementMatrix(new DefaultSetRequirement({}));
|
|
}
|
|
}
|
|
return defaultRequirementMatrix;
|
|
};
|
|
RequirementsMatrixFactory.initializeDefaultSetMatrix = function () {
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Excel_RCLIENT_1600] = new ExcelClientDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Word_RCLIENT_1600] = new WordClientDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.PowerPoint_RCLIENT_1600] = new PowerpointClientDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Outlook_RCLIENT_1600] = new OutlookClientDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Excel_WAC_1600] = new ExcelWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Word_WAC_1600] = new WordWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Outlook_WAC_1600] = new OutlookWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Outlook_WAC_1601] = new OutlookWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Project_RCLIENT_1600] = new ProjectClientDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Access_WAC_1600] = new AccessWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.PowerPoint_WAC_1600] = new PowerpointWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Excel_IOS_1600] = new ExcelIOSDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.SWAY_WAC_1600] = new SwayWebDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Word_IOS_1600] = new WordIOSDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.PowerPoint_IOS_1600] = new PowerpointIOSDefaultSetRequirement();
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix[RequirementsMatrixFactory.Outlook_IOS_1600] = new OutlookIOSDefaultSetRequirement();
|
|
};
|
|
RequirementsMatrixFactory.Excel_RCLIENT_1600 = "1-16.00";
|
|
RequirementsMatrixFactory.Word_RCLIENT_1600 = "2-16.00";
|
|
RequirementsMatrixFactory.PowerPoint_RCLIENT_1600 = "4-16.00";
|
|
RequirementsMatrixFactory.Outlook_RCLIENT_1600 = "8-16.00";
|
|
RequirementsMatrixFactory.Excel_WAC_1600 = "16-16.00";
|
|
RequirementsMatrixFactory.Word_WAC_1600 = "32-16.00";
|
|
RequirementsMatrixFactory.Outlook_WAC_1600 = "64-16.00";
|
|
RequirementsMatrixFactory.Outlook_WAC_1601 = "64-16.01";
|
|
RequirementsMatrixFactory.Project_RCLIENT_1600 = "128-16.00";
|
|
RequirementsMatrixFactory.Access_WAC_1600 = "256-16.00";
|
|
RequirementsMatrixFactory.PowerPoint_WAC_1600 = "512-16.00";
|
|
RequirementsMatrixFactory.Excel_IOS_1600 = "1024-16.01";
|
|
RequirementsMatrixFactory.SWAY_WAC_1600 = "2048-16.00";
|
|
RequirementsMatrixFactory.Word_IOS_1600 = "4096-16.00";
|
|
RequirementsMatrixFactory.PowerPoint_IOS_1600 = "8192-16.00";
|
|
|
|
RequirementsMatrixFactory.Outlook_IOS_1600 = "65536-16.00";
|
|
|
|
RequirementsMatrixFactory.DefaultSetArrayMatrix = {};
|
|
return RequirementsMatrixFactory;
|
|
})();
|
|
Requirement.RequirementsMatrixFactory = RequirementsMatrixFactory;
|
|
})(OfficeExt.Requirement || (OfficeExt.Requirement = {}));
|
|
var Requirement = OfficeExt.Requirement;
|
|
})(OfficeExt || (OfficeExt = {}));
|
|
|
|
OfficeExt.Requirement.RequirementsMatrixFactory.initializeOsfDda();
|
|
|
|
Microsoft.Office.WebExtension.ApplicationMode = {
|
|
WebEditor: "webEditor",
|
|
WebViewer: "webViewer",
|
|
Client: "client"
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.DocumentMode = {
|
|
ReadOnly: "readOnly",
|
|
ReadWrite: "readWrite"
|
|
};
|
|
|
|
OSF.NamespaceManager = (function OSF_NamespaceManager() {
|
|
var _userOffice;
|
|
var _useShortcut = false;
|
|
return {
|
|
enableShortcut: function OSF_NamespaceManager$enableShortcut() {
|
|
if (!_useShortcut) {
|
|
if (window.Office) {
|
|
_userOffice = window.Office;
|
|
} else {
|
|
OSF.OUtil.setNamespace("Office", window);
|
|
}
|
|
window.Office = Microsoft.Office.WebExtension;
|
|
_useShortcut = true;
|
|
}
|
|
},
|
|
disableShortcut: function OSF_NamespaceManager$disableShortcut() {
|
|
if (_useShortcut) {
|
|
if (_userOffice) {
|
|
window.Office = _userOffice;
|
|
} else {
|
|
OSF.OUtil.unsetNamespace("Office", window);
|
|
}
|
|
_useShortcut = false;
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
OSF.NamespaceManager.enableShortcut();
|
|
|
|
Microsoft.Office.WebExtension.useShortNamespace = function Microsoft_Office_WebExtension_useShortNamespace(useShortcut) {
|
|
if (useShortcut) {
|
|
OSF.NamespaceManager.enableShortcut();
|
|
} else {
|
|
OSF.NamespaceManager.disableShortcut();
|
|
}
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.select = function Microsoft_Office_WebExtension_select(str, errorCallback) {
|
|
var promise;
|
|
if (str && typeof str == "string") {
|
|
var index = str.indexOf("#");
|
|
if (index != -1) {
|
|
var op = str.substring(0, index);
|
|
var target = str.substring(index + 1);
|
|
switch (op) {
|
|
case "binding":
|
|
case "bindings":
|
|
if (target) {
|
|
promise = new OSF.DDA.BindingPromise(target);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!promise) {
|
|
if (errorCallback) {
|
|
var callbackType = typeof errorCallback;
|
|
if (callbackType == "function") {
|
|
var callArgs = {};
|
|
callArgs[Microsoft.Office.WebExtension.Parameters.Callback] = errorCallback;
|
|
OSF.DDA.issueAsyncResult(callArgs, OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidApiCallInContext, OSF.DDA.ErrorCodeManager.getErrorArgs(OSF.DDA.ErrorCodeManager.errorCodes.ooeInvalidApiCallInContext));
|
|
} else {
|
|
throw OSF.OUtil.formatString(Strings.OfficeOM.L_CallbackNotAFunction, callbackType);
|
|
}
|
|
}
|
|
} else {
|
|
promise.onFail = errorCallback;
|
|
return promise;
|
|
}
|
|
};
|
|
|
|
OSF.DDA.Context = function OSF_DDA_Context(officeAppContext, document, license, appOM, getOfficeTheme) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"contentLanguage": {
|
|
value: officeAppContext.get_dataLocale()
|
|
},
|
|
"displayLanguage": {
|
|
value: officeAppContext.get_appUILocale()
|
|
},
|
|
"touchEnabled": {
|
|
value: officeAppContext.get_touchEnabled()
|
|
},
|
|
"commerceAllowed": {
|
|
value: officeAppContext.get_commerceAllowed()
|
|
}
|
|
});
|
|
if (document) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "document", {
|
|
value: document
|
|
});
|
|
}
|
|
if (license) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "license", {
|
|
value: license
|
|
});
|
|
}
|
|
if (appOM) {
|
|
var displayName = appOM.displayName || "appOM";
|
|
delete appOM.displayName;
|
|
OSF.OUtil.defineEnumerableProperty(this, displayName, {
|
|
value: appOM
|
|
});
|
|
}
|
|
if (getOfficeTheme) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "officeTheme", {
|
|
get: function () {
|
|
return getOfficeTheme();
|
|
}
|
|
});
|
|
}
|
|
var requirements = OfficeExt.Requirement.RequirementsMatrixFactory.getDefaultRequirementMatrix(officeAppContext);
|
|
|
|
OSF.OUtil.defineEnumerableProperty(this, "requirements", {
|
|
value: requirements
|
|
});
|
|
};
|
|
|
|
OSF.DDA.OutlookContext = function OSF_DDA_OutlookContext(appContext, settings, license, appOM, getOfficeTheme) {
|
|
OSF.DDA.OutlookContext.uber.constructor.call(this, appContext, null, license, appOM, getOfficeTheme);
|
|
if (settings) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "roamingSettings", {
|
|
value: settings
|
|
});
|
|
}
|
|
};
|
|
|
|
OSF.OUtil.extend(OSF.DDA.OutlookContext, OSF.DDA.Context);
|
|
|
|
OSF.DDA.OutlookAppOm = function OSF_DDA_OutlookAppOm(appContext, window, appReady) {
|
|
};
|
|
|
|
OSF.DDA.Document = function OSF_DDA_Document(officeAppContext, settings) {
|
|
var mode;
|
|
switch (officeAppContext.get_clientMode()) {
|
|
case OSF.ClientMode.ReadOnly:
|
|
mode = Microsoft.Office.WebExtension.DocumentMode.ReadOnly;
|
|
break;
|
|
case OSF.ClientMode.ReadWrite:
|
|
mode = Microsoft.Office.WebExtension.DocumentMode.ReadWrite;
|
|
break;
|
|
}
|
|
;
|
|
if (settings) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "settings", {
|
|
value: settings
|
|
});
|
|
}
|
|
;
|
|
OSF.OUtil.defineMutableProperties(this, {
|
|
"mode": {
|
|
value: mode
|
|
},
|
|
"url": {
|
|
value: officeAppContext.get_docUrl()
|
|
}
|
|
});
|
|
};
|
|
|
|
OSF.DDA.JsomDocument = function OSF_DDA_JsomDocument(officeAppContext, bindingFacade, settings) {
|
|
OSF.DDA.JsomDocument.uber.constructor.call(this, officeAppContext, settings);
|
|
|
|
if (bindingFacade) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "bindings", {
|
|
get: function OSF_DDA_Document$GetBindings() {
|
|
return bindingFacade;
|
|
}
|
|
});
|
|
}
|
|
var am = OSF.DDA.AsyncMethodNames;
|
|
OSF.DDA.DispIdHost.addAsyncMethods(this, [
|
|
am.GetSelectedDataAsync,
|
|
am.SetSelectedDataAsync
|
|
]);
|
|
OSF.DDA.DispIdHost.addEventSupport(this, new OSF.EventDispatch([Microsoft.Office.WebExtension.EventType.DocumentSelectionChanged]));
|
|
};
|
|
|
|
OSF.OUtil.extend(OSF.DDA.JsomDocument, OSF.DDA.Document);
|
|
|
|
OSF.OUtil.defineEnumerableProperty(Microsoft.Office.WebExtension, "context", {
|
|
get: function Microsoft_Office_WebExtension$GetContext() {
|
|
var context;
|
|
if (OSF && OSF._OfficeAppFactory) {
|
|
context = OSF._OfficeAppFactory.getContext();
|
|
}
|
|
return context;
|
|
}
|
|
});
|
|
|
|
OSF.DDA.License = function OSF_DDA_License(eToken) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "value", {
|
|
value: eToken
|
|
});
|
|
};
|
|
|
|
OSF.OUtil.setNamespace("AsyncResultEnum", OSF.DDA);
|
|
OSF.DDA.AsyncResultEnum.Properties = {
|
|
Context: "Context",
|
|
Value: "Value",
|
|
Status: "Status",
|
|
Error: "Error"
|
|
};
|
|
Microsoft.Office.WebExtension.AsyncResultStatus = {
|
|
Succeeded: "succeeded",
|
|
Failed: "failed"
|
|
};
|
|
|
|
OSF.DDA.AsyncResultEnum.ErrorCode = {
|
|
Success: 0,
|
|
Failed: 1
|
|
};
|
|
OSF.DDA.AsyncResultEnum.ErrorProperties = {
|
|
Name: "Name",
|
|
Message: "Message",
|
|
Code: "Code"
|
|
};
|
|
OSF.DDA.AsyncMethodNames = {};
|
|
OSF.DDA.AsyncMethodNames.addNames = function (methodNames) {
|
|
for (var entry in methodNames) {
|
|
var am = {};
|
|
OSF.OUtil.defineEnumerableProperties(am, {
|
|
"id": {
|
|
value: entry
|
|
},
|
|
"displayName": {
|
|
value: methodNames[entry]
|
|
}
|
|
});
|
|
OSF.DDA.AsyncMethodNames[entry] = am;
|
|
}
|
|
};
|
|
OSF.DDA.AsyncMethodCall = function OSF_DDA_AsyncMethodCall(requiredParameters, supportedOptions, privateStateCallbacks, onSucceeded, onFailed, checkCallArgs, displayName) {
|
|
var requiredCount = requiredParameters.length;
|
|
var getInvalidParameterString = OSF.OUtil.delayExecutionAndCache(function () {
|
|
return OSF.OUtil.formatString(Strings.OfficeOM.L_InvalidParameters, displayName);
|
|
});
|
|
|
|
function OSF_DAA_AsyncMethodCall$VerifyArguments(params, args) {
|
|
for (var name in params) {
|
|
var param = params[name];
|
|
var arg = args[name];
|
|
|
|
if (param["enum"]) {
|
|
switch (typeof arg) {
|
|
case "string":
|
|
if (OSF.OUtil.listContainsValue(param["enum"], arg)) {
|
|
break;
|
|
}
|
|
|
|
case "undefined":
|
|
throw OSF.DDA.ErrorCodeManager.errorCodes.ooeUnsupportedEnumeration;
|
|
break;
|
|
default:
|
|
throw getInvalidParameterString();
|
|
}
|
|
}
|
|
|
|
if (param["types"]) {
|
|
if (!OSF.OUtil.listContainsValue(param["types"], typeof arg)) {
|
|
throw getInvalidParameterString();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
;
|
|
function OSF_DAA_AsyncMethodCall$ExtractRequiredArguments(userArgs, caller, stateInfo) {
|
|
if (userArgs.length < requiredCount) {
|
|
throw OsfMsAjaxFactory.msAjaxError.parameterCount(Strings.OfficeOM.L_MissingRequiredArguments);
|
|
}
|
|
|
|
var requiredArgs = [];
|
|
var index;
|
|
for (index = 0; index < requiredCount; index++) {
|
|
requiredArgs.push(userArgs[index]);
|
|
}
|
|
OSF_DAA_AsyncMethodCall$VerifyArguments(requiredParameters, requiredArgs);
|
|
var ret = {};
|
|
for (index = 0; index < requiredCount; index++) {
|
|
var param = requiredParameters[index];
|
|
var arg = requiredArgs[index];
|
|
if (param.verify) {
|
|
var isValid = param.verify(arg, caller, stateInfo);
|
|
if (!isValid) {
|
|
throw getInvalidParameterString();
|
|
}
|
|
}
|
|
ret[param.name] = arg;
|
|
}
|
|
return ret;
|
|
}
|
|
;
|
|
function OSF_DAA_AsyncMethodCall$ExtractOptions(userArgs, requiredArgs, caller, stateInfo) {
|
|
if (userArgs.length > requiredCount + 2) {
|
|
throw OsfMsAjaxFactory.msAjaxError.parameterCount(Strings.OfficeOM.L_TooManyArguments);
|
|
}
|
|
var options, parameterCallback;
|
|
|
|
for (var i = userArgs.length - 1; i >= requiredCount; i--) {
|
|
var argument = userArgs[i];
|
|
switch (typeof argument) {
|
|
case "object":
|
|
if (options) {
|
|
throw OsfMsAjaxFactory.msAjaxError.parameterCount(Strings.OfficeOM.L_TooManyOptionalObjects);
|
|
} else {
|
|
options = argument;
|
|
}
|
|
break;
|
|
case "function":
|
|
if (parameterCallback) {
|
|
throw OsfMsAjaxFactory.msAjaxError.parameterCount(Strings.OfficeOM.L_TooManyOptionalFunction);
|
|
} else {
|
|
parameterCallback = argument;
|
|
}
|
|
break;
|
|
default:
|
|
throw OsfMsAjaxFactory.msAjaxError.argument(Strings.OfficeOM.L_InValidOptionalArgument);
|
|
break;
|
|
}
|
|
}
|
|
options = options || {};
|
|
|
|
for (var optionName in supportedOptions) {
|
|
if (!OSF.OUtil.listContainsKey(options, optionName)) {
|
|
var value = undefined;
|
|
var option = supportedOptions[optionName];
|
|
|
|
if (option.calculate && requiredArgs) {
|
|
value = option.calculate(requiredArgs, caller, stateInfo);
|
|
}
|
|
|
|
if (!value && option.defaultValue !== undefined) {
|
|
value = option.defaultValue;
|
|
}
|
|
options[optionName] = value;
|
|
}
|
|
}
|
|
|
|
if (parameterCallback) {
|
|
if (options[Microsoft.Office.WebExtension.Parameters.Callback]) {
|
|
throw Strings.OfficeOM.L_RedundantCallbackSpecification;
|
|
} else {
|
|
options[Microsoft.Office.WebExtension.Parameters.Callback] = parameterCallback;
|
|
}
|
|
}
|
|
OSF_DAA_AsyncMethodCall$VerifyArguments(supportedOptions, options);
|
|
return options;
|
|
}
|
|
;
|
|
this.verifyAndExtractCall = function OSF_DAA_AsyncMethodCall$VerifyAndExtractCall(userArgs, caller, stateInfo) {
|
|
var required = OSF_DAA_AsyncMethodCall$ExtractRequiredArguments(userArgs, caller, stateInfo);
|
|
var options = OSF_DAA_AsyncMethodCall$ExtractOptions(userArgs, required, caller, stateInfo);
|
|
var callArgs = {};
|
|
for (var r in required) {
|
|
callArgs[r] = required[r];
|
|
}
|
|
for (var o in options) {
|
|
callArgs[o] = options[o];
|
|
}
|
|
for (var s in privateStateCallbacks) {
|
|
callArgs[s] = privateStateCallbacks[s](caller, stateInfo);
|
|
}
|
|
if (checkCallArgs) {
|
|
callArgs = checkCallArgs(callArgs, caller, stateInfo);
|
|
}
|
|
return callArgs;
|
|
};
|
|
this.processResponse = function OSF_DAA_AsyncMethodCall$ProcessResponse(status, response, caller, callArgs) {
|
|
var payload;
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
if (onSucceeded) {
|
|
payload = onSucceeded(response, caller, callArgs);
|
|
} else {
|
|
payload = response;
|
|
}
|
|
} else {
|
|
if (onFailed) {
|
|
payload = onFailed(status, response);
|
|
} else {
|
|
payload = OSF.DDA.ErrorCodeManager.getErrorArgs(status);
|
|
}
|
|
}
|
|
return payload;
|
|
};
|
|
|
|
this.getCallArgs = function (suppliedArgs) {
|
|
var options, parameterCallback;
|
|
|
|
for (var i = suppliedArgs.length - 1; i >= requiredCount; i--) {
|
|
var argument = suppliedArgs[i];
|
|
switch (typeof argument) {
|
|
case "object":
|
|
options = argument;
|
|
break;
|
|
case "function":
|
|
parameterCallback = argument;
|
|
break;
|
|
}
|
|
}
|
|
options = options || {};
|
|
if (parameterCallback) {
|
|
options[Microsoft.Office.WebExtension.Parameters.Callback] = parameterCallback;
|
|
}
|
|
return options;
|
|
};
|
|
};
|
|
OSF.DDA.AsyncMethodCallFactory = (function () {
|
|
function createObject(properties) {
|
|
var obj = null;
|
|
if (properties) {
|
|
obj = {};
|
|
var len = properties.length;
|
|
for (var i = 0; i < len; i++) {
|
|
obj[properties[i].name] = properties[i].value;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
return {
|
|
manufacture: function (params) {
|
|
var supportedOptions = params.supportedOptions ? createObject(params.supportedOptions) : [];
|
|
var privateStateCallbacks = params.privateStateCallbacks ? createObject(params.privateStateCallbacks) : [];
|
|
|
|
return new OSF.DDA.AsyncMethodCall(params.requiredArguments || [], supportedOptions, privateStateCallbacks, params.onSucceeded, params.onFailed, params.checkCallArgs, params.method.displayName);
|
|
}
|
|
};
|
|
})();
|
|
OSF.DDA.AsyncMethodCalls = {};
|
|
OSF.DDA.AsyncMethodCalls.define = function (callDefinition) {
|
|
OSF.DDA.AsyncMethodCalls[callDefinition.method.id] = OSF.DDA.AsyncMethodCallFactory.manufacture(callDefinition);
|
|
};
|
|
|
|
OSF.DDA.Error = function OSF_DDA_Error(name, message, code) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"name": {
|
|
value: name
|
|
},
|
|
"message": {
|
|
value: message
|
|
},
|
|
"code": {
|
|
value: code
|
|
}
|
|
});
|
|
};
|
|
|
|
OSF.DDA.AsyncResult = function OSF_DDA_AsyncResult(initArgs, errorArgs) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"value": {
|
|
value: initArgs[OSF.DDA.AsyncResultEnum.Properties.Value]
|
|
},
|
|
"status": {
|
|
value: errorArgs ? Microsoft.Office.WebExtension.AsyncResultStatus.Failed : Microsoft.Office.WebExtension.AsyncResultStatus.Succeeded
|
|
}
|
|
});
|
|
if (initArgs[OSF.DDA.AsyncResultEnum.Properties.Context]) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "asyncContext", {
|
|
value: initArgs[OSF.DDA.AsyncResultEnum.Properties.Context]
|
|
});
|
|
}
|
|
if (errorArgs) {
|
|
OSF.OUtil.defineEnumerableProperty(this, "error", {
|
|
value: new OSF.DDA.Error(errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Name], errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Message], errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Code])
|
|
});
|
|
}
|
|
};
|
|
OSF.DDA.issueAsyncResult = function OSF_DDA$IssueAsyncResult(callArgs, status, payload) {
|
|
var callback = callArgs[Microsoft.Office.WebExtension.Parameters.Callback];
|
|
if (callback) {
|
|
var asyncInitArgs = {};
|
|
asyncInitArgs[OSF.DDA.AsyncResultEnum.Properties.Context] = callArgs[Microsoft.Office.WebExtension.Parameters.AsyncContext];
|
|
var errorArgs;
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
asyncInitArgs[OSF.DDA.AsyncResultEnum.Properties.Value] = payload;
|
|
} else {
|
|
errorArgs = {};
|
|
payload = payload || OSF.DDA.ErrorCodeManager.getErrorArgs(OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError);
|
|
errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Code] = status || OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError;
|
|
errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Name] = payload.name || payload;
|
|
errorArgs[OSF.DDA.AsyncResultEnum.ErrorProperties.Message] = payload.message || payload;
|
|
}
|
|
callback(new OSF.DDA.AsyncResult(asyncInitArgs, errorArgs));
|
|
}
|
|
};
|
|
OSF.DDA.ListType = (function () {
|
|
var listTypes = {};
|
|
return {
|
|
setListType: function OSF_DDA_ListType$AddListType(t, prop) {
|
|
listTypes[t] = prop;
|
|
},
|
|
isListType: function OSF_DDA_ListType$IsListType(t) {
|
|
return OSF.OUtil.listContainsKey(listTypes, t);
|
|
},
|
|
getDescriptor: function OSF_DDA_ListType$getDescriptor(t) {
|
|
return listTypes[t];
|
|
}
|
|
};
|
|
})();
|
|
OSF.DDA.HostParameterMap = function (specialProcessor, mappings) {
|
|
var toHostMap = "toHost";
|
|
var fromHostMap = "fromHost";
|
|
|
|
var self = "self";
|
|
var dynamicTypes = {};
|
|
dynamicTypes[Microsoft.Office.WebExtension.Parameters.Data] = {
|
|
toHost: function (data) {
|
|
if (data != null && data.rows !== undefined) {
|
|
var tableData = {};
|
|
tableData[OSF.DDA.TableDataProperties.TableRows] = data.rows;
|
|
tableData[OSF.DDA.TableDataProperties.TableHeaders] = data.headers;
|
|
data = tableData;
|
|
}
|
|
return data;
|
|
},
|
|
fromHost: function (args) {
|
|
return args;
|
|
}
|
|
};
|
|
|
|
dynamicTypes[Microsoft.Office.WebExtension.Parameters.SampleData] = dynamicTypes[Microsoft.Office.WebExtension.Parameters.Data];
|
|
|
|
function mapValues(preimageSet, mapping) {
|
|
var ret = preimageSet ? {} : undefined;
|
|
for (var entry in preimageSet) {
|
|
var preimage = preimageSet[entry];
|
|
var image;
|
|
if (OSF.DDA.ListType.isListType(entry)) {
|
|
image = [];
|
|
for (var subEntry in preimage) {
|
|
image.push(mapValues(preimage[subEntry], mapping));
|
|
}
|
|
} else if (OSF.OUtil.listContainsKey(dynamicTypes, entry)) {
|
|
image = dynamicTypes[entry][mapping](preimage);
|
|
} else if (mapping == fromHostMap && specialProcessor.preserveNesting(entry)) {
|
|
image = mapValues(preimage, mapping);
|
|
} else {
|
|
var maps = mappings[entry];
|
|
if (maps) {
|
|
var map = maps[mapping];
|
|
if (map) {
|
|
image = map[preimage];
|
|
if (image === undefined) {
|
|
image = preimage;
|
|
}
|
|
}
|
|
} else {
|
|
image = preimage;
|
|
}
|
|
}
|
|
ret[entry] = image;
|
|
}
|
|
return ret;
|
|
}
|
|
;
|
|
|
|
function generateArguments(imageSet, parameters) {
|
|
var ret;
|
|
for (var param in parameters) {
|
|
var arg;
|
|
if (specialProcessor.isComplexType(param)) {
|
|
arg = generateArguments(imageSet, mappings[param][toHostMap]);
|
|
} else {
|
|
arg = imageSet[param];
|
|
}
|
|
if (arg != undefined) {
|
|
if (!ret) {
|
|
ret = {};
|
|
}
|
|
var index = parameters[param];
|
|
|
|
if (index == self) {
|
|
index = param;
|
|
}
|
|
ret[index] = specialProcessor.pack(param, arg);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
;
|
|
|
|
function extractArguments(source, parameters, extracted) {
|
|
if (!extracted) {
|
|
extracted = {};
|
|
}
|
|
for (var param in parameters) {
|
|
var index = parameters[param];
|
|
var value;
|
|
|
|
if (index == self) {
|
|
value = source;
|
|
} else {
|
|
value = source[index];
|
|
}
|
|
if (value === null || value === undefined) {
|
|
extracted[param] = undefined;
|
|
} else {
|
|
value = specialProcessor.unpack(param, value);
|
|
var map;
|
|
if (specialProcessor.isComplexType(param)) {
|
|
map = mappings[param][fromHostMap];
|
|
|
|
if (specialProcessor.preserveNesting(param)) {
|
|
extracted[param] = extractArguments(value, map);
|
|
} else {
|
|
extractArguments(value, map, extracted);
|
|
}
|
|
} else {
|
|
if (OSF.DDA.ListType.isListType(param)) {
|
|
map = {};
|
|
var entryDescriptor = OSF.DDA.ListType.getDescriptor(param);
|
|
map[entryDescriptor] = self;
|
|
for (var item in value) {
|
|
value[item] = extractArguments(value[item], map);
|
|
}
|
|
}
|
|
extracted[param] = value;
|
|
}
|
|
}
|
|
}
|
|
return extracted;
|
|
}
|
|
;
|
|
function applyMap(mapName, preimage, mapping) {
|
|
var parameters = mappings[mapName][mapping];
|
|
var image;
|
|
if (mapping == "toHost") {
|
|
var imageSet = mapValues(preimage, mapping);
|
|
image = generateArguments(imageSet, parameters);
|
|
} else if (mapping == "fromHost") {
|
|
var argumentSet = extractArguments(preimage, parameters);
|
|
image = mapValues(argumentSet, mapping);
|
|
}
|
|
return image;
|
|
}
|
|
;
|
|
if (!mappings) {
|
|
mappings = {};
|
|
}
|
|
this.addMapping = function (mapName, description) {
|
|
var toHost, fromHost;
|
|
if (description.map) {
|
|
toHost = description.map;
|
|
fromHost = {};
|
|
for (var preimage in toHost) {
|
|
var image = toHost[preimage];
|
|
|
|
if (image == self) {
|
|
image = preimage;
|
|
}
|
|
fromHost[image] = preimage;
|
|
}
|
|
} else {
|
|
toHost = description.toHost;
|
|
fromHost = description.fromHost;
|
|
}
|
|
var pair = mappings[mapName];
|
|
if (pair) {
|
|
var currMap = pair[toHostMap];
|
|
for (var th in currMap)
|
|
toHost[th] = currMap[th];
|
|
currMap = pair[fromHostMap];
|
|
for (var fh in currMap)
|
|
fromHost[fh] = currMap[fh];
|
|
} else {
|
|
pair = mappings[mapName] = {};
|
|
}
|
|
pair[toHostMap] = toHost;
|
|
pair[fromHostMap] = fromHost;
|
|
};
|
|
this.toHost = function (mapName, preimage) {
|
|
return applyMap(mapName, preimage, toHostMap);
|
|
};
|
|
this.fromHost = function (mapName, image) {
|
|
return applyMap(mapName, image, fromHostMap);
|
|
};
|
|
this.self = self;
|
|
this.addComplexType = function (ct) {
|
|
specialProcessor.addComplexType(ct);
|
|
};
|
|
this.getDynamicType = function (dt) {
|
|
return specialProcessor.getDynamicType(dt);
|
|
};
|
|
this.setDynamicType = function (dt, handler) {
|
|
specialProcessor.setDynamicType(dt, handler);
|
|
};
|
|
this.dynamicTypes = dynamicTypes;
|
|
this.doMapValues = function (preimageSet, mapping) {
|
|
return mapValues(preimageSet, mapping);
|
|
};
|
|
};
|
|
OSF.DDA.SpecialProcessor = function (complexTypes, dynamicTypes) {
|
|
this.addComplexType = function OSF_DDA_SpecialProcessor$addComplexType(ct) {
|
|
complexTypes.push(ct);
|
|
};
|
|
this.getDynamicType = function OSF_DDA_SpecialProcessor$getDynamicType(dt) {
|
|
return dynamicTypes[dt];
|
|
};
|
|
this.setDynamicType = function OSF_DDA_SpecialProcessor$setDynamicType(dt, handler) {
|
|
dynamicTypes[dt] = handler;
|
|
};
|
|
this.isComplexType = function OSF_DDA_SpecialProcessor$isComplexType(t) {
|
|
return OSF.OUtil.listContainsValue(complexTypes, t);
|
|
};
|
|
this.isDynamicType = function OSF_DDA_SpecialProcessor$isDynamicType(p) {
|
|
return OSF.OUtil.listContainsKey(dynamicTypes, p);
|
|
};
|
|
this.preserveNesting = function OSF_DDA_SpecialProcessor$preserveNesting(p) {
|
|
var pn = [];
|
|
if (OSF.DDA.PropertyDescriptors)
|
|
pn.push(OSF.DDA.PropertyDescriptors.Subset);
|
|
if (OSF.DDA.DataNodeEventProperties) {
|
|
pn = pn.concat([
|
|
OSF.DDA.DataNodeEventProperties.OldNode,
|
|
OSF.DDA.DataNodeEventProperties.NewNode,
|
|
OSF.DDA.DataNodeEventProperties.NextSiblingNode
|
|
]);
|
|
}
|
|
return OSF.OUtil.listContainsValue(pn, p);
|
|
};
|
|
this.pack = function OSF_DDA_SpecialProcessor$pack(param, arg) {
|
|
var value;
|
|
|
|
if (this.isDynamicType(param)) {
|
|
value = dynamicTypes[param].toHost(arg);
|
|
} else {
|
|
value = arg;
|
|
}
|
|
return value;
|
|
};
|
|
this.unpack = function OSF_DDA_SpecialProcessor$unpack(param, arg) {
|
|
var value;
|
|
|
|
if (this.isDynamicType(param)) {
|
|
value = dynamicTypes[param].fromHost(arg);
|
|
} else {
|
|
value = arg;
|
|
}
|
|
return value;
|
|
};
|
|
};
|
|
OSF.DDA.getDecoratedParameterMap = function (specialProcessor, initialDefs) {
|
|
var parameterMap = new OSF.DDA.HostParameterMap(specialProcessor);
|
|
var self = parameterMap.self;
|
|
function createObject(properties) {
|
|
var obj = null;
|
|
if (properties) {
|
|
obj = {};
|
|
var len = properties.length;
|
|
for (var i = 0; i < len; i++) {
|
|
obj[properties[i].name] = properties[i].value;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
parameterMap.define = function define(definition) {
|
|
var args = {};
|
|
var toHost = createObject(definition.toHost);
|
|
|
|
if (definition.invertible) {
|
|
args.map = toHost;
|
|
} else if (definition.canonical) {
|
|
args.toHost = args.fromHost = toHost;
|
|
} else {
|
|
args.toHost = toHost;
|
|
args.fromHost = createObject(definition.fromHost);
|
|
}
|
|
parameterMap.addMapping(definition.type, args);
|
|
if (definition.isComplexType)
|
|
parameterMap.addComplexType(definition.type);
|
|
};
|
|
for (var id in initialDefs)
|
|
parameterMap.define(initialDefs[id]);
|
|
return parameterMap;
|
|
};
|
|
OSF.OUtil.setNamespace("DispIdHost", OSF.DDA);
|
|
OSF.DDA.DispIdHost.Methods = {
|
|
InvokeMethod: "invokeMethod",
|
|
AddEventHandler: "addEventHandler",
|
|
RemoveEventHandler: "removeEventHandler"
|
|
};
|
|
OSF.DDA.DispIdHost.Delegates = {
|
|
ExecuteAsync: "executeAsync",
|
|
RegisterEventAsync: "registerEventAsync",
|
|
UnregisterEventAsync: "unregisterEventAsync",
|
|
ParameterMap: "parameterMap"
|
|
};
|
|
OSF.DDA.DispIdHost.Facade = function OSF_DDA_DispIdHost_Facade(getDelegateMethods, parameterMap) {
|
|
var dispIdMap = {};
|
|
var jsom = OSF.DDA.AsyncMethodNames;
|
|
var did = OSF.DDA.MethodDispId;
|
|
|
|
var methodMap = {
|
|
"GoToByIdAsync": did.dispidNavigateToMethod,
|
|
"GetSelectedDataAsync": did.dispidGetSelectedDataMethod,
|
|
"SetSelectedDataAsync": did.dispidSetSelectedDataMethod,
|
|
"GetDocumentCopyChunkAsync": did.dispidGetDocumentCopyChunkMethod,
|
|
"ReleaseDocumentCopyAsync": did.dispidReleaseDocumentCopyMethod,
|
|
"GetDocumentCopyAsync": did.dispidGetDocumentCopyMethod,
|
|
"AddFromSelectionAsync": did.dispidAddBindingFromSelectionMethod,
|
|
"AddFromPromptAsync": did.dispidAddBindingFromPromptMethod,
|
|
"AddFromNamedItemAsync": did.dispidAddBindingFromNamedItemMethod,
|
|
"GetAllAsync": did.dispidGetAllBindingsMethod,
|
|
"GetByIdAsync": did.dispidGetBindingMethod,
|
|
"ReleaseByIdAsync": did.dispidReleaseBindingMethod,
|
|
"GetDataAsync": did.dispidGetBindingDataMethod,
|
|
"SetDataAsync": did.dispidSetBindingDataMethod,
|
|
"AddRowsAsync": did.dispidAddRowsMethod,
|
|
"AddColumnsAsync": did.dispidAddColumnsMethod,
|
|
"DeleteAllDataValuesAsync": did.dispidClearAllRowsMethod,
|
|
"RefreshAsync": did.dispidLoadSettingsMethod,
|
|
"SaveAsync": did.dispidSaveSettingsMethod,
|
|
"GetActiveViewAsync": did.dispidGetActiveViewMethod,
|
|
"GetFilePropertiesAsync": did.dispidGetFilePropertiesMethod,
|
|
"GetOfficeThemeAsync": did.dispidGetOfficeThemeMethod,
|
|
"GetDocumentThemeAsync": did.dispidGetDocumentThemeMethod,
|
|
"ClearFormatsAsync": did.dispidClearFormatsMethod,
|
|
"SetTableOptionsAsync": did.dispidSetTableOptionsMethod,
|
|
"SetFormatsAsync": did.dispidSetFormatsMethod,
|
|
"ExecuteRichApiRequestAsync": did.dispidExecuteRichApiRequestMethod,
|
|
"AppCommandInvocationCompletedAsync": did.dispidAppCommandInvocationCompletedMethod,
|
|
"AddDataPartAsync": did.dispidAddDataPartMethod,
|
|
"GetDataPartByIdAsync": did.dispidGetDataPartByIdMethod,
|
|
"GetDataPartsByNameSpaceAsync": did.dispidGetDataPartsByNamespaceMethod,
|
|
"GetPartXmlAsync": did.dispidGetDataPartXmlMethod,
|
|
"GetPartNodesAsync": did.dispidGetDataPartNodesMethod,
|
|
"DeleteDataPartAsync": did.dispidDeleteDataPartMethod,
|
|
"GetNodeValueAsync": did.dispidGetDataNodeValueMethod,
|
|
"GetNodeXmlAsync": did.dispidGetDataNodeXmlMethod,
|
|
"GetRelativeNodesAsync": did.dispidGetDataNodesMethod,
|
|
"SetNodeValueAsync": did.dispidSetDataNodeValueMethod,
|
|
"SetNodeXmlAsync": did.dispidSetDataNodeXmlMethod,
|
|
"AddDataPartNamespaceAsync": did.dispidAddDataNamespaceMethod,
|
|
"GetDataPartNamespaceAsync": did.dispidGetDataUriByPrefixMethod,
|
|
"GetDataPartPrefixAsync": did.dispidGetDataPrefixByUriMethod,
|
|
"GetSelectedTask": did.dispidGetSelectedTaskMethod,
|
|
"GetTask": did.dispidGetTaskMethod,
|
|
"GetWSSUrl": did.dispidGetWSSUrlMethod,
|
|
"GetTaskField": did.dispidGetTaskFieldMethod,
|
|
"GetSelectedResource": did.dispidGetSelectedResourceMethod,
|
|
"GetResourceField": did.dispidGetResourceFieldMethod,
|
|
"GetProjectField": did.dispidGetProjectFieldMethod,
|
|
"GetSelectedView": did.dispidGetSelectedViewMethod,
|
|
"GetTaskByIndex": did.dispidGetTaskByIndexMethod,
|
|
"GetResourceByIndex": did.dispidGetResourceByIndexMethod,
|
|
"SetTaskField": did.dispidSetTaskFieldMethod,
|
|
"SetResourceField": did.dispidSetResourceFieldMethod,
|
|
"GetMaxTaskIndex": did.dispidGetMaxTaskIndexMethod,
|
|
"GetMaxResourceIndex": did.dispidGetMaxResourceIndexMethod
|
|
};
|
|
for (var method in methodMap) {
|
|
if (jsom[method]) {
|
|
dispIdMap[jsom[method].id] = methodMap[method];
|
|
}
|
|
}
|
|
|
|
jsom = Microsoft.Office.WebExtension.EventType;
|
|
did = OSF.DDA.EventDispId;
|
|
var eventMap = {
|
|
"SettingsChanged": did.dispidSettingsChangedEvent,
|
|
"DocumentSelectionChanged": did.dispidDocumentSelectionChangedEvent,
|
|
"BindingSelectionChanged": did.dispidBindingSelectionChangedEvent,
|
|
"BindingDataChanged": did.dispidBindingDataChangedEvent,
|
|
"ActiveViewChanged": did.dispidActiveViewChangedEvent,
|
|
"OfficeThemeChanged": did.dispidOfficeThemeChangedEvent,
|
|
"DocumentThemeChanged": did.dispidDocumentThemeChangedEvent,
|
|
"AppCommandInvoked": did.dispidAppCommandInvokedEvent,
|
|
"TaskSelectionChanged": did.dispidTaskSelectionChangedEvent,
|
|
"ResourceSelectionChanged": did.dispidResourceSelectionChangedEvent,
|
|
"ViewSelectionChanged": did.dispidViewSelectionChangedEvent,
|
|
"DataNodeInserted": did.dispidDataNodeAddedEvent,
|
|
"DataNodeReplaced": did.dispidDataNodeReplacedEvent,
|
|
"DataNodeDeleted": did.dispidDataNodeDeletedEvent
|
|
};
|
|
|
|
for (var event in eventMap) {
|
|
if (jsom[event]) {
|
|
dispIdMap[jsom[event]] = eventMap[event];
|
|
}
|
|
}
|
|
function onException(ex, asyncMethodCall, suppliedArgs, callArgs) {
|
|
if (typeof ex == "number") {
|
|
if (!callArgs) {
|
|
callArgs = asyncMethodCall.getCallArgs(suppliedArgs);
|
|
}
|
|
OSF.DDA.issueAsyncResult(callArgs, ex, OSF.DDA.ErrorCodeManager.getErrorArgs(ex));
|
|
} else {
|
|
throw ex;
|
|
}
|
|
}
|
|
;
|
|
this[OSF.DDA.DispIdHost.Methods.InvokeMethod] = function OSF_DDA_DispIdHost_Facade$InvokeMethod(method, suppliedArguments, caller, privateState) {
|
|
var callArgs;
|
|
try {
|
|
var methodName = method.id;
|
|
var asyncMethodCall = OSF.DDA.AsyncMethodCalls[methodName];
|
|
callArgs = asyncMethodCall.verifyAndExtractCall(suppliedArguments, caller, privateState);
|
|
var dispId = dispIdMap[methodName];
|
|
var delegate = getDelegateMethods(methodName);
|
|
var hostCallArgs;
|
|
if (parameterMap.toHost) {
|
|
hostCallArgs = parameterMap.toHost(dispId, callArgs);
|
|
} else {
|
|
hostCallArgs = callArgs;
|
|
}
|
|
delegate[OSF.DDA.DispIdHost.Delegates.ExecuteAsync]({
|
|
"dispId": dispId,
|
|
"hostCallArgs": hostCallArgs,
|
|
"onCalling": function OSF_DDA_DispIdFacade$Execute_onCalling() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.IssueCall);
|
|
},
|
|
"onReceiving": function OSF_DDA_DispIdFacade$Execute_onReceiving() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.ReceiveResponse);
|
|
},
|
|
"onComplete": function (status, hostResponseArgs) {
|
|
var responseArgs;
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
if (parameterMap.fromHost) {
|
|
responseArgs = parameterMap.fromHost(dispId, hostResponseArgs);
|
|
} else {
|
|
responseArgs = hostResponseArgs;
|
|
}
|
|
} else {
|
|
responseArgs = hostResponseArgs;
|
|
}
|
|
var payload = asyncMethodCall.processResponse(status, responseArgs, caller, callArgs);
|
|
OSF.DDA.issueAsyncResult(callArgs, status, payload);
|
|
}
|
|
});
|
|
} catch (ex) {
|
|
onException(ex, asyncMethodCall, suppliedArguments, callArgs);
|
|
}
|
|
};
|
|
this[OSF.DDA.DispIdHost.Methods.AddEventHandler] = function OSF_DDA_DispIdHost_Facade$AddEventHandler(suppliedArguments, eventDispatch, caller) {
|
|
var callArgs;
|
|
var eventType, handler;
|
|
function onEnsureRegistration(status) {
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
var added = eventDispatch.addEventHandler(eventType, handler);
|
|
if (!added) {
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeEventHandlerAdditionFailed;
|
|
}
|
|
}
|
|
var error;
|
|
if (status != OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
error = OSF.DDA.ErrorCodeManager.getErrorArgs(status);
|
|
}
|
|
OSF.DDA.issueAsyncResult(callArgs, status, error);
|
|
}
|
|
try {
|
|
var asyncMethodCall = OSF.DDA.AsyncMethodCalls[OSF.DDA.AsyncMethodNames.AddHandlerAsync.id];
|
|
callArgs = asyncMethodCall.verifyAndExtractCall(suppliedArguments, caller, eventDispatch);
|
|
|
|
eventType = callArgs[Microsoft.Office.WebExtension.Parameters.EventType];
|
|
handler = callArgs[Microsoft.Office.WebExtension.Parameters.Handler];
|
|
if (eventDispatch.getEventHandlerCount(eventType) == 0) {
|
|
var dispId = dispIdMap[eventType];
|
|
var invoker = getDelegateMethods(eventType)[OSF.DDA.DispIdHost.Delegates.RegisterEventAsync];
|
|
invoker({
|
|
"eventType": eventType,
|
|
"dispId": dispId,
|
|
"targetId": caller.id || "",
|
|
"onCalling": function OSF_DDA_DispIdFacade$Execute_onCalling() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.IssueCall);
|
|
},
|
|
"onReceiving": function OSF_DDA_DispIdFacade$Execute_onReceiving() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.ReceiveResponse);
|
|
},
|
|
"onComplete": onEnsureRegistration,
|
|
"onEvent": function handleEvent(hostArgs) {
|
|
var args = parameterMap.fromHost(dispId, hostArgs);
|
|
eventDispatch.fireEvent(OSF.DDA.OMFactory.manufactureEventArgs(eventType, caller, args));
|
|
}
|
|
});
|
|
} else {
|
|
onEnsureRegistration(OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess);
|
|
}
|
|
} catch (ex) {
|
|
onException(ex, asyncMethodCall, suppliedArguments, callArgs);
|
|
}
|
|
};
|
|
this[OSF.DDA.DispIdHost.Methods.RemoveEventHandler] = function OSF_DDA_DispIdHost_Facade$RemoveEventHandler(suppliedArguments, eventDispatch, caller) {
|
|
var callArgs;
|
|
var eventType, handler;
|
|
function onEnsureRegistration(status) {
|
|
var error;
|
|
if (status != OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
error = OSF.DDA.ErrorCodeManager.getErrorArgs(status);
|
|
}
|
|
OSF.DDA.issueAsyncResult(callArgs, status, error);
|
|
}
|
|
try {
|
|
var asyncMethodCall = OSF.DDA.AsyncMethodCalls[OSF.DDA.AsyncMethodNames.RemoveHandlerAsync.id];
|
|
callArgs = asyncMethodCall.verifyAndExtractCall(suppliedArguments, caller, eventDispatch);
|
|
|
|
eventType = callArgs[Microsoft.Office.WebExtension.Parameters.EventType];
|
|
handler = callArgs[Microsoft.Office.WebExtension.Parameters.Handler];
|
|
var status, removeSuccess;
|
|
|
|
if (handler === null) {
|
|
removeSuccess = eventDispatch.clearEventHandlers(eventType);
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess;
|
|
} else {
|
|
removeSuccess = eventDispatch.removeEventHandler(eventType, handler);
|
|
status = removeSuccess ? OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess : OSF.DDA.ErrorCodeManager.errorCodes.ooeEventHandlerNotExist;
|
|
}
|
|
if (removeSuccess && eventDispatch.getEventHandlerCount(eventType) == 0) {
|
|
var dispId = dispIdMap[eventType];
|
|
var invoker = getDelegateMethods(eventType)[OSF.DDA.DispIdHost.Delegates.UnregisterEventAsync];
|
|
invoker({
|
|
"eventType": eventType,
|
|
"dispId": dispId,
|
|
"targetId": caller.id || "",
|
|
"onCalling": function OSF_DDA_DispIdFacade$Execute_onCalling() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.IssueCall);
|
|
},
|
|
"onReceiving": function OSF_DDA_DispIdFacade$Execute_onReceiving() {
|
|
OSF.OUtil.writeProfilerMark(OSF.HostCallPerfMarker.ReceiveResponse);
|
|
},
|
|
"onComplete": onEnsureRegistration
|
|
});
|
|
} else {
|
|
onEnsureRegistration(status);
|
|
}
|
|
} catch (ex) {
|
|
onException(ex, asyncMethodCall, suppliedArguments, callArgs);
|
|
}
|
|
};
|
|
};
|
|
OSF.DDA.DispIdHost.addAsyncMethods = function OSF_DDA_DispIdHost$AddAsyncMethods(target, asyncMethodNames, privateState) {
|
|
for (var entry in asyncMethodNames) {
|
|
var method = asyncMethodNames[entry];
|
|
var name = method.displayName;
|
|
if (!target[name]) {
|
|
OSF.OUtil.defineEnumerableProperty(target, name, {
|
|
value: (function (asyncMethod) {
|
|
return function () {
|
|
var invokeMethod = OSF._OfficeAppFactory.getHostFacade()[OSF.DDA.DispIdHost.Methods.InvokeMethod];
|
|
invokeMethod(asyncMethod, arguments, target, privateState);
|
|
};
|
|
})(method)
|
|
});
|
|
}
|
|
}
|
|
};
|
|
OSF.DDA.DispIdHost.addEventSupport = function OSF_DDA_DispIdHost$AddEventSupport(target, eventDispatch) {
|
|
var add = OSF.DDA.AsyncMethodNames.AddHandlerAsync.displayName;
|
|
var remove = OSF.DDA.AsyncMethodNames.RemoveHandlerAsync.displayName;
|
|
if (!target[add]) {
|
|
OSF.OUtil.defineEnumerableProperty(target, add, {
|
|
value: function () {
|
|
var addEventHandler = OSF._OfficeAppFactory.getHostFacade()[OSF.DDA.DispIdHost.Methods.AddEventHandler];
|
|
addEventHandler(arguments, eventDispatch, target);
|
|
}
|
|
});
|
|
}
|
|
if (!target[remove]) {
|
|
OSF.OUtil.defineEnumerableProperty(target, remove, {
|
|
value: function () {
|
|
var removeEventHandler = OSF._OfficeAppFactory.getHostFacade()[OSF.DDA.DispIdHost.Methods.RemoveEventHandler];
|
|
removeEventHandler(arguments, eventDispatch, target);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
if (!OsfMsAjaxFactory.isMsAjaxLoaded()) {
|
|
if (!(OSF._OfficeAppFactory && OSF._OfficeAppFactory && OSF._OfficeAppFactory.getLoadScriptHelper && OSF._OfficeAppFactory.getLoadScriptHelper().isScriptLoading(OSF.ConstantNames.MicrosoftAjaxId))) {
|
|
var msAjaxCDNPath = (window.location.protocol.toLowerCase() === 'https:' ? 'https:' : 'http:') + '//ajax.aspnetcdn.com/ajax/3.5/MicrosoftAjax.js';
|
|
OsfMsAjaxFactory.loadMsAjaxFull(function OSF$loadMSAjaxCallback() {
|
|
if (!OsfMsAjaxFactory.isMsAjaxLoaded()) {
|
|
throw 'Not able to load MicrosoftAjax.js.';
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
OSF.OUtil.setNamespace("SafeArray", OSF.DDA);
|
|
OSF.DDA.SafeArray.Response = {
|
|
Status: 0,
|
|
Payload: 1
|
|
};
|
|
|
|
OSF.DDA.SafeArray.UniqueArguments = {
|
|
Offset: "offset",
|
|
Run: "run",
|
|
BindingSpecificData: "bindingSpecificData",
|
|
MergedCellGuid: "{66e7831f-81b2-42e2-823c-89e872d541b3}"
|
|
};
|
|
OSF.OUtil.setNamespace("Delegate", OSF.DDA.SafeArray);
|
|
OSF.DDA.SafeArray.Delegate._onException = function OSF_DDA_SafeArray_Delegate$OnException(ex, args) {
|
|
var status;
|
|
var number = ex.number;
|
|
if (number) {
|
|
switch (number) {
|
|
case -2146828218:
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeNoCapability;
|
|
break;
|
|
case -2146827850:
|
|
default:
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError;
|
|
break;
|
|
}
|
|
}
|
|
if (args.onComplete) {
|
|
args.onComplete(status || OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError);
|
|
}
|
|
};
|
|
OSF.DDA.SafeArray.Delegate.SpecialProcessor = function OSF_DDA_SafeArray_Delegate_SpecialProcessor() {
|
|
function _2DVBArrayToJaggedArray(vbArr) {
|
|
var ret;
|
|
try {
|
|
var rows = vbArr.ubound(1);
|
|
var cols = vbArr.ubound(2);
|
|
vbArr = vbArr.toArray();
|
|
if (rows == 1 && cols == 1) {
|
|
ret = [vbArr];
|
|
} else {
|
|
ret = [];
|
|
for (var row = 0; row < rows; row++) {
|
|
var rowArr = [];
|
|
for (var col = 0; col < cols; col++) {
|
|
var datum = vbArr[row * cols + col];
|
|
if (datum != OSF.DDA.SafeArray.UniqueArguments.MergedCellGuid) {
|
|
rowArr.push(datum);
|
|
}
|
|
}
|
|
if (rowArr.length > 0) {
|
|
ret.push(rowArr);
|
|
}
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
}
|
|
return ret;
|
|
}
|
|
var complexTypes = [];
|
|
var dynamicTypes = {};
|
|
|
|
dynamicTypes[Microsoft.Office.WebExtension.Parameters.Data] = (function () {
|
|
var tableRows = 0;
|
|
var tableHeaders = 1;
|
|
return {
|
|
toHost: function OSF_DDA_SafeArray_Delegate_SpecialProcessor_Data$toHost(data) {
|
|
if (typeof data != "string" && data[OSF.DDA.TableDataProperties.TableRows] !== undefined) {
|
|
var tableData = [];
|
|
tableData[tableRows] = data[OSF.DDA.TableDataProperties.TableRows];
|
|
tableData[tableHeaders] = data[OSF.DDA.TableDataProperties.TableHeaders];
|
|
data = tableData;
|
|
}
|
|
return data;
|
|
},
|
|
fromHost: function OSF_DDA_SafeArray_Delegate_SpecialProcessor_Data$fromHost(hostArgs) {
|
|
var ret;
|
|
|
|
if (hostArgs.toArray) {
|
|
var dimensions = hostArgs.dimensions();
|
|
if (dimensions === 2) {
|
|
ret = _2DVBArrayToJaggedArray(hostArgs);
|
|
} else {
|
|
var array = hostArgs.toArray();
|
|
if (array.length === 2 && ((array[0] != null && array[0].toArray) || (array[1] != null && array[1].toArray))) {
|
|
ret = {};
|
|
ret[OSF.DDA.TableDataProperties.TableRows] = _2DVBArrayToJaggedArray(array[tableRows]);
|
|
ret[OSF.DDA.TableDataProperties.TableHeaders] = _2DVBArrayToJaggedArray(array[tableHeaders]);
|
|
} else {
|
|
ret = array;
|
|
}
|
|
}
|
|
} else {
|
|
ret = hostArgs;
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
})();
|
|
OSF.DDA.SafeArray.Delegate.SpecialProcessor.uber.constructor.call(this, complexTypes, dynamicTypes);
|
|
|
|
this.unpack = function OSF_DDA_SafeArray_Delegate_SpecialProcessor$unpack(param, arg) {
|
|
var value;
|
|
|
|
if (this.isComplexType(param) || OSF.DDA.ListType.isListType(param)) {
|
|
var toArraySupported = (arg || typeof arg === "unknown") && arg.toArray;
|
|
value = toArraySupported ? arg.toArray() : arg || {};
|
|
} else if (this.isDynamicType(param)) {
|
|
value = dynamicTypes[param].fromHost(arg);
|
|
} else {
|
|
value = arg;
|
|
}
|
|
return value;
|
|
};
|
|
};
|
|
|
|
OSF.OUtil.extend(OSF.DDA.SafeArray.Delegate.SpecialProcessor, OSF.DDA.SpecialProcessor);
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap = OSF.DDA.getDecoratedParameterMap(new OSF.DDA.SafeArray.Delegate.SpecialProcessor(), [
|
|
{
|
|
type: Microsoft.Office.WebExtension.Parameters.ValueFormat,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.ValueFormat.Unformatted, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.ValueFormat.Formatted, value: 1 }
|
|
]
|
|
},
|
|
{
|
|
type: Microsoft.Office.WebExtension.Parameters.FilterType,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.FilterType.All, value: 0 }
|
|
]
|
|
}
|
|
]);
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.PropertyDescriptors.AsyncResultStatus,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.AsyncResultStatus.Succeeded, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.AsyncResultStatus.Failed, value: 1 }
|
|
]
|
|
});
|
|
OSF.DDA.SafeArray.Delegate.executeAsync = function OSF_DDA_SafeArray_Delegate$ExecuteAsync(args) {
|
|
function toArray(args) {
|
|
var arrArgs = args;
|
|
if (OSF.OUtil.isArray(args)) {
|
|
var len = arrArgs.length;
|
|
for (var i = 0; i < len; i++) {
|
|
arrArgs[i] = toArray(arrArgs[i]);
|
|
}
|
|
} else if (OSF.OUtil.isDate(args)) {
|
|
arrArgs = args.getVarDate();
|
|
} else if (typeof args === "object" && !OSF.OUtil.isArray(args)) {
|
|
arrArgs = [];
|
|
for (var index in args) {
|
|
if (!OSF.OUtil.isFunction(args[index])) {
|
|
arrArgs[index] = toArray(args[index]);
|
|
}
|
|
}
|
|
}
|
|
return arrArgs;
|
|
}
|
|
function fromSafeArray(value) {
|
|
var ret = value;
|
|
if (value != null && value.toArray) {
|
|
var arrayResult = value.toArray();
|
|
for (var i = 0; i < arrayResult.length; i++) {
|
|
arrayResult[i] = fromSafeArray(arrayResult[i]);
|
|
}
|
|
ret = arrayResult;
|
|
}
|
|
return ret;
|
|
}
|
|
try {
|
|
if (args.onCalling) {
|
|
args.onCalling();
|
|
}
|
|
var startTime = (new Date()).getTime();
|
|
OSF.ClientHostController.execute(args.dispId, toArray(args.hostCallArgs), function OSF_DDA_SafeArrayFacade$Execute_OnResponse(hostResponseArgs) {
|
|
var result = hostResponseArgs.toArray();
|
|
var status = result[OSF.DDA.SafeArray.Response.Status];
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeChunkResult) {
|
|
var payload = result[OSF.DDA.SafeArray.Response.Payload];
|
|
payload = fromSafeArray(payload);
|
|
if (payload != null) {
|
|
if (!args._chunkResultData) {
|
|
args._chunkResultData = new Array();
|
|
}
|
|
|
|
args._chunkResultData[payload[0]] = payload[1];
|
|
}
|
|
} else {
|
|
if (args.onReceiving) {
|
|
args.onReceiving();
|
|
}
|
|
if (args.onComplete) {
|
|
var payload;
|
|
if (status == OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess) {
|
|
if (result.length > 2) {
|
|
payload = [];
|
|
for (var i = 1; i < result.length; i++)
|
|
payload[i - 1] = result[i];
|
|
} else {
|
|
payload = result[OSF.DDA.SafeArray.Response.Payload];
|
|
}
|
|
if (args._chunkResultData) {
|
|
payload = fromSafeArray(payload);
|
|
if (payload != null) {
|
|
var expectedChunkCount = payload[payload.length - 1];
|
|
if (args._chunkResultData.length == expectedChunkCount) {
|
|
payload[payload.length - 1] = args._chunkResultData;
|
|
} else {
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
payload = result[OSF.DDA.SafeArray.Response.Payload];
|
|
}
|
|
args.onComplete(status, payload);
|
|
}
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.onMethodDone(args.dispId, args.hostCallArgs, Math.abs((new Date()).getTime() - startTime), status);
|
|
}
|
|
}
|
|
});
|
|
} catch (ex) {
|
|
OSF.DDA.SafeArray.Delegate._onException(ex, args);
|
|
}
|
|
};
|
|
OSF.DDA.SafeArray.Delegate._getOnAfterRegisterEvent = function OSF_DDA_SafeArrayDelegate$GetOnAfterRegisterEvent(register, args) {
|
|
var startTime = (new Date()).getTime();
|
|
return function OSF_DDA_SafeArrayDelegate$OnAfterRegisterEvent(hostResponseArgs) {
|
|
if (args.onReceiving) {
|
|
args.onReceiving();
|
|
}
|
|
var status = hostResponseArgs.toArray ? hostResponseArgs.toArray()[OSF.DDA.SafeArray.Response.Status] : hostResponseArgs;
|
|
if (args.onComplete) {
|
|
args.onComplete(status);
|
|
}
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.onRegisterDone(register, args.dispId, Math.abs((new Date()).getTime() - startTime), status);
|
|
}
|
|
};
|
|
};
|
|
OSF.DDA.SafeArray.Delegate.registerEventAsync = function OSF_DDA_SafeArray_Delegate$RegisterEventAsync(args) {
|
|
if (args.onCalling) {
|
|
args.onCalling();
|
|
}
|
|
var callback = OSF.DDA.SafeArray.Delegate._getOnAfterRegisterEvent(true, args);
|
|
try {
|
|
OSF.ClientHostController.registerEvent(args.dispId, args.targetId, function OSF_DDA_SafeArrayDelegate$RegisterEventAsync_OnEvent(eventDispId, payload) {
|
|
if (args.onEvent) {
|
|
args.onEvent(payload);
|
|
}
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.onEventDone(args.dispId);
|
|
}
|
|
}, callback);
|
|
} catch (ex) {
|
|
OSF.DDA.SafeArray.Delegate._onException(ex, args);
|
|
}
|
|
};
|
|
OSF.DDA.SafeArray.Delegate.unregisterEventAsync = function OSF_DDA_SafeArray_Delegate$UnregisterEventAsync(args) {
|
|
if (args.onCalling) {
|
|
args.onCalling();
|
|
}
|
|
var callback = OSF.DDA.SafeArray.Delegate._getOnAfterRegisterEvent(false, args);
|
|
try {
|
|
OSF.ClientHostController.unregisterEvent(args.dispId, args.targetId, callback);
|
|
} catch (ex) {
|
|
OSF.DDA.SafeArray.Delegate._onException(ex, args);
|
|
}
|
|
};
|
|
|
|
OSF.ClientMode = {
|
|
ReadWrite: 0,
|
|
ReadOnly: 1
|
|
};
|
|
OSF.DDA.RichInitializationReason = {
|
|
1: Microsoft.Office.WebExtension.InitializationReason.Inserted,
|
|
2: Microsoft.Office.WebExtension.InitializationReason.DocumentOpened
|
|
};
|
|
|
|
OSF.InitializationHelper = function OSF_InitializationHelper(hostInfo, webAppState, context, settings, hostFacade) {
|
|
this._hostInfo = hostInfo;
|
|
this._webAppState = webAppState;
|
|
this._context = context;
|
|
this._settings = settings;
|
|
this._hostFacade = hostFacade;
|
|
this._initializeSettings = this.initializeSettings;
|
|
};
|
|
OSF.InitializationHelper.prototype.deserializeSettings = function OSF_InitializationHelper$deserializeSettings(serializedSettings, refreshSupported) {
|
|
var settings;
|
|
var osfSessionStorage = OSF.OUtil.getSessionStorage();
|
|
if (osfSessionStorage) {
|
|
var storageSettings = osfSessionStorage.getItem(OSF._OfficeAppFactory.getCachedSessionSettingsKey());
|
|
if (storageSettings) {
|
|
serializedSettings = (typeof (JSON) !== "undefined") ? JSON.parse(storageSettings) : OsfMsAjaxFactory.msAjaxSerializer.deserialize(storageSettings, true);
|
|
} else {
|
|
storageSettings = (typeof (JSON) !== "undefined") ? JSON.stringify(serializedSettings) : OsfMsAjaxFactory.msAjaxSerializer.serialize(serializedSettings);
|
|
osfSessionStorage.setItem(OSF._OfficeAppFactory.getCachedSessionSettingsKey(), storageSettings);
|
|
}
|
|
}
|
|
var deserializedSettings = OSF.DDA.SettingsManager.deserializeSettings(serializedSettings);
|
|
if (refreshSupported) {
|
|
settings = new OSF.DDA.RefreshableSettings(deserializedSettings);
|
|
} else {
|
|
settings = new OSF.DDA.Settings(deserializedSettings);
|
|
}
|
|
return settings;
|
|
};
|
|
OSF.InitializationHelper.prototype.setAgaveHostCommunication = function OSF_InitializationHelper$setAgaveHostCommunication() {
|
|
};
|
|
OSF.InitializationHelper.prototype.prepareRightBeforeWebExtensionInitialize = function OSF_InitializationHelper$prepareRightBeforeWebExtensionInitialize(appContext) {
|
|
this.prepareApiSurface(appContext);
|
|
Microsoft.Office.WebExtension.initialize(this.getInitializationReason(appContext));
|
|
};
|
|
OSF.InitializationHelper.prototype.prepareApiSurface = function OSF_InitializationHelper$prepareApiSurfaceAndInitialize(appContext) {
|
|
var license = new OSF.DDA.License(appContext.get_eToken());
|
|
var getOfficeThemeHandler = (OSF.DDA.OfficeTheme && OSF.DDA.OfficeTheme.getOfficeTheme) ? OSF.DDA.OfficeTheme.getOfficeTheme : null;
|
|
OSF._OfficeAppFactory.setContext(new OSF.DDA.Context(appContext, appContext.doc, license, null, getOfficeThemeHandler));
|
|
var getDelegateMethods, parameterMap;
|
|
getDelegateMethods = OSF.DDA.DispIdHost.getClientDelegateMethods;
|
|
parameterMap = OSF.DDA.SafeArray.Delegate.ParameterMap;
|
|
OSF._OfficeAppFactory.setHostFacade(new OSF.DDA.DispIdHost.Facade(getDelegateMethods, parameterMap));
|
|
};
|
|
OSF.InitializationHelper.prototype.getInitializationReason = function (appContext) {
|
|
return OSF.DDA.RichInitializationReason[appContext.get_reason()];
|
|
};
|
|
|
|
OSF.DDA.DispIdHost.getClientDelegateMethods = function (actionId) {
|
|
var delegateMethods = {};
|
|
delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync] = OSF.DDA.SafeArray.Delegate.executeAsync;
|
|
delegateMethods[OSF.DDA.DispIdHost.Delegates.RegisterEventAsync] = OSF.DDA.SafeArray.Delegate.registerEventAsync;
|
|
delegateMethods[OSF.DDA.DispIdHost.Delegates.UnregisterEventAsync] = OSF.DDA.SafeArray.Delegate.unregisterEventAsync;
|
|
|
|
if (OSF.DDA.AsyncMethodNames.RefreshAsync && actionId == OSF.DDA.AsyncMethodNames.RefreshAsync.id) {
|
|
var readSerializedSettings = function (hostCallArgs, onCalling, onReceiving) {
|
|
return OSF.DDA.ClientSettingsManager.read(onCalling, onReceiving);
|
|
};
|
|
delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync] = OSF.DDA.ClientSettingsManager.getSettingsExecuteMethod(readSerializedSettings);
|
|
}
|
|
if (OSF.DDA.AsyncMethodNames.SaveAsync && actionId == OSF.DDA.AsyncMethodNames.SaveAsync.id) {
|
|
var writeSerializedSettings = function (hostCallArgs, onCalling, onReceiving) {
|
|
return OSF.DDA.ClientSettingsManager.write(hostCallArgs[OSF.DDA.SettingsManager.SerializedSettings], hostCallArgs[Microsoft.Office.WebExtension.Parameters.OverwriteIfStale], onCalling, onReceiving);
|
|
};
|
|
delegateMethods[OSF.DDA.DispIdHost.Delegates.ExecuteAsync] = OSF.DDA.ClientSettingsManager.getSettingsExecuteMethod(writeSerializedSettings);
|
|
}
|
|
return delegateMethods;
|
|
};
|
|
|
|
var OSFRichclient;
|
|
(function (OSFRichclient) {
|
|
var RichClientHostController = (function () {
|
|
function RichClientHostController() {
|
|
}
|
|
RichClientHostController.prototype.execute = function (id, params, callback) {
|
|
window.external.Execute(id, params, callback);
|
|
};
|
|
RichClientHostController.prototype.registerEvent = function (id, targetId, handler, callback) {
|
|
window.external.RegisterEvent(id, targetId, handler, callback);
|
|
};
|
|
RichClientHostController.prototype.unregisterEvent = function (id, targetId, callback) {
|
|
window.external.UnregisterEvent(id, targetId, callback);
|
|
};
|
|
return RichClientHostController;
|
|
})();
|
|
OSFRichclient.RichClientHostController = RichClientHostController;
|
|
})(OSFRichclient || (OSFRichclient = {}));
|
|
OSF.ClientHostController = new OSFRichclient.RichClientHostController();
|
|
|
|
var OfficeExt;
|
|
(function (OfficeExt) {
|
|
(function (OfficeTheme) {
|
|
var OfficeThemeManager = (function () {
|
|
function OfficeThemeManager() {
|
|
this._osfOfficeTheme = null;
|
|
this._osfOfficeThemeTimeStamp = null;
|
|
}
|
|
OfficeThemeManager.prototype.getOfficeTheme = function () {
|
|
if (OSF.DDA._OsfControlContext) {
|
|
if (this._osfOfficeTheme && this._osfOfficeThemeTimeStamp && ((new Date()).getTime() - this._osfOfficeThemeTimeStamp < OfficeThemeManager._osfOfficeThemeCacheValidPeriod)) {
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.onPropertyDone("GetOfficeThemeInfo", 0);
|
|
}
|
|
} else {
|
|
var startTime = (new Date()).getTime();
|
|
var osfOfficeTheme = OSF.DDA._OsfControlContext.GetOfficeThemeInfo();
|
|
var endTime = (new Date()).getTime();
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.onPropertyDone("GetOfficeThemeInfo", Math.abs(endTime - startTime));
|
|
}
|
|
|
|
this._osfOfficeTheme = JSON.parse(osfOfficeTheme);
|
|
for (var color in this._osfOfficeTheme) {
|
|
this._osfOfficeTheme[color] = OSF.OUtil.convertIntToCssHexColor(this._osfOfficeTheme[color]);
|
|
}
|
|
this._osfOfficeThemeTimeStamp = endTime;
|
|
}
|
|
return this._osfOfficeTheme;
|
|
}
|
|
};
|
|
|
|
OfficeThemeManager.instance = function () {
|
|
if (OfficeThemeManager._instance == null) {
|
|
OfficeThemeManager._instance = new OfficeThemeManager();
|
|
}
|
|
return OfficeThemeManager._instance;
|
|
};
|
|
OfficeThemeManager._osfOfficeThemeCacheValidPeriod = 5000;
|
|
|
|
OfficeThemeManager._instance = null;
|
|
return OfficeThemeManager;
|
|
})();
|
|
OfficeTheme.OfficeThemeManager = OfficeThemeManager;
|
|
|
|
OSF.OUtil.setNamespace("OfficeTheme", OSF.DDA);
|
|
OSF.DDA.OfficeTheme.getOfficeTheme = OfficeExt.OfficeTheme.OfficeThemeManager.instance().getOfficeTheme;
|
|
})(OfficeExt.OfficeTheme || (OfficeExt.OfficeTheme = {}));
|
|
var OfficeTheme = OfficeExt.OfficeTheme;
|
|
})(OfficeExt || (OfficeExt = {}));
|
|
|
|
OSF.DDA.ClientSettingsManager = {
|
|
getSettingsExecuteMethod: function OSF_DDA_ClientSettingsManager$getSettingsExecuteMethod(hostDelegateMethod) {
|
|
return function (args) {
|
|
var status, response;
|
|
try {
|
|
response = hostDelegateMethod(args.hostCallArgs, args.onCalling, args.onReceiving);
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeSuccess;
|
|
} catch (ex) {
|
|
status = OSF.DDA.ErrorCodeManager.errorCodes.ooeInternalError;
|
|
response = { name: Strings.OfficeOM.L_InternalError, message: ex };
|
|
}
|
|
if (args.onComplete) {
|
|
args.onComplete(status, response);
|
|
}
|
|
};
|
|
},
|
|
read: function OSF_DDA_ClientSettingsManager$read(onCalling, onReceiving) {
|
|
var keys = [];
|
|
var values = [];
|
|
if (onCalling) {
|
|
onCalling();
|
|
}
|
|
OSF.DDA._OsfControlContext.GetSettings().Read(keys, values);
|
|
if (onReceiving) {
|
|
onReceiving();
|
|
}
|
|
var serializedSettings = {};
|
|
for (var index = 0; index < keys.length; index++) {
|
|
serializedSettings[keys[index]] = values[index];
|
|
}
|
|
return serializedSettings;
|
|
},
|
|
write: function OSF_DDA_ClientSettingsManager$write(serializedSettings, overwriteIfStale, onCalling, onReceiving) {
|
|
var keys = [];
|
|
var values = [];
|
|
for (var key in serializedSettings) {
|
|
keys.push(key);
|
|
values.push(serializedSettings[key]);
|
|
}
|
|
if (onCalling) {
|
|
onCalling();
|
|
}
|
|
OSF.DDA._OsfControlContext.GetSettings().Write(keys, values);
|
|
if (onReceiving) {
|
|
onReceiving();
|
|
}
|
|
}
|
|
};
|
|
|
|
OSF.InitializationHelper.prototype.initializeSettings = function OSF_InitializationHelper$initializeSettings(refreshSupported) {
|
|
var serializedSettings = OSF.DDA.ClientSettingsManager.read();
|
|
var settings = this.deserializeSettings(serializedSettings, refreshSupported);
|
|
return settings;
|
|
};
|
|
OSF.InitializationHelper.prototype.getAppContext = function OSF_InitializationHelper$getAppContext(wnd, gotAppContext) {
|
|
var returnedContext;
|
|
var context = OSF.DDA._OsfControlContext = window.external.GetContext();
|
|
var appType = context.GetAppType();
|
|
var appTypeSupported = false;
|
|
for (var appEntry in OSF.AppName) {
|
|
if (OSF.AppName[appEntry] == appType) {
|
|
appTypeSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!appTypeSupported) {
|
|
throw "Unsupported client type " + appType;
|
|
}
|
|
var id = context.GetSolutionRef();
|
|
var version = context.GetAppVersionMajor();
|
|
var minorVersion = context.GetAppVersionMinor();
|
|
var UILocale = context.GetAppUILocale();
|
|
var dataLocale = context.GetAppDataLocale();
|
|
var docUrl = context.GetDocUrl();
|
|
var clientMode = context.GetAppCapabilities();
|
|
var reason = context.GetActivationMode();
|
|
var osfControlType = context.GetControlIntegrationLevel();
|
|
var settings = [];
|
|
var eToken;
|
|
try {
|
|
eToken = context.GetSolutionToken();
|
|
} catch (ex) {
|
|
}
|
|
var correlationId;
|
|
|
|
if (typeof context.GetCorrelationId !== "undefined") {
|
|
correlationId = context.GetCorrelationId();
|
|
}
|
|
var appInstanceId;
|
|
if (typeof context.GetInstanceId !== "undefined") {
|
|
appInstanceId = context.GetInstanceId();
|
|
}
|
|
var touchEnabled;
|
|
if (typeof context.GetTouchEnabled !== "undefined") {
|
|
touchEnabled = context.GetTouchEnabled();
|
|
}
|
|
var commerceAllowed;
|
|
if (typeof context.GetCommerceAllowed !== "undefined") {
|
|
commerceAllowed = context.GetCommerceAllowed();
|
|
}
|
|
var requirementMatrix;
|
|
if (typeof context.GetSupportedMatrix !== "undefined") {
|
|
requirementMatrix = context.GetSupportedMatrix();
|
|
}
|
|
eToken = eToken ? eToken.toString() : "";
|
|
returnedContext = new OSF.OfficeAppContext(id, appType, version, UILocale, dataLocale, docUrl, clientMode, settings, reason, osfControlType, eToken, correlationId, appInstanceId, touchEnabled, commerceAllowed, minorVersion, requirementMatrix);
|
|
if (OSF.AppTelemetry) {
|
|
OSF.AppTelemetry.initialize(returnedContext);
|
|
}
|
|
gotAppContext(returnedContext);
|
|
};
|
|
|
|
var OSFLog;
|
|
(function (OSFLog) {
|
|
var BaseUsageData = (function () {
|
|
function BaseUsageData(table) {
|
|
this._table = table;
|
|
this._fields = {};
|
|
}
|
|
Object.defineProperty(BaseUsageData.prototype, "Fields", {
|
|
get: function () {
|
|
return this._fields;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(BaseUsageData.prototype, "Table", {
|
|
get: function () {
|
|
return this._table;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
BaseUsageData.prototype.SerializeFields = function () {
|
|
};
|
|
BaseUsageData.prototype.SetSerializedField = function (key, value) {
|
|
if (typeof (value) !== "undefined" && value !== null) {
|
|
this._serializedFields[key] = value.toString();
|
|
}
|
|
};
|
|
BaseUsageData.prototype.SerializeRow = function () {
|
|
this._serializedFields = {};
|
|
this.SetSerializedField("Table", this._table);
|
|
this.SerializeFields();
|
|
return JSON.stringify(this._serializedFields);
|
|
};
|
|
return BaseUsageData;
|
|
})();
|
|
OSFLog.BaseUsageData = BaseUsageData;
|
|
var AppActivatedUsageData = (function (_super) {
|
|
__extends(AppActivatedUsageData, _super);
|
|
function AppActivatedUsageData() {
|
|
_super.call(this, "AppActivated");
|
|
}
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "CorrelationId", {
|
|
get: function () {
|
|
return this.Fields["CorrelationId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CorrelationId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "SessionId", {
|
|
get: function () {
|
|
return this.Fields["SessionId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SessionId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "AppId", {
|
|
get: function () {
|
|
return this.Fields["AppId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "AppURL", {
|
|
get: function () {
|
|
return this.Fields["AppURL"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppURL"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "AssetId", {
|
|
get: function () {
|
|
return this.Fields["AssetId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AssetId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "Browser", {
|
|
get: function () {
|
|
return this.Fields["Browser"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["Browser"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "UserId", {
|
|
get: function () {
|
|
return this.Fields["UserId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["UserId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "Host", {
|
|
get: function () {
|
|
return this.Fields["Host"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["Host"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "HostVersion", {
|
|
get: function () {
|
|
return this.Fields["HostVersion"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["HostVersion"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "ClientId", {
|
|
get: function () {
|
|
return this.Fields["ClientId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["ClientId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "AppSizeWidth", {
|
|
get: function () {
|
|
return this.Fields["AppSizeWidth"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppSizeWidth"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppActivatedUsageData.prototype, "AppSizeHeight", {
|
|
get: function () {
|
|
return this.Fields["AppSizeHeight"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppSizeHeight"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
AppActivatedUsageData.prototype.SerializeFields = function () {
|
|
this.SetSerializedField("CorrelationId", this.CorrelationId);
|
|
this.SetSerializedField("SessionId", this.SessionId);
|
|
this.SetSerializedField("AppId", this.AppId);
|
|
this.SetSerializedField("AppURL", this.AppURL);
|
|
this.SetSerializedField("AssetId", this.AssetId);
|
|
this.SetSerializedField("Browser", this.Browser);
|
|
this.SetSerializedField("UserId", this.UserId);
|
|
this.SetSerializedField("Host", this.Host);
|
|
this.SetSerializedField("HostVersion", this.HostVersion);
|
|
this.SetSerializedField("ClientId", this.ClientId);
|
|
this.SetSerializedField("AppSizeWidth", this.AppSizeWidth);
|
|
this.SetSerializedField("AppSizeHeight", this.AppSizeHeight);
|
|
};
|
|
return AppActivatedUsageData;
|
|
})(BaseUsageData);
|
|
OSFLog.AppActivatedUsageData = AppActivatedUsageData;
|
|
var ScriptLoadUsageData = (function (_super) {
|
|
__extends(ScriptLoadUsageData, _super);
|
|
function ScriptLoadUsageData() {
|
|
_super.call(this, "ScriptLoad");
|
|
}
|
|
Object.defineProperty(ScriptLoadUsageData.prototype, "CorrelationId", {
|
|
get: function () {
|
|
return this.Fields["CorrelationId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CorrelationId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ScriptLoadUsageData.prototype, "SessionId", {
|
|
get: function () {
|
|
return this.Fields["SessionId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SessionId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ScriptLoadUsageData.prototype, "ScriptId", {
|
|
get: function () {
|
|
return this.Fields["ScriptId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["ScriptId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ScriptLoadUsageData.prototype, "StartTime", {
|
|
get: function () {
|
|
return this.Fields["StartTime"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["StartTime"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ScriptLoadUsageData.prototype, "ResponseTime", {
|
|
get: function () {
|
|
return this.Fields["ResponseTime"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["ResponseTime"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
ScriptLoadUsageData.prototype.SerializeFields = function () {
|
|
this.SetSerializedField("CorrelationId", this.CorrelationId);
|
|
this.SetSerializedField("SessionId", this.SessionId);
|
|
this.SetSerializedField("ScriptId", this.ScriptId);
|
|
this.SetSerializedField("StartTime", this.StartTime);
|
|
this.SetSerializedField("ResponseTime", this.ResponseTime);
|
|
};
|
|
return ScriptLoadUsageData;
|
|
})(BaseUsageData);
|
|
OSFLog.ScriptLoadUsageData = ScriptLoadUsageData;
|
|
var AppClosedUsageData = (function (_super) {
|
|
__extends(AppClosedUsageData, _super);
|
|
function AppClosedUsageData() {
|
|
_super.call(this, "AppClosed");
|
|
}
|
|
Object.defineProperty(AppClosedUsageData.prototype, "CorrelationId", {
|
|
get: function () {
|
|
return this.Fields["CorrelationId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CorrelationId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "SessionId", {
|
|
get: function () {
|
|
return this.Fields["SessionId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SessionId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "FocusTime", {
|
|
get: function () {
|
|
return this.Fields["FocusTime"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["FocusTime"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "AppSizeFinalWidth", {
|
|
get: function () {
|
|
return this.Fields["AppSizeFinalWidth"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppSizeFinalWidth"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "AppSizeFinalHeight", {
|
|
get: function () {
|
|
return this.Fields["AppSizeFinalHeight"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["AppSizeFinalHeight"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "OpenTime", {
|
|
get: function () {
|
|
return this.Fields["OpenTime"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["OpenTime"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppClosedUsageData.prototype, "CloseMethod", {
|
|
get: function () {
|
|
return this.Fields["CloseMethod"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CloseMethod"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
AppClosedUsageData.prototype.SerializeFields = function () {
|
|
this.SetSerializedField("CorrelationId", this.CorrelationId);
|
|
this.SetSerializedField("SessionId", this.SessionId);
|
|
this.SetSerializedField("FocusTime", this.FocusTime);
|
|
this.SetSerializedField("AppSizeFinalWidth", this.AppSizeFinalWidth);
|
|
this.SetSerializedField("AppSizeFinalHeight", this.AppSizeFinalHeight);
|
|
this.SetSerializedField("OpenTime", this.OpenTime);
|
|
this.SetSerializedField("CloseMethod", this.CloseMethod);
|
|
};
|
|
return AppClosedUsageData;
|
|
})(BaseUsageData);
|
|
OSFLog.AppClosedUsageData = AppClosedUsageData;
|
|
var APIUsageUsageData = (function (_super) {
|
|
__extends(APIUsageUsageData, _super);
|
|
function APIUsageUsageData() {
|
|
_super.call(this, "APIUsage");
|
|
}
|
|
Object.defineProperty(APIUsageUsageData.prototype, "CorrelationId", {
|
|
get: function () {
|
|
return this.Fields["CorrelationId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CorrelationId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "SessionId", {
|
|
get: function () {
|
|
return this.Fields["SessionId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SessionId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "APIType", {
|
|
get: function () {
|
|
return this.Fields["APIType"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["APIType"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "APIID", {
|
|
get: function () {
|
|
return this.Fields["APIID"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["APIID"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "Parameters", {
|
|
get: function () {
|
|
return this.Fields["Parameters"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["Parameters"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "ResponseTime", {
|
|
get: function () {
|
|
return this.Fields["ResponseTime"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["ResponseTime"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(APIUsageUsageData.prototype, "ErrorType", {
|
|
get: function () {
|
|
return this.Fields["ErrorType"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["ErrorType"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
APIUsageUsageData.prototype.SerializeFields = function () {
|
|
this.SetSerializedField("CorrelationId", this.CorrelationId);
|
|
this.SetSerializedField("SessionId", this.SessionId);
|
|
this.SetSerializedField("APIType", this.APIType);
|
|
this.SetSerializedField("APIID", this.APIID);
|
|
this.SetSerializedField("Parameters", this.Parameters);
|
|
this.SetSerializedField("ResponseTime", this.ResponseTime);
|
|
this.SetSerializedField("ErrorType", this.ErrorType);
|
|
};
|
|
return APIUsageUsageData;
|
|
})(BaseUsageData);
|
|
OSFLog.APIUsageUsageData = APIUsageUsageData;
|
|
var AppInitializationUsageData = (function (_super) {
|
|
__extends(AppInitializationUsageData, _super);
|
|
function AppInitializationUsageData() {
|
|
_super.call(this, "AppInitialization");
|
|
}
|
|
Object.defineProperty(AppInitializationUsageData.prototype, "CorrelationId", {
|
|
get: function () {
|
|
return this.Fields["CorrelationId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["CorrelationId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppInitializationUsageData.prototype, "SessionId", {
|
|
get: function () {
|
|
return this.Fields["SessionId"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SessionId"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppInitializationUsageData.prototype, "SuccessCode", {
|
|
get: function () {
|
|
return this.Fields["SuccessCode"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["SuccessCode"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AppInitializationUsageData.prototype, "Message", {
|
|
get: function () {
|
|
return this.Fields["Message"];
|
|
},
|
|
set: function (value) {
|
|
this.Fields["Message"] = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
AppInitializationUsageData.prototype.SerializeFields = function () {
|
|
this.SetSerializedField("CorrelationId", this.CorrelationId);
|
|
this.SetSerializedField("SessionId", this.SessionId);
|
|
this.SetSerializedField("SuccessCode", this.SuccessCode);
|
|
this.SetSerializedField("Message", this.Message);
|
|
};
|
|
return AppInitializationUsageData;
|
|
})(BaseUsageData);
|
|
OSFLog.AppInitializationUsageData = AppInitializationUsageData;
|
|
})(OSFLog || (OSFLog = {}));
|
|
|
|
|
|
var Logger;
|
|
(function (Logger) {
|
|
"use strict";
|
|
|
|
|
|
|
|
(function (TraceLevel) {
|
|
TraceLevel[TraceLevel["info"] = 0] = "info";
|
|
TraceLevel[TraceLevel["warning"] = 1] = "warning";
|
|
TraceLevel[TraceLevel["error"] = 2] = "error";
|
|
})(Logger.TraceLevel || (Logger.TraceLevel = {}));
|
|
var TraceLevel = Logger.TraceLevel;
|
|
|
|
(function (SendFlag) {
|
|
SendFlag[SendFlag["none"] = 0] = "none";
|
|
SendFlag[SendFlag["flush"] = 1] = "flush";
|
|
})(Logger.SendFlag || (Logger.SendFlag = {}));
|
|
var SendFlag = Logger.SendFlag;
|
|
function allowUploadingData() {
|
|
if (OSF.Logger && OSF.Logger.ulsEndpoint) {
|
|
OSF.Logger.ulsEndpoint.loadProxyFrame();
|
|
}
|
|
}
|
|
Logger.allowUploadingData = allowUploadingData;
|
|
function sendLog(traceLevel, message, flag) {
|
|
if (OSF.Logger && OSF.Logger.ulsEndpoint) {
|
|
var jsonObj = { traceLevel: traceLevel, message: message, flag: flag, internalLog: true };
|
|
var logs = JSON.stringify(jsonObj);
|
|
OSF.Logger.ulsEndpoint.writeLog(logs);
|
|
}
|
|
}
|
|
Logger.sendLog = sendLog;
|
|
|
|
function creatULSEndpoint() {
|
|
try {
|
|
return new ULSEndpointProxy();
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var ULSEndpointProxy = (function () {
|
|
function ULSEndpointProxy() {
|
|
var _this = this;
|
|
this.proxyFrame = null;
|
|
this.telemetryEndPoint = "https://telemetryservice.firstpartyapps.oaspapps.com/telemetryservice/telemetryproxy.html";
|
|
this.buffer = [];
|
|
this.proxyFrameReady = false;
|
|
OSF.OUtil.addEventListener(window, "message", function (e) {
|
|
return _this.tellProxyFrameReady(e);
|
|
});
|
|
|
|
setTimeout(function () {
|
|
_this.loadProxyFrame();
|
|
}, 3000);
|
|
}
|
|
ULSEndpointProxy.prototype.writeLog = function (log) {
|
|
if (this.proxyFrameReady === true) {
|
|
this.proxyFrame.contentWindow.postMessage(log, "*");
|
|
} else {
|
|
if (this.buffer.length < 128) {
|
|
this.buffer.push(log);
|
|
}
|
|
}
|
|
};
|
|
ULSEndpointProxy.prototype.loadProxyFrame = function () {
|
|
if (this.proxyFrame == null) {
|
|
this.proxyFrame = document.createElement("iframe");
|
|
this.proxyFrame.setAttribute("style", "display:none");
|
|
this.proxyFrame.setAttribute("src", this.telemetryEndPoint);
|
|
document.head.appendChild(this.proxyFrame);
|
|
}
|
|
};
|
|
|
|
ULSEndpointProxy.prototype.tellProxyFrameReady = function (e) {
|
|
var _this = this;
|
|
if (e.data === "ProxyFrameReadyToLog") {
|
|
this.proxyFrameReady = true;
|
|
for (var i = 0; i < this.buffer.length; i++) {
|
|
this.writeLog(this.buffer[i]);
|
|
}
|
|
|
|
this.buffer.length = 0;
|
|
|
|
OSF.OUtil.removeEventListener(window, "message", function (e) {
|
|
return _this.tellProxyFrameReady(e);
|
|
});
|
|
} else if (e.data === "ProxyFrameReadyToInit") {
|
|
var initJson = { appName: "Office APPs", sessionId: OSF.OUtil.Guid.generateNewGuid() };
|
|
var initStr = JSON.stringify(initJson);
|
|
this.proxyFrame.contentWindow.postMessage(initStr, "*");
|
|
}
|
|
};
|
|
return ULSEndpointProxy;
|
|
})();
|
|
|
|
if (!OSF.Logger) {
|
|
OSF.Logger = Logger;
|
|
}
|
|
|
|
Logger.ulsEndpoint = creatULSEndpoint();
|
|
})(Logger || (Logger = {}));
|
|
|
|
|
|
|
|
var OSFAppTelemetry;
|
|
(function (OSFAppTelemetry) {
|
|
"use strict";
|
|
var appInfo;
|
|
var sessionId = OSF.OUtil.Guid.generateNewGuid();
|
|
var osfControlAppCorrelationId = "";
|
|
|
|
|
|
;
|
|
|
|
var AppInfo = (function () {
|
|
function AppInfo() {
|
|
}
|
|
return AppInfo;
|
|
})();
|
|
|
|
var Event = (function () {
|
|
function Event(name, handler) {
|
|
this.name = name;
|
|
this.handler = handler;
|
|
}
|
|
return Event;
|
|
})();
|
|
var AppStorage = (function () {
|
|
function AppStorage() {
|
|
this.clientIDKey = "Office API client";
|
|
this.logIdSetKey = "Office App Log Id Set";
|
|
}
|
|
AppStorage.prototype.getClientId = function () {
|
|
var clientId = this.getValue(this.clientIDKey);
|
|
|
|
if (!clientId || clientId.length <= 0 || clientId.length > 40) {
|
|
clientId = OSF.OUtil.Guid.generateNewGuid();
|
|
|
|
this.setValue(this.clientIDKey, clientId);
|
|
}
|
|
return clientId;
|
|
};
|
|
|
|
AppStorage.prototype.saveLog = function (logId, log) {
|
|
var logIdSet = this.getValue(this.logIdSetKey);
|
|
logIdSet = ((logIdSet && logIdSet.length > 0) ? (logIdSet + ";") : "") + logId;
|
|
this.setValue(this.logIdSetKey, logIdSet);
|
|
this.setValue(logId, log);
|
|
};
|
|
|
|
AppStorage.prototype.enumerateLog = function (callback, clean) {
|
|
var logIdSet = this.getValue(this.logIdSetKey);
|
|
if (logIdSet) {
|
|
var ids = logIdSet.split(";");
|
|
for (var id in ids) {
|
|
var logId = ids[id];
|
|
var log = this.getValue(logId);
|
|
if (log) {
|
|
if (callback) {
|
|
callback(logId, log);
|
|
}
|
|
if (clean) {
|
|
this.remove(logId);
|
|
}
|
|
}
|
|
}
|
|
if (clean) {
|
|
this.remove(this.logIdSetKey);
|
|
}
|
|
}
|
|
};
|
|
AppStorage.prototype.getValue = function (key) {
|
|
var osfLocalStorage = OSF.OUtil.getLocalStorage();
|
|
var value = "";
|
|
if (osfLocalStorage) {
|
|
value = osfLocalStorage.getItem(key);
|
|
}
|
|
return value;
|
|
};
|
|
AppStorage.prototype.setValue = function (key, value) {
|
|
var osfLocalStorage = OSF.OUtil.getLocalStorage();
|
|
if (osfLocalStorage) {
|
|
osfLocalStorage.setItem(key, value);
|
|
}
|
|
};
|
|
AppStorage.prototype.remove = function (key) {
|
|
var osfLocalStorage = OSF.OUtil.getLocalStorage();
|
|
if (osfLocalStorage) {
|
|
try {
|
|
osfLocalStorage.removeItem(key);
|
|
} catch (ex) {
|
|
}
|
|
}
|
|
};
|
|
return AppStorage;
|
|
})();
|
|
|
|
var AppLogger = (function () {
|
|
function AppLogger() {
|
|
}
|
|
AppLogger.prototype.LogData = function (data) {
|
|
if (!OSF.Logger) {
|
|
return;
|
|
}
|
|
OSF.Logger.sendLog(OSF.Logger.TraceLevel.info, data.SerializeRow(), OSF.Logger.SendFlag.none);
|
|
};
|
|
AppLogger.prototype.LogRawData = function (log) {
|
|
if (!OSF.Logger) {
|
|
return;
|
|
}
|
|
OSF.Logger.sendLog(OSF.Logger.TraceLevel.info, log, OSF.Logger.SendFlag.none);
|
|
};
|
|
return AppLogger;
|
|
})();
|
|
|
|
function initialize(context) {
|
|
if (!OSF.Logger) {
|
|
return;
|
|
}
|
|
if (appInfo) {
|
|
return;
|
|
}
|
|
appInfo = new AppInfo();
|
|
appInfo.hostVersion = context.get_appVersion();
|
|
appInfo.appId = context.get_id();
|
|
appInfo.host = context.get_appName();
|
|
appInfo.browser = window.navigator.userAgent;
|
|
appInfo.correlationId = context.get_correlationId();
|
|
appInfo.clientId = (new AppStorage()).getClientId();
|
|
var index = location.href.indexOf("?");
|
|
appInfo.appURL = (index == -1) ? location.href : location.href.substring(0, index);
|
|
|
|
(function getUserIdAndAssetIdFromToken(token, appInfo) {
|
|
var xmlContent;
|
|
var parser;
|
|
var xmlDoc;
|
|
appInfo.assetId = "";
|
|
appInfo.userId = "";
|
|
try {
|
|
xmlContent = decodeURIComponent(token);
|
|
parser = new DOMParser();
|
|
xmlDoc = parser.parseFromString(xmlContent, "text/xml");
|
|
appInfo.userId = xmlDoc.getElementsByTagName("t")[0].attributes.getNamedItem("cid").nodeValue;
|
|
appInfo.assetId = xmlDoc.getElementsByTagName("t")[0].attributes.getNamedItem("aid").nodeValue;
|
|
} catch (e) {
|
|
} finally {
|
|
xmlContent = null;
|
|
xmlDoc = null;
|
|
parser = null;
|
|
}
|
|
})(context.get_eToken(), appInfo);
|
|
|
|
(function handleLifecycle() {
|
|
var startTime = new Date();
|
|
|
|
var lastFocus = null;
|
|
|
|
var focusTime = 0;
|
|
var finished = false;
|
|
var adjustFocusTime = function () {
|
|
if (document.hasFocus()) {
|
|
if (lastFocus == null) {
|
|
lastFocus = new Date();
|
|
}
|
|
} else if (lastFocus) {
|
|
focusTime += Math.abs((new Date()).getTime() - lastFocus.getTime());
|
|
lastFocus = null;
|
|
}
|
|
};
|
|
var eventList = [];
|
|
eventList.push(new Event("focus", adjustFocusTime));
|
|
eventList.push(new Event("blur", adjustFocusTime));
|
|
|
|
eventList.push(new Event("focusout", adjustFocusTime));
|
|
eventList.push(new Event("focusin", adjustFocusTime));
|
|
var exitFunction = function () {
|
|
for (var i = 0; i < eventList.length; i++) {
|
|
OSF.OUtil.removeEventListener(window, eventList[i].name, eventList[i].handler);
|
|
}
|
|
eventList.length = 0;
|
|
if (!finished) {
|
|
if (document.hasFocus() && lastFocus) {
|
|
focusTime += Math.abs((new Date()).getTime() - lastFocus.getTime());
|
|
lastFocus = null;
|
|
}
|
|
OSFAppTelemetry.onAppClosed(Math.abs((new Date()).getTime() - startTime.getTime()), focusTime);
|
|
finished = true;
|
|
}
|
|
};
|
|
|
|
eventList.push(new Event("beforeunload", exitFunction));
|
|
eventList.push(new Event("unload", exitFunction));
|
|
|
|
for (var i = 0; i < eventList.length; i++) {
|
|
OSF.OUtil.addEventListener(window, eventList[i].name, eventList[i].handler);
|
|
}
|
|
|
|
adjustFocusTime();
|
|
})();
|
|
OSFAppTelemetry.onAppActivated();
|
|
}
|
|
OSFAppTelemetry.initialize = initialize;
|
|
|
|
function onAppActivated() {
|
|
if (!appInfo) {
|
|
return;
|
|
}
|
|
|
|
(new AppStorage()).enumerateLog(function (id, log) {
|
|
return (new AppLogger()).LogRawData(log);
|
|
}, true);
|
|
var data = new OSFLog.AppActivatedUsageData();
|
|
data.SessionId = sessionId;
|
|
data.AppId = appInfo.appId;
|
|
data.AssetId = appInfo.assetId;
|
|
data.AppURL = appInfo.appURL;
|
|
data.UserId = appInfo.userId;
|
|
data.ClientId = appInfo.clientId;
|
|
data.Browser = appInfo.browser;
|
|
data.Host = appInfo.host;
|
|
data.HostVersion = appInfo.hostVersion;
|
|
data.CorrelationId = appInfo.correlationId;
|
|
data.AppSizeWidth = window.innerWidth;
|
|
data.AppSizeHeight = window.innerHeight;
|
|
(new AppLogger()).LogData(data);
|
|
|
|
setTimeout(function () {
|
|
if (!OSF.Logger) {
|
|
return;
|
|
}
|
|
OSF.Logger.allowUploadingData();
|
|
}, 100);
|
|
}
|
|
OSFAppTelemetry.onAppActivated = onAppActivated;
|
|
|
|
function onScriptDone(scriptId, msStartTime, msResponseTime, appCorrelationId) {
|
|
var data = new OSFLog.ScriptLoadUsageData();
|
|
data.CorrelationId = appCorrelationId;
|
|
data.SessionId = sessionId;
|
|
data.ScriptId = scriptId;
|
|
data.StartTime = msStartTime;
|
|
data.ResponseTime = msResponseTime;
|
|
(new AppLogger()).LogData(data);
|
|
}
|
|
OSFAppTelemetry.onScriptDone = onScriptDone;
|
|
|
|
function onCallDone(apiType, id, parameters, msResponseTime, errorType) {
|
|
if (!appInfo) {
|
|
return;
|
|
}
|
|
var data = new OSFLog.APIUsageUsageData();
|
|
data.CorrelationId = osfControlAppCorrelationId;
|
|
data.SessionId = sessionId;
|
|
data.APIType = apiType;
|
|
data.APIID = id;
|
|
data.Parameters = parameters;
|
|
data.ResponseTime = msResponseTime;
|
|
data.ErrorType = errorType;
|
|
(new AppLogger()).LogData(data);
|
|
}
|
|
OSFAppTelemetry.onCallDone = onCallDone;
|
|
;
|
|
|
|
function onMethodDone(id, args, msResponseTime, errorType) {
|
|
var parameters = null;
|
|
if (args) {
|
|
if (typeof args == "number") {
|
|
parameters = String(args);
|
|
} else if (typeof args === "object") {
|
|
for (var index in args) {
|
|
if (parameters !== null) {
|
|
parameters += ",";
|
|
} else {
|
|
parameters = "";
|
|
}
|
|
if (typeof args[index] == "number") {
|
|
parameters += String(args[index]);
|
|
}
|
|
}
|
|
} else {
|
|
parameters = "";
|
|
}
|
|
}
|
|
OSF.AppTelemetry.onCallDone("method", id, parameters, msResponseTime, errorType);
|
|
}
|
|
OSFAppTelemetry.onMethodDone = onMethodDone;
|
|
|
|
function onPropertyDone(propertyName, msResponseTime) {
|
|
OSF.AppTelemetry.onCallDone("property", -1, propertyName, msResponseTime);
|
|
}
|
|
OSFAppTelemetry.onPropertyDone = onPropertyDone;
|
|
|
|
function onEventDone(id, errorType) {
|
|
OSF.AppTelemetry.onCallDone("event", id, null, 0, errorType);
|
|
}
|
|
OSFAppTelemetry.onEventDone = onEventDone;
|
|
|
|
function onRegisterDone(register, id, msResponseTime, errorType) {
|
|
OSF.AppTelemetry.onCallDone(register ? "registerevent" : "unregisterevent", id, null, msResponseTime, errorType);
|
|
}
|
|
OSFAppTelemetry.onRegisterDone = onRegisterDone;
|
|
|
|
function onAppClosed(openTime, focusTime) {
|
|
if (!appInfo) {
|
|
return;
|
|
}
|
|
var data = new OSFLog.AppClosedUsageData();
|
|
data.CorrelationId = osfControlAppCorrelationId;
|
|
data.SessionId = sessionId;
|
|
data.FocusTime = focusTime;
|
|
data.OpenTime = openTime;
|
|
data.AppSizeFinalWidth = window.innerWidth;
|
|
data.AppSizeFinalHeight = window.innerHeight;
|
|
|
|
(new AppStorage()).saveLog(sessionId, data.SerializeRow());
|
|
}
|
|
OSFAppTelemetry.onAppClosed = onAppClosed;
|
|
function setOsfControlAppCorrelationId(correlationId) {
|
|
osfControlAppCorrelationId = correlationId;
|
|
}
|
|
OSFAppTelemetry.setOsfControlAppCorrelationId = setOsfControlAppCorrelationId;
|
|
function doAppInitializationLogging(isException, message) {
|
|
var data = new OSFLog.AppInitializationUsageData();
|
|
data.CorrelationId = osfControlAppCorrelationId;
|
|
data.SessionId = sessionId;
|
|
data.SuccessCode = isException ? 1 : 0;
|
|
data.Message = message;
|
|
(new AppLogger()).LogData(data);
|
|
}
|
|
OSFAppTelemetry.doAppInitializationLogging = doAppInitializationLogging;
|
|
|
|
function logAppCommonMessage(message) {
|
|
doAppInitializationLogging(false, message);
|
|
}
|
|
OSFAppTelemetry.logAppCommonMessage = logAppCommonMessage;
|
|
|
|
function logAppException(errorMessage) {
|
|
doAppInitializationLogging(true, errorMessage);
|
|
}
|
|
OSFAppTelemetry.logAppException = logAppException;
|
|
OSF.AppTelemetry = OSFAppTelemetry;
|
|
})(OSFAppTelemetry || (OSFAppTelemetry = {}));
|
|
|
|
Microsoft.Office.WebExtension.EventType = {};
|
|
|
|
OSF.EventDispatch = function OSF_EventDispatch(eventTypes) {
|
|
this._eventHandlers = {};
|
|
for (var entry in eventTypes) {
|
|
var eventType = eventTypes[entry];
|
|
this._eventHandlers[eventType] = [];
|
|
}
|
|
};
|
|
OSF.EventDispatch.prototype = {
|
|
getSupportedEvents: function OSF_EventDispatch$getSupportedEvents() {
|
|
var events = [];
|
|
for (var eventName in this._eventHandlers)
|
|
events.push(eventName);
|
|
return events;
|
|
},
|
|
supportsEvent: function OSF_EventDispatch$supportsEvent(event) {
|
|
var isSupported = false;
|
|
for (var eventName in this._eventHandlers) {
|
|
if (event == eventName) {
|
|
isSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
return isSupported;
|
|
},
|
|
hasEventHandler: function OSF_EventDispatch$hasEventHandler(eventType, handler) {
|
|
var handlers = this._eventHandlers[eventType];
|
|
if (handlers && handlers.length > 0) {
|
|
for (var h in handlers) {
|
|
if (handlers[h] === handler)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
addEventHandler: function OSF_EventDispatch$addEventHandler(eventType, handler) {
|
|
if (typeof handler != "function") {
|
|
return false;
|
|
}
|
|
var handlers = this._eventHandlers[eventType];
|
|
if (handlers && !this.hasEventHandler(eventType, handler)) {
|
|
handlers.push(handler);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
removeEventHandler: function OSF_EventDispatch$removeEventHandler(eventType, handler) {
|
|
var handlers = this._eventHandlers[eventType];
|
|
if (handlers && handlers.length > 0) {
|
|
for (var index = 0; index < handlers.length; index++) {
|
|
if (handlers[index] === handler) {
|
|
handlers.splice(index, 1);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
clearEventHandlers: function OSF_EventDispatch$clearEventHandlers(eventType) {
|
|
if (typeof this._eventHandlers[eventType] != "undefined" && this._eventHandlers[eventType].length > 0) {
|
|
this._eventHandlers[eventType] = [];
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
getEventHandlerCount: function OSF_EventDispatch$getEventHandlerCount(eventType) {
|
|
return this._eventHandlers[eventType] != undefined ? this._eventHandlers[eventType].length : -1;
|
|
},
|
|
fireEvent: function OSF_EventDispatch$fireEvent(eventArgs) {
|
|
if (eventArgs.type == undefined)
|
|
return false;
|
|
var eventType = eventArgs.type;
|
|
if (eventType && this._eventHandlers[eventType]) {
|
|
var eventHandlers = this._eventHandlers[eventType];
|
|
for (var handler in eventHandlers)
|
|
eventHandlers[handler](eventArgs);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
OSF.DDA.OMFactory = OSF.DDA.OMFactory || {};
|
|
OSF.DDA.OMFactory.manufactureEventArgs = function OSF_DDA_OMFactory$manufactureEventArgs(eventType, target, eventProperties) {
|
|
var args;
|
|
switch (eventType) {
|
|
case Microsoft.Office.WebExtension.EventType.DocumentSelectionChanged:
|
|
args = new OSF.DDA.DocumentSelectionChangedEventArgs(target);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.BindingSelectionChanged:
|
|
args = new OSF.DDA.BindingSelectionChangedEventArgs(this.manufactureBinding(eventProperties, target.document), eventProperties[OSF.DDA.PropertyDescriptors.Subset]);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.BindingDataChanged:
|
|
args = new OSF.DDA.BindingDataChangedEventArgs(this.manufactureBinding(eventProperties, target.document));
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.SettingsChanged:
|
|
args = new OSF.DDA.SettingsChangedEventArgs(target);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.ActiveViewChanged:
|
|
args = new OSF.DDA.ActiveViewChangedEventArgs(eventProperties);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.OfficeThemeChanged:
|
|
args = new OSF.DDA.Theming.OfficeThemeChangedEventArgs(eventProperties);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.DocumentThemeChanged:
|
|
args = new OSF.DDA.Theming.DocumentThemeChangedEventArgs(eventProperties);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.AppCommandInvoked:
|
|
args = OSF.DDA.AppCommand.AppCommandInvokedEventArgs.create(eventProperties);
|
|
break;
|
|
|
|
case Microsoft.Office.WebExtension.EventType.DataNodeInserted:
|
|
args = new OSF.DDA.NodeInsertedEventArgs(this.manufactureDataNode(eventProperties[OSF.DDA.DataNodeEventProperties.NewNode]), eventProperties[OSF.DDA.DataNodeEventProperties.InUndoRedo]);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.DataNodeReplaced:
|
|
args = new OSF.DDA.NodeReplacedEventArgs(this.manufactureDataNode(eventProperties[OSF.DDA.DataNodeEventProperties.OldNode]), this.manufactureDataNode(eventProperties[OSF.DDA.DataNodeEventProperties.NewNode]), eventProperties[OSF.DDA.DataNodeEventProperties.InUndoRedo]);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.DataNodeDeleted:
|
|
args = new OSF.DDA.NodeDeletedEventArgs(this.manufactureDataNode(eventProperties[OSF.DDA.DataNodeEventProperties.OldNode]), this.manufactureDataNode(eventProperties[OSF.DDA.DataNodeEventProperties.NextSiblingNode]), eventProperties[OSF.DDA.DataNodeEventProperties.InUndoRedo]);
|
|
break;
|
|
|
|
case Microsoft.Office.WebExtension.EventType.TaskSelectionChanged:
|
|
args = new OSF.DDA.TaskSelectionChangedEventArgs(target);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.ResourceSelectionChanged:
|
|
args = new OSF.DDA.ResourceSelectionChangedEventArgs(target);
|
|
break;
|
|
case Microsoft.Office.WebExtension.EventType.ViewSelectionChanged:
|
|
args = new OSF.DDA.ViewSelectionChangedEventArgs(target);
|
|
break;
|
|
default:
|
|
throw OsfMsAjaxFactory.msAjaxError.argument(Microsoft.Office.WebExtension.Parameters.EventType, OSF.OUtil.formatString(Strings.OfficeOM.L_NotSupportedEventType, eventType));
|
|
}
|
|
return args;
|
|
};
|
|
OSF.DDA.AsyncMethodNames.addNames({
|
|
AddHandlerAsync: "addHandlerAsync",
|
|
RemoveHandlerAsync: "removeHandlerAsync"
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.AddHandlerAsync,
|
|
requiredArguments: [
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.EventType,
|
|
"enum": Microsoft.Office.WebExtension.EventType,
|
|
"verify": function (eventType, caller, eventDispatch) {
|
|
return eventDispatch.supportsEvent(eventType);
|
|
}
|
|
},
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.Handler,
|
|
"types": ["function"]
|
|
}
|
|
],
|
|
supportedOptions: [],
|
|
privateStateCallbacks: []
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.RemoveHandlerAsync,
|
|
requiredArguments: [
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.EventType,
|
|
"enum": Microsoft.Office.WebExtension.EventType,
|
|
"verify": function (eventType, caller, eventDispatch) {
|
|
return eventDispatch.supportsEvent(eventType);
|
|
}
|
|
}
|
|
],
|
|
supportedOptions: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.Handler,
|
|
value: {
|
|
"types": ["function", "object"],
|
|
"defaultValue": null
|
|
}
|
|
}
|
|
],
|
|
privateStateCallbacks: []
|
|
});
|
|
|
|
Microsoft.Office.WebExtension.TableData = function Microsoft_Office_WebExtension_TableData(rows, headers) {
|
|
function fixData(data) {
|
|
if (data == null || data == undefined) {
|
|
return null;
|
|
}
|
|
try {
|
|
for (var dim = OSF.DDA.DataCoercion.findArrayDimensionality(data, 2); dim < 2; dim++) {
|
|
data = [data];
|
|
}
|
|
return data;
|
|
} catch (ex) {
|
|
}
|
|
}
|
|
;
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"headers": {
|
|
get: function () {
|
|
return headers;
|
|
},
|
|
set: function (value) {
|
|
headers = fixData(value);
|
|
}
|
|
},
|
|
"rows": {
|
|
get: function () {
|
|
return rows;
|
|
},
|
|
set: function (value) {
|
|
rows = (value == null || (OSF.OUtil.isArray(value) && (value.length == 0))) ? [] : fixData(value);
|
|
}
|
|
}
|
|
});
|
|
this.headers = headers;
|
|
this.rows = rows;
|
|
};
|
|
OSF.DDA.OMFactory = OSF.DDA.OMFactory || {};
|
|
OSF.DDA.OMFactory.manufactureTableData = function OSF_DDA_OMFactory$manufactureTableData(tableDataProperties) {
|
|
return new Microsoft.Office.WebExtension.TableData(tableDataProperties[OSF.DDA.TableDataProperties.TableRows], tableDataProperties[OSF.DDA.TableDataProperties.TableHeaders]);
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.CoercionType = {
|
|
Text: "text",
|
|
Matrix: "matrix",
|
|
Table: "table"
|
|
};
|
|
|
|
OSF.DDA.DataCoercion = (function OSF_DDA_DataCoercion() {
|
|
return {
|
|
findArrayDimensionality: function OSF_DDA_DataCoercion$findArrayDimensionality(obj) {
|
|
if (OSF.OUtil.isArray(obj)) {
|
|
var dim = 0;
|
|
for (var index = 0; index < obj.length; index++) {
|
|
dim = Math.max(dim, OSF.DDA.DataCoercion.findArrayDimensionality(obj[index]));
|
|
}
|
|
return dim + 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
},
|
|
getCoercionDefaultForBinding: function OSF_DDA_DataCoercion$getCoercionDefaultForBinding(bindingType) {
|
|
switch (bindingType) {
|
|
case Microsoft.Office.WebExtension.BindingType.Matrix:
|
|
return Microsoft.Office.WebExtension.CoercionType.Matrix;
|
|
case Microsoft.Office.WebExtension.BindingType.Table:
|
|
return Microsoft.Office.WebExtension.CoercionType.Table;
|
|
case Microsoft.Office.WebExtension.BindingType.Text:
|
|
default:
|
|
return Microsoft.Office.WebExtension.CoercionType.Text;
|
|
}
|
|
},
|
|
getBindingDefaultForCoercion: function OSF_DDA_DataCoercion$getBindingDefaultForCoercion(coercionType) {
|
|
switch (coercionType) {
|
|
case Microsoft.Office.WebExtension.CoercionType.Matrix:
|
|
return Microsoft.Office.WebExtension.BindingType.Matrix;
|
|
case Microsoft.Office.WebExtension.CoercionType.Table:
|
|
return Microsoft.Office.WebExtension.BindingType.Table;
|
|
case Microsoft.Office.WebExtension.CoercionType.Text:
|
|
case Microsoft.Office.WebExtension.CoercionType.Html:
|
|
case Microsoft.Office.WebExtension.CoercionType.Ooxml:
|
|
default:
|
|
return Microsoft.Office.WebExtension.BindingType.Text;
|
|
}
|
|
},
|
|
determineCoercionType: function OSF_DDA_DataCoercion$determineCoercionType(data) {
|
|
if (data == null || data == undefined)
|
|
return null;
|
|
var sourceType = null;
|
|
var runtimeType = typeof data;
|
|
if (data.rows !== undefined) {
|
|
sourceType = Microsoft.Office.WebExtension.CoercionType.Table;
|
|
} else if (OSF.OUtil.isArray(data)) {
|
|
sourceType = Microsoft.Office.WebExtension.CoercionType.Matrix;
|
|
} else if (runtimeType == "string" || runtimeType == "number" || runtimeType == "boolean" || OSF.OUtil.isDate(data)) {
|
|
sourceType = Microsoft.Office.WebExtension.CoercionType.Text;
|
|
} else {
|
|
throw OSF.DDA.ErrorCodeManager.errorCodes.ooeUnsupportedDataObject;
|
|
}
|
|
return sourceType;
|
|
},
|
|
coerceData: function OSF_DDA_DataCoercion$coerceData(data, destinationType, sourceType) {
|
|
sourceType = sourceType || OSF.DDA.DataCoercion.determineCoercionType(data);
|
|
if (sourceType && sourceType != destinationType) {
|
|
OSF.OUtil.writeProfilerMark(OSF.InternalPerfMarker.DataCoercionBegin);
|
|
data = OSF.DDA.DataCoercion._coerceDataFromTable(destinationType, OSF.DDA.DataCoercion._coerceDataToTable(data, sourceType));
|
|
OSF.OUtil.writeProfilerMark(OSF.InternalPerfMarker.DataCoercionEnd);
|
|
}
|
|
return data;
|
|
},
|
|
_matrixToText: function OSF_DDA_DataCoercion$_matrixToText(matrix) {
|
|
if (matrix.length == 1 && matrix[0].length == 1)
|
|
return "" + matrix[0][0];
|
|
var val = "";
|
|
for (var i = 0; i < matrix.length; i++) {
|
|
val += matrix[i].join("\t") + "\n";
|
|
}
|
|
return val.substring(0, val.length - 1);
|
|
},
|
|
_textToMatrix: function OSF_DDA_DataCoercion$_textToMatrix(text) {
|
|
var ret = text.split("\n");
|
|
for (var i = 0; i < ret.length; i++)
|
|
ret[i] = ret[i].split("\t");
|
|
return ret;
|
|
},
|
|
_tableToText: function OSF_DDA_DataCoercion$_tableToText(table) {
|
|
var headers = "";
|
|
if (table.headers != null) {
|
|
headers = OSF.DDA.DataCoercion._matrixToText([table.headers]) + "\n";
|
|
}
|
|
|
|
var rows = OSF.DDA.DataCoercion._matrixToText(table.rows);
|
|
if (rows == "") {
|
|
headers = headers.substring(0, headers.length - 1);
|
|
}
|
|
return headers + rows;
|
|
},
|
|
_tableToMatrix: function OSF_DDA_DataCoercion$_tableToMatrix(table) {
|
|
var matrix = table.rows;
|
|
if (table.headers != null) {
|
|
matrix.unshift(table.headers);
|
|
}
|
|
return matrix;
|
|
},
|
|
_coerceDataFromTable: function OSF_DDA_DataCoercion$_coerceDataFromTable(coercionType, table) {
|
|
var value;
|
|
switch (coercionType) {
|
|
case Microsoft.Office.WebExtension.CoercionType.Table:
|
|
value = table;
|
|
break;
|
|
case Microsoft.Office.WebExtension.CoercionType.Matrix:
|
|
value = OSF.DDA.DataCoercion._tableToMatrix(table);
|
|
break;
|
|
case Microsoft.Office.WebExtension.CoercionType.SlideRange:
|
|
value = null;
|
|
if (OSF.DDA.OMFactory.manufactureSlideRange) {
|
|
value = OSF.DDA.OMFactory.manufactureSlideRange(OSF.DDA.DataCoercion._tableToText(table));
|
|
}
|
|
if (value == null) {
|
|
value = OSF.DDA.DataCoercion._tableToText(table);
|
|
}
|
|
break;
|
|
case Microsoft.Office.WebExtension.CoercionType.Text:
|
|
case Microsoft.Office.WebExtension.CoercionType.Html:
|
|
case Microsoft.Office.WebExtension.CoercionType.Ooxml:
|
|
default:
|
|
value = OSF.DDA.DataCoercion._tableToText(table);
|
|
break;
|
|
}
|
|
return value;
|
|
},
|
|
_coerceDataToTable: function OSF_DDA_DataCoercion$_coerceDataToTable(data, sourceType) {
|
|
if (sourceType == undefined) {
|
|
sourceType = OSF.DDA.DataCoercion.determineCoercionType(data);
|
|
}
|
|
var value;
|
|
switch (sourceType) {
|
|
case Microsoft.Office.WebExtension.CoercionType.Table:
|
|
value = data;
|
|
break;
|
|
case Microsoft.Office.WebExtension.CoercionType.Matrix:
|
|
value = new Microsoft.Office.WebExtension.TableData(data);
|
|
break;
|
|
case Microsoft.Office.WebExtension.CoercionType.Text:
|
|
case Microsoft.Office.WebExtension.CoercionType.Html:
|
|
case Microsoft.Office.WebExtension.CoercionType.Ooxml:
|
|
default:
|
|
value = new Microsoft.Office.WebExtension.TableData(OSF.DDA.DataCoercion._textToMatrix(data));
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
};
|
|
})();
|
|
Microsoft.Office.WebExtension.ProjectViewTypes = {
|
|
Gantt: 1,
|
|
NetworkDiagram: 2,
|
|
TaskDiagram: 3,
|
|
TaskForm: 4,
|
|
TaskSheet: 5,
|
|
ResourceForm: 6,
|
|
ResourceSheet: 7,
|
|
ResourceGraph: 8,
|
|
TeamPlanner: 9,
|
|
TaskDetails: 10,
|
|
TaskNameForm: 11,
|
|
ResourceNames: 12,
|
|
Calendar: 13,
|
|
TaskUsage: 14,
|
|
ResourceUsage: 15,
|
|
Timeline: 16,
|
|
Drawing: 18,
|
|
ResourcePlan: 19
|
|
};
|
|
|
|
OSF.OUtil.redefineList(Microsoft.Office.WebExtension.CoercionType, {
|
|
Text: "text"
|
|
});
|
|
OSF.OUtil.redefineList(Microsoft.Office.WebExtension.ValueFormat, {
|
|
Unformatted: "unformatted"
|
|
});
|
|
|
|
OSF.OUtil.augmentList(Microsoft.Office.WebExtension.EventType, {
|
|
TaskSelectionChanged: "taskSelectionChanged",
|
|
ResourceSelectionChanged: "resourceSelectionChanged",
|
|
ViewSelectionChanged: "viewSelectionChanged"
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodNames.addNames({
|
|
GetSelectedDataAsync: "getSelectedDataAsync",
|
|
SetSelectedDataAsync: "setSelectedDataAsync"
|
|
});
|
|
|
|
(function () {
|
|
function processData(dataDescriptor, caller, callArgs) {
|
|
var data = dataDescriptor[Microsoft.Office.WebExtension.Parameters.Data];
|
|
|
|
if (OSF.DDA.TableDataProperties && data && (data[OSF.DDA.TableDataProperties.TableRows] != undefined || data[OSF.DDA.TableDataProperties.TableHeaders] != undefined)) {
|
|
data = OSF.DDA.OMFactory.manufactureTableData(data);
|
|
}
|
|
data = OSF.DDA.DataCoercion.coerceData(data, callArgs[Microsoft.Office.WebExtension.Parameters.CoercionType]);
|
|
return data == undefined ? null : data;
|
|
}
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetSelectedDataAsync,
|
|
requiredArguments: [
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.CoercionType,
|
|
"enum": Microsoft.Office.WebExtension.CoercionType
|
|
}
|
|
],
|
|
supportedOptions: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ValueFormat,
|
|
value: {
|
|
"enum": Microsoft.Office.WebExtension.ValueFormat,
|
|
"defaultValue": Microsoft.Office.WebExtension.ValueFormat.Unformatted
|
|
}
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FilterType,
|
|
value: {
|
|
"enum": Microsoft.Office.WebExtension.FilterType,
|
|
"defaultValue": Microsoft.Office.WebExtension.FilterType.All
|
|
}
|
|
}
|
|
],
|
|
privateStateCallbacks: [],
|
|
onSucceeded: processData
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.SetSelectedDataAsync,
|
|
requiredArguments: [
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.Data,
|
|
"types": ["string", "object", "number", "boolean"]
|
|
}
|
|
],
|
|
supportedOptions: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.CoercionType,
|
|
value: {
|
|
"enum": Microsoft.Office.WebExtension.CoercionType,
|
|
"calculate": function (requiredArgs) {
|
|
return OSF.DDA.DataCoercion.determineCoercionType(requiredArgs[Microsoft.Office.WebExtension.Parameters.Data]);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ImageLeft,
|
|
value: {
|
|
"types": ["number", "boolean"],
|
|
"defaultValue": false
|
|
}
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ImageTop,
|
|
value: {
|
|
"types": ["number", "boolean"],
|
|
"defaultValue": false
|
|
}
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ImageWidth,
|
|
value: {
|
|
"types": ["number", "boolean"],
|
|
"defaultValue": false
|
|
}
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ImageHeight,
|
|
value: {
|
|
"types": ["number", "boolean"],
|
|
"defaultValue": false
|
|
}
|
|
}
|
|
],
|
|
privateStateCallbacks: []
|
|
});
|
|
})();
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetSelectedDataMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.Data, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.CoercionType, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ValueFormat, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FilterType, value: 2 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidSetSelectedDataMethod,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.CoercionType, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.Data, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ImageLeft, value: 2 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ImageTop, value: 3 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ImageWidth, value: 4 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ImageHeight, value: 5 }
|
|
]
|
|
});
|
|
OSF.DDA.SettingsManager = {
|
|
SerializedSettings: "serializedSettings",
|
|
DateJSONPrefix: "Date(",
|
|
DataJSONSuffix: ")",
|
|
serializeSettings: function OSF_DDA_SettingsManager$serializeSettings(settingsCollection) {
|
|
var ret = {};
|
|
for (var key in settingsCollection) {
|
|
var value = settingsCollection[key];
|
|
try {
|
|
if (JSON) {
|
|
value = JSON.stringify(value, function dateReplacer(k, v) {
|
|
return OSF.OUtil.isDate(this[k]) ? OSF.DDA.SettingsManager.DateJSONPrefix + this[k].getTime() + OSF.DDA.SettingsManager.DataJSONSuffix : v;
|
|
});
|
|
} else {
|
|
value = Sys.Serialization.JavaScriptSerializer.serialize(value);
|
|
}
|
|
ret[key] = value;
|
|
} catch (ex) {
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
deserializeSettings: function OSF_DDA_SettingsManager$deserializeSettings(serializedSettings) {
|
|
var ret = {};
|
|
serializedSettings = serializedSettings || {};
|
|
for (var key in serializedSettings) {
|
|
var value = serializedSettings[key];
|
|
try {
|
|
if (JSON) {
|
|
value = JSON.parse(value, function dateReviver(k, v) {
|
|
var d;
|
|
if (typeof v === 'string' && v && v.length > 6 && v.slice(0, 5) === OSF.DDA.SettingsManager.DateJSONPrefix && v.slice(-1) === OSF.DDA.SettingsManager.DataJSONSuffix) {
|
|
d = new Date(parseInt(v.slice(5, -1)));
|
|
if (d) {
|
|
return d;
|
|
}
|
|
}
|
|
return v;
|
|
});
|
|
} else {
|
|
value = Sys.Serialization.JavaScriptSerializer.deserialize(value, true);
|
|
}
|
|
ret[key] = value;
|
|
} catch (ex) {
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
OSF.DDA.Settings = function OSF_DDA_Settings(settings) {
|
|
settings = settings || {};
|
|
|
|
var cacheSessionSettings = function (settings) {
|
|
var osfSessionStorage = OSF.OUtil.getSessionStorage();
|
|
if (osfSessionStorage) {
|
|
var serializedSettings = OSF.DDA.SettingsManager.serializeSettings(settings);
|
|
var storageSettings = JSON ? JSON.stringify(serializedSettings) : Sys.Serialization.JavaScriptSerializer.serialize(serializedSettings);
|
|
osfSessionStorage.setItem(OSF._OfficeAppFactory.getCachedSessionSettingsKey(), storageSettings);
|
|
}
|
|
};
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"get": {
|
|
value: function OSF_DDA_Settings$get(name) {
|
|
var e = Function._validateParams(arguments, [
|
|
{ name: "name", type: String, mayBeNull: false }
|
|
]);
|
|
if (e)
|
|
throw e;
|
|
var setting = settings[name];
|
|
return typeof (setting) === 'undefined' ? null : setting;
|
|
}
|
|
},
|
|
"set": {
|
|
value: function OSF_DDA_Settings$set(name, value) {
|
|
var e = Function._validateParams(arguments, [
|
|
{ name: "name", type: String, mayBeNull: false },
|
|
{ name: "value", mayBeNull: true }
|
|
]);
|
|
if (e)
|
|
throw e;
|
|
settings[name] = value;
|
|
cacheSessionSettings(settings);
|
|
}
|
|
},
|
|
"remove": {
|
|
value: function OSF_DDA_Settings$remove(name) {
|
|
var e = Function._validateParams(arguments, [
|
|
{ name: "name", type: String, mayBeNull: false }
|
|
]);
|
|
if (e)
|
|
throw e;
|
|
delete settings[name];
|
|
cacheSessionSettings(settings);
|
|
}
|
|
}
|
|
});
|
|
OSF.DDA.DispIdHost.addAsyncMethods(this, [OSF.DDA.AsyncMethodNames.SaveAsync], settings);
|
|
};
|
|
|
|
OSF.DDA.RefreshableSettings = function OSF_DDA_RefreshableSettings(settings) {
|
|
OSF.DDA.RefreshableSettings.uber.constructor.call(this, settings);
|
|
OSF.DDA.DispIdHost.addAsyncMethods(this, [OSF.DDA.AsyncMethodNames.RefreshAsync], settings);
|
|
OSF.DDA.DispIdHost.addEventSupport(this, new OSF.EventDispatch([Microsoft.Office.WebExtension.EventType.SettingsChanged]));
|
|
};
|
|
|
|
OSF.OUtil.extend(OSF.DDA.RefreshableSettings, OSF.DDA.Settings);
|
|
OSF.OUtil.augmentList(Microsoft.Office.WebExtension.EventType, {
|
|
SettingsChanged: "settingsChanged"
|
|
});
|
|
OSF.DDA.SettingsChangedEventArgs = function OSF_DDA_SettingsChangedEventArgs(settingsInstance) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"type": {
|
|
value: Microsoft.Office.WebExtension.EventType.SettingsChanged
|
|
},
|
|
"settings": {
|
|
value: settingsInstance
|
|
}
|
|
});
|
|
};
|
|
OSF.DDA.AsyncMethodNames.addNames({
|
|
RefreshAsync: "refreshAsync",
|
|
SaveAsync: "saveAsync"
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.RefreshAsync,
|
|
requiredArguments: [],
|
|
supportedOptions: [],
|
|
privateStateCallbacks: [],
|
|
onSucceeded: function deserializeSettings(serializedSettingsDescriptor, refreshingSettings) {
|
|
var serializedSettings = serializedSettingsDescriptor[OSF.DDA.SettingsManager.SerializedSettings];
|
|
var newSettings = OSF.DDA.SettingsManager.deserializeSettings(serializedSettings);
|
|
return newSettings;
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.SaveAsync,
|
|
requiredArguments: [],
|
|
supportedOptions: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.OverwriteIfStale,
|
|
value: {
|
|
"types": ["boolean"],
|
|
"defaultValue": true
|
|
}
|
|
}
|
|
],
|
|
privateStateCallbacks: [
|
|
{
|
|
name: OSF.DDA.SettingsManager.SerializedSettings,
|
|
value: function serializeSettings(settingsInstance, settingsCollection) {
|
|
return OSF.DDA.SettingsManager.serializeSettings(settingsCollection);
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidLoadSettingsMethod,
|
|
fromHost: [
|
|
{ name: OSF.DDA.SettingsManager.SerializedSettings, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidSaveSettingsMethod,
|
|
toHost: [
|
|
{ name: OSF.DDA.SettingsManager.SerializedSettings, value: OSF.DDA.SettingsManager.SerializedSettings },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.OverwriteIfStale, value: Microsoft.Office.WebExtension.Parameters.OverwriteIfStale }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({ type: OSF.DDA.EventDispId.dispidSettingsChangedEvent });
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: Microsoft.Office.WebExtension.Parameters.CoercionType,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.CoercionType.Text, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.CoercionType.Matrix, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.CoercionType.Table, value: 2 }
|
|
]
|
|
});
|
|
|
|
Microsoft.Office.WebExtension.ProjectTaskFields = {
|
|
ActualCost: 0,
|
|
ActualDuration: 1,
|
|
ActualFinish: 2,
|
|
ActualOvertimeCost: 3,
|
|
ActualOvertimeWork: 4,
|
|
ActualStart: 5,
|
|
ActualWork: 6,
|
|
Text1: 7,
|
|
Text10: 8,
|
|
Finish10: 9,
|
|
Start10: 10,
|
|
Text11: 11,
|
|
Text12: 12,
|
|
Text13: 13,
|
|
Text14: 14,
|
|
Text15: 15,
|
|
Text16: 16,
|
|
Text17: 17,
|
|
Text18: 18,
|
|
Text19: 19,
|
|
Finish1: 20,
|
|
Start1: 21,
|
|
Text2: 22,
|
|
Text20: 23,
|
|
Text21: 24,
|
|
Text22: 25,
|
|
Text23: 26,
|
|
Text24: 27,
|
|
Text25: 28,
|
|
Text26: 29,
|
|
Text27: 30,
|
|
Text28: 31,
|
|
Text29: 32,
|
|
Finish2: 33,
|
|
Start2: 34,
|
|
Text3: 35,
|
|
Text30: 36,
|
|
Finish3: 37,
|
|
Start3: 38,
|
|
Text4: 39,
|
|
Finish4: 40,
|
|
Start4: 41,
|
|
Text5: 42,
|
|
Finish5: 43,
|
|
Start5: 44,
|
|
Text6: 45,
|
|
Finish6: 46,
|
|
Start6: 47,
|
|
Text7: 48,
|
|
Finish7: 49,
|
|
Start7: 50,
|
|
Text8: 51,
|
|
Finish8: 52,
|
|
Start8: 53,
|
|
Text9: 54,
|
|
Finish9: 55,
|
|
Start9: 56,
|
|
Baseline10BudgetCost: 57,
|
|
Baseline10BudgetWork: 58,
|
|
Baseline10Cost: 59,
|
|
Baseline10Duration: 60,
|
|
Baseline10Finish: 61,
|
|
Baseline10FixedCost: 62,
|
|
Baseline10FixedCostAccrual: 63,
|
|
Baseline10Start: 64,
|
|
Baseline10Work: 65,
|
|
Baseline1BudgetCost: 66,
|
|
Baseline1BudgetWork: 67,
|
|
Baseline1Cost: 68,
|
|
Baseline1Duration: 69,
|
|
Baseline1Finish: 70,
|
|
Baseline1FixedCost: 71,
|
|
Baseline1FixedCostAccrual: 72,
|
|
Baseline1Start: 73,
|
|
Baseline1Work: 74,
|
|
Baseline2BudgetCost: 75,
|
|
Baseline2BudgetWork: 76,
|
|
Baseline2Cost: 77,
|
|
Baseline2Duration: 78,
|
|
Baseline2Finish: 79,
|
|
Baseline2FixedCost: 80,
|
|
Baseline2FixedCostAccrual: 81,
|
|
Baseline2Start: 82,
|
|
Baseline2Work: 83,
|
|
Baseline3BudgetCost: 84,
|
|
Baseline3BudgetWork: 85,
|
|
Baseline3Cost: 86,
|
|
Baseline3Duration: 87,
|
|
Baseline3Finish: 88,
|
|
Baseline3FixedCost: 89,
|
|
Baseline3FixedCostAccrual: 90,
|
|
Basline3Start: 91,
|
|
Baseline3Work: 92,
|
|
Baseline4BudgetCost: 93,
|
|
Baseline4BudgetWork: 94,
|
|
Baseline4Cost: 95,
|
|
Baseline4Duration: 96,
|
|
Baseline4Finish: 97,
|
|
Baseline4FixedCost: 98,
|
|
Baseline4FixedCostAccrual: 99,
|
|
Baseline4Start: 100,
|
|
Baseline4Work: 101,
|
|
Baseline5BudgetCost: 102,
|
|
Baseline5BudgetWork: 103,
|
|
Baseline5Cost: 104,
|
|
Baseline5Duration: 105,
|
|
Baseline5Finish: 106,
|
|
Baseline5FixedCost: 107,
|
|
Baseline5FixedCostAccrual: 108,
|
|
Baseline5Start: 109,
|
|
Baseline5Work: 110,
|
|
Baseline6BudgetCost: 111,
|
|
Baseline6BudgetWork: 112,
|
|
Baseline6Cost: 113,
|
|
Baseline6Duration: 114,
|
|
Baseline6Finish: 115,
|
|
Baseline6FixedCost: 116,
|
|
Baseline6FixedCostAccrual: 117,
|
|
Baseline6Start: 118,
|
|
Baseline6Work: 119,
|
|
Baseline7BudgetCost: 120,
|
|
Baseline7BudgetWork: 121,
|
|
Baseline7Cost: 122,
|
|
Baseline7Duration: 123,
|
|
Baseline7Finish: 124,
|
|
Baseline7FixedCost: 125,
|
|
Baseline7FixedCostAccrual: 126,
|
|
Baseline7Start: 127,
|
|
Baseline7Work: 128,
|
|
Baseline8BudgetCost: 129,
|
|
Baseline8BudgetWork: 130,
|
|
Baseline8Cost: 131,
|
|
Baseline8Duration: 132,
|
|
Baseline8Finish: 133,
|
|
Baseline8FixedCost: 134,
|
|
Baseline8FixedCostAccrual: 135,
|
|
Baseline8Start: 136,
|
|
Baseline8Work: 137,
|
|
Baseline9BudgetCost: 138,
|
|
Baseline9BudgetWork: 139,
|
|
Baseline9Cost: 140,
|
|
Baseline9Duration: 141,
|
|
Baseline9Finish: 142,
|
|
Baseline9FixedCost: 143,
|
|
Baseline9FixedCostAccrual: 144,
|
|
Baseline9Start: 145,
|
|
Baseline9Work: 146,
|
|
BaselineBudgetCost: 147,
|
|
BaselineBudgetWork: 148,
|
|
BaselineCost: 149,
|
|
BaselineDuration: 150,
|
|
BaselineFinish: 151,
|
|
BaselineFixedCost: 152,
|
|
BaselineFixedCostAccrual: 153,
|
|
BaselineStart: 154,
|
|
BaselineWork: 155,
|
|
BudgetCost: 156,
|
|
BudgetWork: 157,
|
|
TaskCalendarGUID: 158,
|
|
ConstraintDate: 159,
|
|
ConstraintType: 160,
|
|
Cost1: 161,
|
|
Cost10: 162,
|
|
Cost2: 163,
|
|
Cost3: 164,
|
|
Cost4: 165,
|
|
Cost5: 166,
|
|
Cost6: 167,
|
|
Cost7: 168,
|
|
Cost8: 169,
|
|
Cost9: 170,
|
|
Date1: 171,
|
|
Date10: 172,
|
|
Date2: 173,
|
|
Date3: 174,
|
|
Date4: 175,
|
|
Date5: 176,
|
|
Date6: 177,
|
|
Date7: 178,
|
|
Date8: 179,
|
|
Date9: 180,
|
|
Deadline: 181,
|
|
Duration1: 182,
|
|
Duration10: 183,
|
|
Duration2: 184,
|
|
Duration3: 185,
|
|
Duration4: 186,
|
|
Duration5: 187,
|
|
Duration6: 188,
|
|
Duration7: 189,
|
|
Duration8: 190,
|
|
Duration9: 191,
|
|
Duration: 192,
|
|
EarnedValueMethod: 193,
|
|
FinishSlack: 194,
|
|
FixedCost: 195,
|
|
FixedCostAccrual: 196,
|
|
Flag10: 197,
|
|
Flag1: 198,
|
|
Flag11: 199,
|
|
Flag12: 200,
|
|
Flag13: 201,
|
|
Flag14: 202,
|
|
Flag15: 203,
|
|
Flag16: 204,
|
|
Flag17: 205,
|
|
Flag18: 206,
|
|
Flag19: 207,
|
|
Flag2: 208,
|
|
Flag20: 209,
|
|
Flag3: 210,
|
|
Flag4: 211,
|
|
Flag5: 212,
|
|
Flag6: 213,
|
|
Flag7: 214,
|
|
Flag8: 215,
|
|
Flag9: 216,
|
|
FreeSlack: 217,
|
|
HasRollupSubTasks: 218,
|
|
ID: 219,
|
|
Name: 220,
|
|
Notes: 221,
|
|
Number1: 222,
|
|
Number10: 223,
|
|
Number11: 224,
|
|
Number12: 225,
|
|
Number13: 226,
|
|
Number14: 227,
|
|
Number15: 228,
|
|
Number16: 229,
|
|
Number17: 230,
|
|
Number18: 231,
|
|
Number19: 232,
|
|
Number2: 233,
|
|
Number20: 234,
|
|
Number3: 235,
|
|
Number4: 236,
|
|
Number5: 237,
|
|
Number6: 238,
|
|
Number7: 239,
|
|
Number8: 240,
|
|
Number9: 241,
|
|
ScheduledDuration: 242,
|
|
ScheduledFinish: 243,
|
|
ScheduledStart: 244,
|
|
OutlineLevel: 245,
|
|
OvertimeCost: 246,
|
|
OvertimeWork: 247,
|
|
PercentComplete: 248,
|
|
PercentWorkComplete: 249,
|
|
Predecessors: 250,
|
|
PreleveledFinish: 251,
|
|
PreleveledStart: 252,
|
|
Priority: 253,
|
|
Active: 254,
|
|
Critical: 255,
|
|
Milestone: 256,
|
|
Overallocated: 257,
|
|
IsRollup: 258,
|
|
Summary: 259,
|
|
RegularWork: 260,
|
|
RemainingCost: 261,
|
|
RemainingDuration: 262,
|
|
RemainingOvertimeCost: 263,
|
|
RemainingWork: 264,
|
|
ResourceNames: 265,
|
|
ResourceNames_deprecated: 266,
|
|
Cost: 267,
|
|
Finish: 268,
|
|
Start: 269,
|
|
Work: 270,
|
|
StartSlack: 271,
|
|
Status: 272,
|
|
Successors: 273,
|
|
StatusManager: 274,
|
|
TotalSlack: 275,
|
|
TaskGUID: 276,
|
|
Type: 277,
|
|
WBS: 278,
|
|
WBSPREDECESSORS: 279,
|
|
WBSSUCCESSORS: 280,
|
|
WSSID: 281
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.ProjectResourceFields = {
|
|
Accrual: 0,
|
|
ActualCost: 1,
|
|
ActualOvertimeCost: 2,
|
|
ActualOvertimeWork: 3,
|
|
ActualOvertimeWorkProtected: 4,
|
|
ActualWork: 5,
|
|
ActualWorkProtected: 6,
|
|
BaseCalendar: 7,
|
|
Baseline10BudgetCost: 8,
|
|
Baseline10BudgetWork: 9,
|
|
Baseline10Cost: 10,
|
|
Baseline10Work: 11,
|
|
Baseline1BudgetCost: 12,
|
|
Baseline1BudgetWork: 13,
|
|
Baseline1Cost: 14,
|
|
Baseline1Work: 15,
|
|
Baseline2BudgetCost: 16,
|
|
Baseline2BudgetWork: 17,
|
|
Baseline2Cost: 18,
|
|
Baseline2Work: 19,
|
|
Baseline3BudgetCost: 20,
|
|
Baseline3BudgetWork: 21,
|
|
Baseline3Cost: 22,
|
|
Baseline3Work: 23,
|
|
Baseline4BudgetCost: 24,
|
|
Baseline4BudgetWork: 25,
|
|
Baseline4Cost: 26,
|
|
Baseline4Work: 27,
|
|
Baseline5BudgetCost: 28,
|
|
Baseline5BudgetWork: 29,
|
|
Baseline5Cost: 30,
|
|
Baseline5Work: 31,
|
|
Baseline6BudgetCost: 32,
|
|
Baseline6BudgetWork: 33,
|
|
Baseline6Cost: 34,
|
|
Baseline6Work: 35,
|
|
Baseline7BudgetCost: 36,
|
|
Baseline7BudgetWork: 37,
|
|
Baseline7Cost: 38,
|
|
Baseline7Work: 39,
|
|
Baseline8BudgetCost: 40,
|
|
Baseline8BudgetWork: 41,
|
|
Baseline8Cost: 42,
|
|
Baseline8Work: 43,
|
|
Baseline9BudgetCost: 44,
|
|
Baseline9BudgetWork: 45,
|
|
Baseline9Cost: 46,
|
|
Baseline9Work: 47,
|
|
BaselineBudgetCost: 48,
|
|
BaselineBudgetWork: 49,
|
|
BaselineCost: 50,
|
|
BaselineWork: 51,
|
|
BudgetCost: 52,
|
|
BudgetWork: 53,
|
|
ResourceCalendarGUID: 54,
|
|
Code: 55,
|
|
Cost1: 56,
|
|
Cost10: 57,
|
|
Cost2: 58,
|
|
Cost3: 59,
|
|
Cost4: 60,
|
|
Cost5: 61,
|
|
Cost6: 62,
|
|
Cost7: 63,
|
|
Cost8: 64,
|
|
Cost9: 65,
|
|
ResourceCreationDate: 66,
|
|
Date1: 67,
|
|
Date10: 68,
|
|
Date2: 69,
|
|
Date3: 70,
|
|
Date4: 71,
|
|
Date5: 72,
|
|
Date6: 73,
|
|
Date7: 74,
|
|
Date8: 75,
|
|
Date9: 76,
|
|
Duration1: 77,
|
|
Duration10: 78,
|
|
Duration2: 79,
|
|
Duration3: 80,
|
|
Duration4: 81,
|
|
Duration5: 82,
|
|
Duration6: 83,
|
|
Duration7: 84,
|
|
Duration8: 85,
|
|
Duration9: 86,
|
|
Email: 87,
|
|
End: 88,
|
|
Finish1: 89,
|
|
Finish10: 90,
|
|
Finish2: 91,
|
|
Finish3: 92,
|
|
Finish4: 93,
|
|
Finish5: 94,
|
|
Finish6: 95,
|
|
Finish7: 96,
|
|
Finish8: 97,
|
|
Finish9: 98,
|
|
Flag10: 99,
|
|
Flag1: 100,
|
|
Flag11: 101,
|
|
Flag12: 102,
|
|
Flag13: 103,
|
|
Flag14: 104,
|
|
Flag15: 105,
|
|
Flag16: 106,
|
|
Flag17: 107,
|
|
Flag18: 108,
|
|
Flag19: 109,
|
|
Flag2: 110,
|
|
Flag20: 111,
|
|
Flag3: 112,
|
|
Flag4: 113,
|
|
Flag5: 114,
|
|
Flag6: 115,
|
|
Flag7: 116,
|
|
Flag8: 117,
|
|
Flag9: 118,
|
|
Group: 119,
|
|
Units: 120,
|
|
Name: 121,
|
|
Notes: 122,
|
|
Number1: 123,
|
|
Number10: 124,
|
|
Number11: 125,
|
|
Number12: 126,
|
|
Number13: 127,
|
|
Number14: 128,
|
|
Number15: 129,
|
|
Number16: 130,
|
|
Number17: 131,
|
|
Number18: 132,
|
|
Number19: 133,
|
|
Number2: 134,
|
|
Number20: 135,
|
|
Number3: 136,
|
|
Number4: 137,
|
|
Number5: 138,
|
|
Number6: 139,
|
|
Number7: 140,
|
|
Number8: 141,
|
|
Number9: 142,
|
|
OvertimeCost: 143,
|
|
OvertimeRate: 144,
|
|
OvertimeWork: 145,
|
|
PercentWorkComplete: 146,
|
|
CostPerUse: 147,
|
|
Generic: 148,
|
|
OverAllocated: 149,
|
|
RegularWork: 150,
|
|
RemainingCost: 151,
|
|
RemainingOvertimeCost: 152,
|
|
RemainingOvertimeWork: 153,
|
|
RemainingWork: 154,
|
|
ResourceGUID: 155,
|
|
Cost: 156,
|
|
Work: 157,
|
|
Start: 158,
|
|
Start1: 159,
|
|
Start10: 160,
|
|
Start2: 161,
|
|
Start3: 162,
|
|
Start4: 163,
|
|
Start5: 164,
|
|
Start6: 165,
|
|
Start7: 166,
|
|
Start8: 167,
|
|
Start9: 168,
|
|
StandardRate: 169,
|
|
Text1: 170,
|
|
Text10: 171,
|
|
Text11: 172,
|
|
Text12: 173,
|
|
Text13: 174,
|
|
Text14: 175,
|
|
Text15: 176,
|
|
Text16: 177,
|
|
Text17: 178,
|
|
Text18: 179,
|
|
Text19: 180,
|
|
Text2: 181,
|
|
Text20: 182,
|
|
Text21: 183,
|
|
Text22: 184,
|
|
Text23: 185,
|
|
Text24: 186,
|
|
Text25: 187,
|
|
Text26: 188,
|
|
Text27: 189,
|
|
Text28: 190,
|
|
Text29: 191,
|
|
Text3: 192,
|
|
Text30: 193,
|
|
Text4: 194,
|
|
Text5: 195,
|
|
Text6: 196,
|
|
Text7: 197,
|
|
Text8: 198,
|
|
Text9: 199
|
|
};
|
|
|
|
Microsoft.Office.WebExtension.ProjectProjectFields = {
|
|
CurrencyDigits: 0,
|
|
CurrencySymbol: 1,
|
|
CurrencySymbolPosition: 2,
|
|
DurationUnits: 3,
|
|
GUID: 4,
|
|
Finish: 5,
|
|
Start: 6,
|
|
ReadOnly: 7,
|
|
VERSION: 8,
|
|
WorkUnits: 9,
|
|
ProjectServerUrl: 10,
|
|
WSSUrl: 11,
|
|
WSSList: 12
|
|
};
|
|
OSF.DDA.ProjectDocument = function OSF_DDA_ProjectDocument(officeAppContext) {
|
|
OSF.DDA.ProjectDocument.uber.constructor.call(this, officeAppContext);
|
|
var am = OSF.DDA.AsyncMethodNames;
|
|
OSF.DDA.DispIdHost.addAsyncMethods(this, [
|
|
am.GetSelectedDataAsync,
|
|
am.GetSelectedTask,
|
|
am.GetTask,
|
|
am.GetTaskField,
|
|
am.GetWSSUrl,
|
|
am.GetSelectedResource,
|
|
am.GetResourceField,
|
|
am.GetProjectField,
|
|
am.GetSelectedView,
|
|
am.GetTaskByIndex,
|
|
am.GetResourceByIndex,
|
|
am.SetTaskField,
|
|
am.SetResourceField,
|
|
am.GetMaxTaskIndex,
|
|
am.GetMaxResourceIndex
|
|
]);
|
|
OSF.DDA.DispIdHost.addEventSupport(this, new OSF.EventDispatch([
|
|
Microsoft.Office.WebExtension.EventType.TaskSelectionChanged,
|
|
Microsoft.Office.WebExtension.EventType.ResourceSelectionChanged,
|
|
Microsoft.Office.WebExtension.EventType.ViewSelectionChanged]));
|
|
};
|
|
|
|
OSF.OUtil.extend(OSF.DDA.ProjectDocument, OSF.DDA.Document);
|
|
OSF.DDA.TaskSelectionChangedEventArgs = function OSF_DDA_TaskSelectionChangedEventArgs(doc) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"type": {
|
|
value: Microsoft.Office.WebExtension.EventType.TaskSelectionChanged
|
|
},
|
|
"document": {
|
|
value: doc
|
|
}
|
|
});
|
|
};
|
|
OSF.DDA.ResourceSelectionChangedEventArgs = function OSF_DDA_ResourceSelectionChangedEventArgs(doc) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"type": {
|
|
value: Microsoft.Office.WebExtension.EventType.ResourceSelectionChanged
|
|
},
|
|
"document": {
|
|
value: doc
|
|
}
|
|
});
|
|
};
|
|
OSF.DDA.ViewSelectionChangedEventArgs = function OSF_DDA_ViewSelectionChangedEventArgs(doc) {
|
|
OSF.OUtil.defineEnumerableProperties(this, {
|
|
"type": {
|
|
value: Microsoft.Office.WebExtension.EventType.ViewSelectionChanged
|
|
},
|
|
"document": {
|
|
value: doc
|
|
}
|
|
});
|
|
};
|
|
|
|
OSF.InitializationHelper.prototype.loadAppSpecificScriptAndCreateOM = function OSF_InitializationHelper$loadAppSpecificScriptAndCreateOM(appContext, appReady, basePath) {
|
|
OSF.DDA.ErrorCodeManager.initializeErrorMessages(Strings.OfficeOM);
|
|
appContext.doc = new OSF.DDA.ProjectDocument(appContext, this._initializeSettings(false));
|
|
appReady();
|
|
};
|
|
OSF.DDA.AsyncMethodNames.addNames({
|
|
GetSelectedTask: "getSelectedTaskAsync",
|
|
GetTask: "getTaskAsync",
|
|
GetWSSUrl: "getWSSUrlAsync",
|
|
GetTaskField: "getTaskFieldAsync",
|
|
GetSelectedResource: "getSelectedResourceAsync",
|
|
GetResourceField: "getResourceFieldAsync",
|
|
GetProjectField: "getProjectFieldAsync",
|
|
GetSelectedView: "getSelectedViewAsync",
|
|
GetTaskByIndex: "getTaskByIndexAsync",
|
|
GetResourceByIndex: "getResourceByIndexAsync",
|
|
SetTaskField: "setTaskFieldAsync",
|
|
SetResourceField: "setResourceFieldAsync",
|
|
GetMaxTaskIndex: "getMaxTaskIndexAsync",
|
|
GetMaxResourceIndex: "getMaxResourceIndexAsync"
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetSelectedTask,
|
|
onSucceeded: function (taskIdDescriptor) {
|
|
return taskIdDescriptor[Microsoft.Office.WebExtension.Parameters.TaskId];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetTaskByIndex,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.TaskIndex,
|
|
types: ["number"]
|
|
}
|
|
],
|
|
supportedOptions: [],
|
|
privateStateCallbacks: [],
|
|
onSucceeded: function (taskIdDescriptor) {
|
|
return taskIdDescriptor[Microsoft.Office.WebExtension.Parameters.TaskId];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetTask,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.TaskId,
|
|
types: ["string"]
|
|
}
|
|
]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetTaskField,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.TaskId,
|
|
types: ["string"]
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FieldId,
|
|
types: ["number"]
|
|
}],
|
|
supportedOptions: [{
|
|
name: Microsoft.Office.WebExtension.Parameters.GetRawValue,
|
|
value: {
|
|
"types": ["boolean"],
|
|
"defaultValue": false
|
|
}
|
|
}]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetResourceField,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ResourceId,
|
|
types: ["string"]
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FieldId,
|
|
types: ["number"]
|
|
}],
|
|
supportedOptions: [{
|
|
name: Microsoft.Office.WebExtension.Parameters.GetRawValue,
|
|
value: {
|
|
"types": ["boolean"],
|
|
"defaultValue": false
|
|
}
|
|
}]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetProjectField,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FieldId,
|
|
types: ["number"]
|
|
}
|
|
],
|
|
supportedOptions: [{
|
|
name: Microsoft.Office.WebExtension.Parameters.GetRawValue,
|
|
value: {
|
|
"types": ["boolean"],
|
|
"defaultValue": false
|
|
}
|
|
}]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetSelectedResource,
|
|
onSucceeded: function (resourceIdDescriptor) {
|
|
return resourceIdDescriptor[Microsoft.Office.WebExtension.Parameters.ResourceId];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetResourceByIndex,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ResourceIndex,
|
|
types: ["number"]
|
|
}
|
|
],
|
|
supportedOptions: [],
|
|
privateStateCallbacks: [],
|
|
onSucceeded: function (resourceIdDescriptor) {
|
|
return resourceIdDescriptor[Microsoft.Office.WebExtension.Parameters.ResourceId];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetWSSUrl
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetSelectedView
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.SetTaskField,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.TaskId,
|
|
types: ["string"]
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FieldId,
|
|
types: ["number"]
|
|
},
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.FieldValue,
|
|
"types": ["object", "string", "number", "boolean"]
|
|
}
|
|
]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.SetResourceField,
|
|
requiredArguments: [
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.ResourceId,
|
|
types: ["string"]
|
|
},
|
|
{
|
|
name: Microsoft.Office.WebExtension.Parameters.FieldId,
|
|
types: ["number"]
|
|
},
|
|
{
|
|
"name": Microsoft.Office.WebExtension.Parameters.FieldValue,
|
|
"types": ["object", "string", "number", "boolean"]
|
|
}
|
|
]
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetMaxTaskIndex,
|
|
onSucceeded: function (taskIndexDescriptor) {
|
|
return taskIndexDescriptor[Microsoft.Office.WebExtension.Parameters.TaskIndex];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.AsyncMethodCalls.define({
|
|
method: OSF.DDA.AsyncMethodNames.GetMaxResourceIndex,
|
|
onSucceeded: function (resourceIndexDescriptor) {
|
|
return resourceIndexDescriptor[Microsoft.Office.WebExtension.Parameters.ResourceIndex];
|
|
}
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetSelectedTaskMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskId, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetTaskByIndexMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskId, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskIndex, value: 0 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetTaskMethod,
|
|
fromHost: [
|
|
{ name: "taskName", value: 0 },
|
|
{ name: "wssTaskId", value: 1 },
|
|
{ name: "resourceNames", value: 2 }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskId, value: 0 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetTaskFieldMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldValue, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskId, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldId, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.GetRawValue, value: 2 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetWSSUrlMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ServerUrl, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ListName, value: 1 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetSelectedResourceMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceId, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetResourceByIndexMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceId, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceIndex, value: 0 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetResourceFieldMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldValue, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceId, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldId, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.GetRawValue, value: 2 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetProjectFieldMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldValue, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
],
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldId, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.GetRawValue, value: 1 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetSelectedViewMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ViewType, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ViewName, value: 1 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidSetTaskFieldMethod,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskId, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldId, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldValue, value: 2 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidSetResourceFieldMethod,
|
|
toHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceId, value: 0 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldId, value: 1 },
|
|
{ name: Microsoft.Office.WebExtension.Parameters.FieldValue, value: 2 }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetMaxTaskIndexMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.TaskIndex, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({
|
|
type: OSF.DDA.MethodDispId.dispidGetMaxResourceIndexMethod,
|
|
fromHost: [
|
|
{ name: Microsoft.Office.WebExtension.Parameters.ResourceIndex, value: OSF.DDA.SafeArray.Delegate.ParameterMap.self }
|
|
]
|
|
});
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({ type: OSF.DDA.EventDispId.dispidTaskSelectionChangedEvent });
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({ type: OSF.DDA.EventDispId.dispidResourceSelectionChangedEvent });
|
|
|
|
OSF.DDA.SafeArray.Delegate.ParameterMap.define({ type: OSF.DDA.EventDispId.dispidViewSelectionChangedEvent });
|