GPII-228 Capture Settings Backend (Snapshotter 2018)

gpii/node_modules/flowManager/src/Capture.js

@@ -0,0 +1,24 @@
+/**
+ * GPII snapshot Handler
+ *
+ * Copyright 2014 Raising the Floor - International
+ *
+ * Licensed under the New BSD license. You may not use this file except in
+ * compliance with this License.
+ *
+ * You may obtain a copy of the License at
+ * https://github.com/gpii/universal/LICENSE.txt
+ */
+"use strict";
+
+var fluid = require("infusion");
+
+fluid.defaults("gpii.flowManager.capture.handler", {
+    gradeNames: ["kettle.request.http"], //, "gpii.flowManager.sessionAware"],
+    invokers: {
+        handleRequest: {
+            func: "{flowManager}.capture.events.onPrepareCapture.fire",
+            args: ["{request}.events.onSuccess", "{request}.events.onError"]
+        }
+    }
+});

gpii/node_modules/flowManager/src/FlowManager.js

@@ -31,6 +31,7 @@ require("./UntrustedSettingsGetHandler.js");
 require("./UntrustedSettingsPutHandler.js");
 require("./UntrustedSettingsDataSource.js");
 require("./UntrustedFlowManager.js");
+require("./Capture.js");
 
 require("preferencesServer");
 require("lifecycleManager");
@@ -109,6 +110,9 @@ fluid.defaults("gpii.flowManager.local", {
             options: {
                 gradeNames: ["gpii.userListeners"]
             }
+        },
+        capture: {
+            type: "gpii.flowManager.capture"
         }
     },
     requestHandlers: {
@@ -133,6 +137,11 @@ fluid.defaults("gpii.flowManager.local", {
             route: "/gpiiKey",
             method: "get",
             type: "gpii.flowManager.getGpiiKey.handler"
+        },
+        capture: {
+            route: "/capture",
+            method: "get",
+            type: "gpii.flowManager.capture.handler"
         }
     },
     listeners: {
@@ -141,6 +150,94 @@ fluid.defaults("gpii.flowManager.local", {
     }
 });
 
+fluid.defaults("gpii.flowManager.capture", {
+    gradeNames: ["fluid.component"],
+    events: {
+        onPrepareCapture: null,
+        onPrepareSolutions: null,
+        onSolutions: null,
+        onReadyToCapture: {
+            events: {
+                prepareCapture: "onPrepareCapture",
+                prepareSolutions: "onPrepareSolutions",
+                solutions: "onSolutions"
+            },
+            args: [
+                "{arguments}.solutions.0",
+                "{arguments}.prepareCapture.0"
+            ]
+        },
+        onError: null
+    },
+    listeners: {
+        "onPrepareCapture.deviceContext": {
+            funcName: "gpii.flowManager.getDeviceContext",
+            args: ["{flowManager}.deviceReporterDataSource", "{that}.events.onPrepareSolutions"]
+        },
+        onPrepareSolutions: {
+            func: "{that}.getSolutions",
+            args: ["{arguments}.0"]
+        },
+        onReadyToCapture: {
+            func: "{that}.captureSystemSettings",
+            args: ["{arguments}.0", "{arguments}.1"]
+        },
+        onError: {
+            funcName: "console.log",
+            args: ["{arguments}.0"]
+        }
+    },
+    invokers: {
+        getSolutions: {
+            funcName: "gpii.flowManager.getSolutions",
+            args: [ "{flowManager}.solutionsRegistryDataSource", "{arguments}.0", "{that}.events.onSolutions", "{that}.events.onError"] //"{request}.events.onError"]
+        },
+        captureSystemSettings: {
+            funcName: "gpii.flowManager.captureSystemSettings",
+            args: ["{lifecycleManager}.invokeSettingsHandlerGet", "{lifecycleManager}.variableResolver", "{arguments}.0", "{arguments}.1"]
+        }
+    }
+});
+
+
+/**
+ * Runs through all the solutions currently available on the system, pulls the current
+ * setting for each supportedSetting and returns them in an object. Primary use case
+ * is for backing Capture tools that would allow a user to set up their GPII profile
+ * starting with the current settings for their applications on the local machine.
+ *
+ * @param {lifecycleManager.variableResolver} resolver - Resolver for looking up handler specifications
+ * @param {Object} solutions - Solutions registry entries for solutions available on the current machine.
+ * @param {event} event - Event to call with the payload as an argument after processing.
+ * @return Returns nothing. Results are fired as an argument to the `event` argument.
+ */
+gpii.flowManager.captureSystemSettings = function (invokeSettingsHandlerGet, resolver, solutions, event) {
+    var handlerGetPromises = [];
+    fluid.each(solutions, function (solution, solutionID) {
+        var newSolution = gpii.lifecycleManager.transformSolutionSettings(solution, gpii.settingsHandlers.changesToSettings);
+        fluid.each(newSolution.settingsHandlers, function (handlerSpec) {
+            //if applicationSettings is unspecified, dont attempt to get settings
+            if (!handlerSpec.supportedSettings) {
+                return;
+            }
+
+            handlerSpec.settings = handlerSpec.supportedSettings;
+            handlerSpec = resolver.resolve(handlerSpec, {});
+            handlerGetPromises.push(invokeSettingsHandlerGet(solutionID, handlerSpec));
+        });
+    });
+    var promisesSequence = fluid.promise.sequence(handlerGetPromises);
+    promisesSequence.then(function (responses) {
+        console.log("Sequence Ok");
+        // TODO Assemble a better looking payload to send back once we finish
+        // working through the Windows SPI Settings Handler Issues
+        event.fire(responses);
+    }, function (responses) {
+        console.log("Sequence Not Great");
+        event.fire(responses);
+    });
+};
+
 fluid.defaults("gpii.flowManager.save", {
     requestHandlers: {
         userSavePost: {

gpii/node_modules/settingsHandlers/src/NoSettingsHandler.js

@@ -21,4 +21,5 @@ var fluid = require("infusion"),
 
 settingsHandlers.noSettings = fluid.identity;
 settingsHandlers.noSettings.set = fluid.identity;
+settingsHandlers.noSettings.get = fluid.identity;