gpii.pcpChannel.sessionToPCP = function (model, transformSpec) {
var schemas = transformSpec.ontologyMetadata.flat.schemas;
var outModel = fluid.filterKeys(model, ["userToken", "activeContextName"]);
var settingControls = {};
var activePreferences = fluid.get(model, ["preferences", "contexts", model.activeContextName, "preferences"]);
var prefApplicationPrefix = "http://registry.gpii.net/applications/";
fluid.each(activePreferences, function (prefsVal, prefsKey) {
if (prefsKey.startsWith(prefApplicationPrefix)) {
var solKey = prefsKey.substring(prefApplicationPrefix.length);
var solution = model.solutionsRegistryEntries[solKey];
if (solution) {
fluid.each(prefsVal, function (innerPrefsVal, innerPrefsKey) {
gpii.pcpChannel.emitSettingControl(settingControls, schemas[innerPrefsKey], innerPrefsVal, [prefsKey, innerPrefsKey], solution.name);
});
}
} else {
gpii.pcpChannel.emitSettingControl(settingControls, schemas[prefsKey], prefsVal, [prefsKey]);
}
});
outModel.settingControls = settingControls;
outModel.preferences = {
name: fluid.get(model, "preferences.name"),
contexts: fluid.transform(fluid.get(model, "preferences.contexts"), function (contextVal) {
return fluid.filterKeys(contextVal, ["name"]);
})
};
return outModel;
};
gpii.pspChannel.sessionToPSP = function (model, transformSpec) {
var schemas = transformSpec.ontologyMetadata.flat.schemas;
var outModel = fluid.filterKeys(model, ["gpiiKey", "activeContextName"]);
var settingControls = {};
var activePreferences = fluid.get(model, ["preferences", "contexts", model.activeContextName, "preferences"]);
var prefApplicationPrefix = "http://registry.gpii.net/applications/";
fluid.each(activePreferences, function (prefsVal, prefsKey) {
if (prefsKey.startsWith(prefApplicationPrefix)) {
var solKey = prefsKey.substring(prefApplicationPrefix.length);
var solution = model.solutionsRegistryEntries[solKey];
if (solution) {
fluid.each(prefsVal, function (innerPrefsVal, innerPrefsKey) {
var liveness = gpii.matchMakerFramework.utils.getLeastLiveness([ solution ], innerPrefsKey);
gpii.pspChannel.emitSettingControl(settingControls, schemas[innerPrefsKey], innerPrefsVal, [prefsKey, innerPrefsKey], liveness, solution.name);
});
}
} else {
var activeSolutionIds = Object.keys(fluid.get(model, "activeConfiguration.inferredConfiguration.applications"));
var activeSolutions = fluid.filterKeys(model.solutionsRegistryEntries, activeSolutionIds);
var liveness = gpii.matchMakerFramework.utils.getLeastLiveness(activeSolutions, prefsKey);
gpii.pspChannel.emitSettingControl(settingControls, schemas[prefsKey], prefsVal, [prefsKey], liveness);
}
});
outModel.settingControls = settingControls;
outModel.preferences = {
name: fluid.get(model, "preferences.name"),
contexts: fluid.transform(fluid.get(model, "preferences.contexts"), function (contextVal) {
return fluid.filterKeys(contextVal, ["name"]);
})
};
return outModel;
};
gpii.tests.settingsDataSource.assertInitialAccessToken = function (that, settingsDataSource, isExpired) {
var initialAccessToken = fluid.get(settingsDataSource, ["accessTokens", gpii.tests.settingsDataSource.gpiiKey, "accessToken"]);
var initialTimestampExpires = fluid.get(settingsDataSource, ["accessTokens", gpii.tests.settingsDataSource.gpiiKey, "timestampExpires"]);
jqUnit.assertValue("A saved access token is in place", initialAccessToken);
jqUnit[isExpired ? "assertTrue" : "assertFalse"]("A saved access token is not expired", gpii.oauth2.getExpiresIn(new Date(), initialTimestampExpires) === 0);
that.initialSavedAccessToken = initialAccessToken;
that.initialSavedTimestampExpires = initialTimestampExpires;
};
gpii.settingsHandlers.webSockets.addClient = function (that, solutionId, client) {
var initialSettings = fluid.get(that.model.settings, [solutionId]);
var currentValue = fluid.get(that.clients, [solutionId, client.id]);
if (!currentValue) {
fluid.set(that.clients, [solutionId, client.id], client);
client.sendTypedMessage("connectionSucceeded", initialSettings);
client.events.onDestroy.addListener(function () {
that.removeClient(client);
});
}
};
request.getSolutions = function (matchMaker, event, model) {
var device = model.device,
os = fluid.get(device, "OS.id"),
version = fluid.get(device, "OS.version");
matchMaker.solutionsReporter.get({
os: os,
version: version
}, function (solutions) {
matchMaker.prefilterSolutions(solutions, os, version);
solutions = matchMaker.prefilterSolutions(solutions, device);
event.fire(solutions);
});
};
return fluid.transform(changeMap, function (value, key) {
if (fluid.isPlainObject(value)) {
return inspect(value, path + (path && ".") + key);
} else {
// fluid.get can't support 0 length key names.
var exp = fluid.get(expected, path);
var act = fluid.get(actual, path);
return {
expected: exp && exp[key] || undefined,
actual: act && act[key] || undefined
};
}
});
clientPromise.then(function (client) {
if (client && fluid.get(client, ["oauth2ClientSecret"]) === expectedOauth2ClientSecret) {
promiseTogo.resolve(client);
} else {
fluid.log("clientService: unauthorized client with oauth2ClientId - " + oauth2ClientId);
promiseTogo.reject(gpii.oauth2.errors.unauthorized);
}
}, function (err) {
fluid.remove_if(solutions, function (solution) {
var solutionOSVersion = fluid.find(fluid.get(solution, "contexts.OS"), function(OSEntry) {
return OSEntry.id === os ? OSEntry.version : undefined;
});
if (!semver.satisfies(version, solutionOSVersion)) {
return true;
}
});
gpii.tests.singleInstance.resolveReferences = function (model, value) {
if (typeof(value) === "string") {
return value.charAt(0) === "$" ? fluid.get(model, value.substring(1)) : value;
} else {
return fluid.transform(value, function (obj) {
return gpii.tests.singleInstance.resolveReferences(model, obj);
});
}
};
gpii.flowManager.getSolutions = function (solutionsRegistryDataSource, deviceContext, event, onError) {
var os = fluid.get(deviceContext, "OS.id");
var promise = solutionsRegistryDataSource.get({});
promise.then(function (solutions) {
var solutionsRegistryEntries = gpii.matchMakerFramework.filterSolutions(solutions[os], deviceContext);
fluid.log("Fetched filtered solutions registry entries: ", gpii.renderMegapayload({solutionsRegistryEntries: solutionsRegistryEntries}));
event.fire(solutionsRegistryEntries, solutions);
}, onError.fire);
};
gpii.settingsHandlers.exploding.impl = function (operation, settings, options) {
if (options && options.launchHandler && operation === "set") {
gpii.settingsHandlers.exploding.runningState.running = settings.running;
var launchOperation = settings.running ? "launch" : "stop";
var launchSettings = fluid.get(options, ["preferences", "contexts", "gpii-default", "preferences", "http://registry.gpii.net/applications/net.gpii.explode"]);
return gpii.settingsHandlers.exploding.determineExplode(launchOperation, launchSettings, settings);
} else {
return gpii.settingsHandlers.exploding.determineExplode(operation, settings, settings);
}
};
gpii.preferencesServer.old.get.buildReturnPayload = function (rawPrefs, ontologyHandler, request, requestProxy) {
fluid.log("Raw preferences fetched by old PreferencesServer: " + JSON.stringify(rawPrefs, null, 2));
var fullPrefs = ontologyHandler.rawPrefsToOntology(rawPrefs, "flat");
var prefs = fluid.get(fullPrefs, "contexts.gpii-default.preferences");
var togo = (!prefs) ? {} : {
userToken: request.req.params.userToken,
preferences: gpii.preferencesServer.old.get.newFlatToOldFlat(prefs)
};
requestProxy.events.onSuccess.fire(togo);
};
gpii.contextManager.evaluateMatch = function (that, matchMakerResponse) {
var contextPayload = $.extend({}, matchMakerResponse);
var matchMakerOutput = matchMakerResponse.matchMakerOutput;
var activeContexts = gpii.contextManager.utils.findActiveContexts(fluid.get(that.model, "currentContext"), matchMakerOutput);
// save highest priority context as the applied one
contextPayload.activeContextName = activeContexts[0];
contextPayload.activeConfiguration = $.extend(true, {}, matchMakerOutput.inferredConfiguration[contextPayload.activeContextName]);
return contextPayload;
};
var results = fluid.transform(payload.settings, function (value, key) {
var oldValue = fluid.get(that.model.settings, [path, key]);
var type;
if (oldValue === undefined) {
type = "ADD";
} else if (value === undefined) {
type = "DELETE";
} else {
type = null;
}
that.applier.change(["settings", path, key], value, type);
var newValue = fluid.get(that.model.settings, [path, key]);
return {
oldValue: oldValue,
newValue: newValue
};
});
var map = fluid.transform(termMap, function resolve(entry) {
entry = String(entry);
var encode = !noencode;
if (entry.indexOf("noencode:") === 0) {
encode = false;
entry = entry.substring("noencode:".length);
}
var value = entry.charAt(0) === "%" ? fluid.get(directModel, entry.substring(1)) : entry;
if (encode) {
value = encodeURIComponent(value);
}
return value;
});
gpii.iniFile.read.gotValue = function (state, sectionPath, key, value, quoted) {
// Ignore the value if it's already set, if only setting first duplicates.
var set = !state.options.firstDuplicate || (fluid.get(state.result, sectionPath.concat(key), value) === undefined);
if (!state.options.strings && !quoted) {
// Try to convert it to a non-string value.
if (/^([0-9]+|true|false|null)$/.test(value)) {
value = JSON.parse(value);
}
}
if (set) {
fluid.set(state.result, sectionPath.concat(key), value);
}
};
gpii.iniFile.read.sectionBegin = function (state, sectionPath) {
var existing = sectionPath.length && fluid.get(state.result, sectionPath);
if (existing) {
if (fluid.isPlainObject(existing)) {
fluid.log("iniFile - Warning: Merging sections with duplicate name: ",
sectionPath.join("."));
} else {
fluid.log("iniFile - Warning: Overwriting key=value with section of the same name: ",
sectionPath.join("."));
fluid.set(state.result, sectionPath, {});
}
}
};
gpii.flowManager.untrustedSettingsDataSource.findValidAccessToken = function (that, gpiiKey) {
var allAccessTokens = that.accessTokens;
var accessToken = fluid.get(allAccessTokens, [gpiiKey, "accessToken"]);
var expiresIn = gpii.oauth2.getExpiresIn(new Date(), fluid.get(allAccessTokens, [gpiiKey, "timestampExpires"]));
// If the locally saved access token exists and is still valid, return it.
// Otherwise, request an new access token from the cloud and return.
// The new access token is saved locally for the continuing use.
if (!accessToken || !expiresIn || expiresIn < that.options.minAccessTokenLifeTimeInSecond) {
var accessTokenPromise = that.accessRequester.getAccessToken(gpiiKey);
var mapper = function (accessTokenObj) {
var accessTokenFromCloud = accessTokenObj.access_token;
var timestampExpiresFromCloud = gpii.oauth2.getTimestampExpires(new Date(), accessTokenObj.expiresIn);
that.save(gpiiKey, accessTokenFromCloud, timestampExpiresFromCloud);
return accessTokenFromCloud;
};
return fluid.promise.map(accessTokenPromise, mapper);
} else {
return fluid.promise().resolve(accessToken);
}
};
map = fluid.transform(map, function (entry) {
var encode = false;
if (entry.indexOf(eUC) === 0) {
encode = true;
entry = entry.substring(eUC.length);
}
if (entry.charAt(0) === "%") {
entry = fluid.get(directModel, entry.substring(1));
}
if (encode) {
entry = encodeURIComponent(entry);
}
return entry;
});
gpii.iniFile.write.sectionBegin = function (state, sectionPath) {
var output = [];
if (sectionPath.length > 0) {
// Add the values to the previous section that haven't already been added.
fluid.each(gpii.iniFile.getUnwrittenValues(state, state.currentPath, false), function (tuple) {
output.push.apply(output, gpii.iniFile.writeValue(tuple.key, tuple.value, sectionPath, state.options));
});
}
state.currentPath = sectionPath.slice();
state.currentSection = fluid.get(state.data, state.currentPath);
state.currentPathString = state.currentPath.join(state.pathSep);
state.valuesWritten[state.currentPathString] = true;
return output.length && (output.join(state.options.eol) + state.options.eol);
};
fluid.each(activePreferences, function (prefsVal, prefsKey) {
if (prefsKey.startsWith(prefApplicationPrefix)) {
var solKey = prefsKey.substring(prefApplicationPrefix.length);
var solution = model.solutionsRegistryEntries[solKey];
if (solution) {
fluid.each(prefsVal, function (innerPrefsVal, innerPrefsKey) {
var liveness = gpii.matchMakerFramework.utils.getLeastLiveness([ solution ], innerPrefsKey);
gpii.pspChannel.emitSettingControl(settingControls, schemas[innerPrefsKey], innerPrefsVal, [prefsKey, innerPrefsKey], liveness, solution.name);
});
}
} else {
var activeSolutionIds = Object.keys(fluid.get(model, "activeConfiguration.inferredConfiguration.applications"));
var activeSolutions = fluid.filterKeys(model.solutionsRegistryEntries, activeSolutionIds);
var liveness = gpii.matchMakerFramework.utils.getLeastLiveness(activeSolutions, prefsKey);
gpii.pspChannel.emitSettingControl(settingControls, schemas[prefsKey], prefsVal, [prefsKey], liveness);
}
});
gpii.lifecycleManager.userLogonHandling.startLifecycle = function (that, lifecycleManager, lifecyclePayload, event) {
gpii.logFully("userLogonHandling.startLifecycle got final payload ", gpii.renderMegapayload(lifecyclePayload));
if (that.options.defaultLifecycleInstructions && lifecyclePayload.gpiiKey !== "noUser") {
// Merge the default snapshot with current key's lifecycle instructions to combine the key in action
// with "reset all" functionality
fluid.set(lifecyclePayload, ["activeConfiguration", "lifecycleInstructions"], fluid.extend(
true, {}, that.options.defaultLifecycleInstructions, fluid.get(lifecyclePayload, ["activeConfiguration", "lifecycleInstructions"])
));
}
var promise = lifecycleManager.start(lifecyclePayload);
promise.then(function () {
gpii.lifecycleManager.userLogonHandling.updateLogonChangeModel(lifecycleManager, lifecyclePayload.gpiiKey, "login", false);
event.fire("User with GPII key " + lifecyclePayload.gpiiKey + " was successfully logged in.");
}, function (error) {
fluid.log(fluid.logLevel.FAIL, "Error returned from lifecycle manager: ", error);
lifecycleManager.errorResponse(that, "Error occurred during login: " + error.message);
});
};
gpii.contextManager.updateActiveContextName = function (that, fullPayload, forceContextName) {
var matchMakerOutput = fullPayload.matchMakerOutput;
var newActiveContextName;
if (forceContextName === undefined) {
if (fullPayload.forcedContext) { // Don't compute conditions if context has been forced
newActiveContextName = fullPayload.activeContextName;
} else {
var activeContexts = gpii.contextManager.utils.findActiveContexts(fluid.get(that.model, "currentEnvironment"), matchMakerOutput);
// save highest priority context as the applied one
newActiveContextName = activeContexts[0];
}
} else {
newActiveContextName = forceContextName;
fullPayload.forcedContext = true;
}
fullPayload.activeContextName = newActiveContextName;
return fullPayload;
};
gpii.iniFile.getUnwrittenValues = function (state, sectionPath, subSections) {
var items = [];
var section = fluid.get(state.data, sectionPath);
if (section) {
var allKeys = Object.keys(section);
var path = sectionPath.length ? sectionPath.join(state.pathSep) + state.pathSep : "";
fluid.each(allKeys, function (key) {
if (!state.valuesWritten[path + key]) {
var value = section[key];
if (fluid.isPlainObject(value) === !!subSections) {
items.push({
key: key,
value: value
});
}
}
});
}
return items;
};
gpii.lifecycleManager.responseToSnapshot = function (solutionId, handlerResponse) {
var unValued = fluid.model.transform(handlerResponse, gpii.lifecycleManager.responseToSnapshotRules,
{isomorphic: true});
// TODO: Should eventually be able to do this final stage through transformation too
return fluid.get(unValued, fluid.model.escapedPath(solutionId, "0"), fluid.model.escapedGetConfig);
};
var results = fluid.transform(payload.settings, function (value, key) {
var currentValue = fluid.get(that.model.settings, [path, key]);
return currentValue;
});
gpii.settingsHandlers.webSockets.getSettingsForId = function (that, solutionId) {
return fluid.get(that.model.settings, [solutionId]);
};
return function (parsed) {
var resolver = resolvers[parsed.context];
return !resolver? undefined : (
typeof(resolver) === "function" ? resolver(parsed.path) : fluid.get(resolver, parsed.path));
};
gpii.test.cloudBased.oauth2.verifyFieldInResponse = function (response, request, funcName, fieldName) {
var fieldValue = fluid.get(response, fieldName);
fluid.log(funcName + " Got " + fieldName + ": ", fieldValue);
jqUnit.assertValue("Should have received " + fieldName, fieldValue);
fluid.set(request, fieldName, fieldValue);
};
gpii.test.cloudBased.oauth2.filter = function (model, options, filterName) {
var changes = fluid.get(options, [filterName, "changes"]);
fluid.log("cloudBased.oauth2.filter fetched changes " + JSON.stringify(changes, null, 2) + " for filter name " + filterName);
return changes ? gpii.test.cloudBased.oauth2.filterModel(model, changes) : model;
};