gpii-universal/gpii/node_modules/deviceReporter/src/DeviceReporter.js

Cross platform, core components of the GPII personalization infrastructure.

/*!
 * Device Reporter
 *
 * Copyright 2012 Raising the Floor - International
 *
 * Licensed under the New BSD license. You may not use this file except in
 * compliance with this License.
 *
 * The research leading to these results has received funding from the European Union's
 * Seventh Framework Programme (FP7/2007-2013)
 * under grant agreement no. 289016.
 *
 * You may obtain a copy of the License at
 * https://github.com/GPII/universal/blob/master/LICENSE.txt
 */

"use strict";

var fluid = require("infusion"),
    os = require("os"),
    gpii = fluid.registerNamespace("gpii");

require("kettle");
require("./DeviceReporterUtilities.js");

fluid.defaults("gpii.deviceReporter", {
    gradeNames: ["fluid.component"],
    components: {
        platformReporter: {
            type: "gpii.platformReporter.native"
        }
    },
    invokers: {
        get: "fluid.notImplemented",
        getFinalPayload: {
            funcName: "gpii.deviceReporter.getFinalPayload",
            args: ["{arguments}.0", "{platformReporter}"]
                   // solutions
        }
    }
});

gpii.deviceReporter.getFinalPayload = function (installedSolutions, platformReporter) {
    return {
        solutions: installedSolutions,
        OS: platformReporter.reportPlatform()
    };
};

// Static Device Reporter
fluid.defaults("gpii.deviceReporter.static", {
    gradeNames: ["gpii.deviceReporter"],
    components: {
        installedSolutionsDataSource: {
            type: "kettle.dataSource.file",
            options: {
                gradeNames: "kettle.dataSource.file.moduleTerms"
            }
        }
    },
    invokers: {
        get: {
            funcName: "gpii.deviceReporter.static.get",
            args: ["{deviceReporter}"]
        }
    }
});

gpii.deviceReporter["static"].get = function (deviceReporter) {
    var promiseTogo = fluid.promise();
    var solutionsPromise = deviceReporter.installedSolutionsDataSource.get();
    solutionsPromise.then(function (solutions) {
        if (!fluid.isDestroyed(deviceReporter)) { // Fix failure for GPII-1227 tests which can receive this response after the deviceReporter is gone
            promiseTogo.resolve(deviceReporter.getFinalPayload(solutions)); // TODO: Remove such checks once FLUID-5790 is resolved
        }
    }, function (err) {
        var error = fluid.extend(err, {
            statusCode: 500,
            message: "Failed to read deviceReporter source: " + err.message,
            isError: true
        });
        promiseTogo.reject(error);
    });
    return promiseTogo;
};

// Dynamic Device Reporter
// TODO: Dynamic Device Reporter has *NO* unit tests

fluid.defaults("gpii.deviceReporter.live.nameResolver", {
    gradeNames: ["fluid.component"],
    invokers: {
        resolveName: {
            funcName: "fluid.identity"
        }
    }
});

fluid.defaults("gpii.deviceReporter.live", {
    gradeNames: ["gpii.deviceReporter"],
    components: {
        // currently in "gpii.config.development.dynamicDR.local" as {flowManager}.solutionsRegistryDataSource
        // solutionsRegistryDataSource:             // should be supplied by integrator
        nameResolver: {
            type: "gpii.deviceReporter.live.nameResolver"
        }
    },
    invokers: {
        get: {
            funcName: "gpii.deviceReporter.live.get",
            args: ["{deviceReporter}", "{solutionsRegistryDataSource}"]
        },
        filterByInstalledSolutions: {
            funcName: "gpii.deviceReporter.filterByInstalledSolutions",
            args: [ "{arguments}.0", "{deviceReporter}" ]
        }
    }
});

gpii.deviceReporter.live.get = function (deviceReporter, solutionsRegistryDataSource) {
    var promiseTogo = fluid.promise();
    var solutionsPromise = solutionsRegistryDataSource.get({
        os: deviceReporter.platformReporter.reportPlatform().id
    });

    solutionsPromise.then(function (entries) {
        var filteredSolutions = deviceReporter.filterByInstalledSolutions(entries);
        promiseTogo.resolve(deviceReporter.getFinalPayload(filteredSolutions));
    }, promiseTogo.reject);

    return promiseTogo;
};

gpii.deviceReporter.filterByInstalledSolutions = function (entries, deviceReporter) {
    var installedSolutions = [];
    fluid.each(entries, function (entry, entryId) {
        if (!installedSolutions.some(function (s) { return s.id === entryId; })) {
            var foundEntryId = fluid.find(entry.isInstalled, function (installedSolutionsReporter) {
                var resolvedName = deviceReporter.nameResolver.resolveName(installedSolutionsReporter.type, "deviceReporter");
                if (fluid.invokeGradedFunction(resolvedName, installedSolutionsReporter)) {
                    return entryId;
                }
            }, null);
            if  (foundEntryId !== null) {
                installedSolutions.push({ "id": foundEntryId });
            }
        }
    });
    return installedSolutions;
};

fluid.defaults("gpii.platformReporter.native", {
    gradeNames: ["fluid.component"],
    invokers: {
        reportPlatform: {
            funcName: "gpii.platformReporter.native.reportPlatform"
        }
    }
});

gpii.platformReporter["native"].reportPlatform = function () { // "native" is a reserved word
    return {
        // TODO: need to report more details - windowmanager, etc.
        id: os.platform(),
        // TODO: Need a better strategy - Node semver fails horribly
        // in the face of the benign underscore (eg. x86_64).
        version: os.release().replace("_", "-")
    };
};