@akylas/nativescript-cli 8.7.2

package/lib/services/analytics/analytics-service.js

@@ -0,0 +1,366 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsService = void 0;
+const path = require("path");
+const _ = require("lodash");
+const decorators_1 = require("../../common/decorators");
+const helpers_1 = require("../../common/helpers");
+const constants_1 = require("../../common/constants");
+const yok_1 = require("../../common/yok");
+class AnalyticsService {
+    constructor($logger, $options, $staticConfig, $prompter, $userSettingsService, $analyticsSettingsService, $childProcess, $projectDataService, $mobileHelper, $projectHelper) {
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$staticConfig = $staticConfig;
+        this.$prompter = $prompter;
+        this.$userSettingsService = $userSettingsService;
+        this.$analyticsSettingsService = $analyticsSettingsService;
+        this.$childProcess = $childProcess;
+        this.$projectDataService = $projectDataService;
+        this.$mobileHelper = $mobileHelper;
+        this.$projectHelper = $projectHelper;
+        this.shouldDisposeInstance = true;
+        this.analyticsStatuses = {};
+    }
+    setShouldDispose(shouldDispose) {
+        this.shouldDisposeInstance = shouldDispose;
+    }
+    checkConsent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.$analyticsSettingsService.canDoRequest()) {
+                const initialTrackFeatureUsageStatus = yield this.getStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
+                let trackFeatureUsage = initialTrackFeatureUsageStatus === "enabled";
+                if ((yield this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) &&
+                    (0, helpers_1.isInteractive)()) {
+                    const message = `Do you want to help us improve ${this.$analyticsSettingsService.getClientName()} by automatically sending anonymous usage statistics? We will not use this information to identify or contact you.`;
+                    trackFeatureUsage = yield this.$prompter.confirm(message, () => false);
+                    yield this.setStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, trackFeatureUsage);
+                    yield this.trackAcceptFeatureUsage({
+                        acceptTrackFeatureUsage: trackFeatureUsage,
+                    });
+                }
+                const isErrorReportingUnset = yield this.isNotConfirmed(this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+                const isUsageReportingConfirmed = !(yield this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME));
+                if (isErrorReportingUnset && isUsageReportingConfirmed) {
+                    yield this.setStatus(this.$staticConfig.ERROR_REPORT_SETTING_NAME, trackFeatureUsage);
+                }
+            }
+        });
+    }
+    setStatus(settingName, enabled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.analyticsStatuses[settingName] = enabled
+                ? "enabled"
+                : "disabled";
+            yield this.$userSettingsService.saveSetting(settingName, enabled.toString());
+        });
+    }
+    isEnabled(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyticsStatus = yield this.getStatus(settingName);
+            return analyticsStatus === "enabled";
+        });
+    }
+    getStatusMessage(settingName, jsonFormat, readableSettingName) {
+        if (jsonFormat) {
+            return this.getJsonStatusMessage(settingName);
+        }
+        return this.getHumanReadableStatusMessage(settingName, readableSettingName);
+    }
+    trackAcceptFeatureUsage(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const acceptTracking = !!(settings && settings.acceptTrackFeatureUsage);
+            const googleAnalyticsEventData = {
+                googleAnalyticsDataType: "event",
+                action: "Accept Tracking",
+                label: acceptTracking.toString(),
+            };
+            yield this.forcefullyTrackInGoogleAnalytics(googleAnalyticsEventData);
+        });
+    }
+    trackInGoogleAnalytics(gaSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initAnalyticsStatuses();
+            if (!this.$staticConfig.disableAnalytics &&
+                this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === "enabled") {
+                return this.forcefullyTrackInGoogleAnalytics(gaSettings);
+            }
+        });
+    }
+    trackEventActionInGoogleAnalytics(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = data.device;
+            const platform = device ? device.deviceInfo.platform : data.platform;
+            const normalizedPlatform = platform
+                ? this.$mobileHelper.normalizePlatformName(platform)
+                : platform;
+            const isForDevice = device ? !device.isEmulator : data.isForDevice;
+            let label = "";
+            label = this.addDataToLabel(label, normalizedPlatform);
+            if (isForDevice !== null && isForDevice !== undefined) {
+                const deviceType = isForDevice
+                    ? constants_1.DeviceTypes.Device
+                    : this.$mobileHelper.isAndroidPlatform(platform)
+                        ? constants_1.DeviceTypes.Emulator
+                        : constants_1.DeviceTypes.Simulator;
+                label = this.addDataToLabel(label, deviceType);
+            }
+            if (device) {
+                label = this.addDataToLabel(label, device.deviceInfo.version);
+            }
+            if (data.additionalData) {
+                label = this.addDataToLabel(label, data.additionalData);
+            }
+            const customDimensions = {};
+            this.setProjectRelatedCustomDimensions(customDimensions, data.projectDir);
+            const googleAnalyticsEventData = {
+                googleAnalyticsDataType: "event",
+                action: data.action,
+                label,
+                customDimensions,
+                value: data.value,
+            };
+            yield this.trackInGoogleAnalytics(googleAnalyticsEventData);
+        });
+    }
+    finishTracking() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (this.brokerProcess && this.brokerProcess.connected) {
+                    let timer;
+                    const handler = (data) => {
+                        if (data === "ProcessFinishedTasks") {
+                            this.brokerProcess.removeListener("message", handler);
+                            clearTimeout(timer);
+                            resolve();
+                        }
+                    };
+                    timer = setTimeout(() => {
+                        this.brokerProcess.removeListener("message", handler);
+                        resolve();
+                    }, 3000);
+                    this.brokerProcess.on("message", handler);
+                    const msg = { type: "FinishTracking" };
+                    this.brokerProcess.send(msg, (err) => this.$logger.trace(`Error while sending ${JSON.stringify(msg)}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    forcefullyTrackInGoogleAnalytics(gaSettings) {
+        gaSettings.customDimensions = gaSettings.customDimensions || {};
+        gaSettings.customDimensions["cd5"] =
+            this.$options.analyticsClient ||
+                ((0, helpers_1.isInteractive)() ? "CLI" : "Unknown");
+        this.setProjectRelatedCustomDimensions(gaSettings.customDimensions);
+        const googleAnalyticsData = _.merge({
+            type: "googleAnalyticsData",
+            category: "CLI",
+        }, gaSettings);
+        this.$logger.trace("Will send the following information to Google Analytics:", googleAnalyticsData);
+        return this.sendMessageToBroker(googleAnalyticsData);
+    }
+    setProjectRelatedCustomDimensions(customDimensions, projectDir) {
+        if (!projectDir) {
+            try {
+                projectDir = this.$projectHelper.projectDir;
+            }
+            catch (err) {
+                this.$logger.trace("Unable to get the projectDir from projectHelper", err);
+            }
+        }
+        if (projectDir) {
+            const projectData = this.$projectDataService.getProjectData(projectDir);
+            customDimensions["cd2"] =
+                projectData.projectType;
+            customDimensions["cd9"] = projectData.isShared.toString();
+        }
+        return customDimensions;
+    }
+    dispose() {
+        if (this.brokerProcess && this.shouldDisposeInstance) {
+            this.brokerProcess.disconnect();
+        }
+    }
+    addDataToLabel(label, newData) {
+        if (newData && label) {
+            return `${label}_${newData}`;
+        }
+        return label || newData || "";
+    }
+    getAnalyticsBroker() {
+        return new Promise((resolve, reject) => {
+            const brokerProcessArgs = this.getBrokerProcessArgs();
+            const broker = this.$childProcess.spawn(process.execPath, brokerProcessArgs, {
+                stdio: ["ignore", "ignore", "ignore", "ipc"],
+                detached: true,
+            });
+            broker.unref();
+            let isSettled = false;
+            const timeoutId = setTimeout(() => {
+                if (!isSettled) {
+                    reject(new Error("Unable to start Analytics Broker process."));
+                }
+            }, AnalyticsService.ANALYTICS_BROKER_START_TIMEOUT);
+            broker.on("error", (err) => {
+                clearTimeout(timeoutId);
+                if (!isSettled) {
+                    isSettled = true;
+                    reject(err);
+                }
+            });
+            broker.on("message", (data) => {
+                if (data === "ProcessReadyToReceive") {
+                    clearTimeout(timeoutId);
+                    if (!isSettled) {
+                        isSettled = true;
+                        this.brokerProcess = broker;
+                        resolve(broker);
+                    }
+                }
+            });
+        });
+    }
+    getBrokerProcessArgs() {
+        const brokerProcessArgs = [
+            path.join(__dirname, "analytics-broker-process.js"),
+            this.$staticConfig.PATH_TO_BOOTSTRAP,
+        ];
+        if (this.$options.analyticsLogFile) {
+            brokerProcessArgs.push(this.$options.analyticsLogFile);
+        }
+        return brokerProcessArgs;
+    }
+    sendInfoForTracking(trackingInfo, settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initAnalyticsStatuses();
+            if (!this.$staticConfig.disableAnalytics &&
+                this.analyticsStatuses[settingName] === "enabled") {
+                return this.sendMessageToBroker(trackingInfo);
+            }
+        });
+    }
+    sendMessageToBroker(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let broker;
+            try {
+                broker = yield this.getAnalyticsBroker();
+            }
+            catch (err) {
+                this.$logger.trace("Unable to get broker instance due to error: ", err);
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                if (broker && broker.connected) {
+                    try {
+                        broker.send(message, (error) => resolve());
+                    }
+                    catch (err) {
+                        this.$logger.trace("Error while trying to send message to broker:", err);
+                        resolve();
+                    }
+                }
+                else {
+                    this.$logger.trace("Broker not found or not connected.");
+                    resolve();
+                }
+            });
+        });
+    }
+    initAnalyticsStatuses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.$analyticsSettingsService.canDoRequest()) {
+                this.$logger.trace("Initializing analytics statuses.");
+                const settingsNames = [
+                    this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME,
+                    this.$staticConfig.ERROR_REPORT_SETTING_NAME,
+                ];
+                for (const settingName of settingsNames) {
+                    yield this.getStatus(settingName);
+                }
+                this.$logger.trace("Analytics statuses: ", this.analyticsStatuses);
+            }
+        });
+    }
+    getStatus(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!_.has(this.analyticsStatuses, settingName)) {
+                const settingValue = yield this.$userSettingsService.getSettingValue(settingName);
+                if (settingValue) {
+                    const isEnabled = (0, helpers_1.toBoolean)(settingValue);
+                    if (isEnabled) {
+                        this.analyticsStatuses[settingName] = "enabled";
+                    }
+                    else {
+                        this.analyticsStatuses[settingName] = "disabled";
+                    }
+                }
+                else {
+                    this.analyticsStatuses[settingName] = "not confirmed";
+                }
+            }
+            return this.analyticsStatuses[settingName];
+        });
+    }
+    isNotConfirmed(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyticsStatus = yield this.getStatus(settingName);
+            return analyticsStatus === "not confirmed";
+        });
+    }
+    getHumanReadableStatusMessage(settingName, readableSettingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let status = null;
+            if (yield this.isNotConfirmed(settingName)) {
+                status = "disabled until confirmed";
+            }
+            else {
+                status = yield this.getStatus(settingName);
+            }
+            return `${readableSettingName} is ${status}.`;
+        });
+    }
+    getJsonStatusMessage(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield this.getStatus(settingName);
+            const enabled = status === "not confirmed"
+                ? null
+                : status === "enabled";
+            return JSON.stringify({ enabled });
+        });
+    }
+    trackException(exception, message) {
+        const data = {
+            type: "exception",
+            exception,
+            message,
+        };
+        return this.sendInfoForTracking(data, this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+    }
+}
+AnalyticsService.ANALYTICS_BROKER_START_TIMEOUT = 10 * 1000;
+__decorate([
+    (0, decorators_1.cache)()
+], AnalyticsService.prototype, "getAnalyticsBroker", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AnalyticsService.prototype, "initAnalyticsStatuses", null);
+exports.AnalyticsService = AnalyticsService;
+yok_1.injector.register("analyticsService", AnalyticsService);

package/lib/services/analytics/analytics.d.ts

@@ -0,0 +1,55 @@
+import { TrackingTypes } from "../../common/declarations";
+import { IGoogleAnalyticsData } from "../../common/definitions/google-analytics";
+
+/**
+ * Describes the information that will be passed to analytics for tracking.
+ */
+interface ITrackingInformation {
+	/**
+	 * The type of the data sent to analytics service - initalization data, feature to be tracked, error to be tracked, etc.
+	 */
+	type: TrackingTypes;
+}
+
+/**
+ * Describes information for exception that should be tracked.
+ */
+interface IExceptionsTrackingInformation extends ITrackingInformation {
+	/**
+	 * The exception that should be tracked.
+	 */
+	exception: Error;
+
+	/**
+	 * The message of the error that should be tracked.
+	 */
+	message: string;
+}
+
+/**
+ * Describes the broker used to pass information to all analytics providers.
+ */
+interface IAnalyticsBroker {
+	/**
+	 * Sends the specified tracking information to all providers.
+	 * @param {ITrackingInformation} trackInfo The information that should be passed to all providers.
+	 * @returns {Promise<void>}
+	 */
+	sendDataForTracking(trackInfo: ITrackingInformation): Promise<void>;
+}
+
+interface IGoogleAnalyticsTrackingInformation
+	extends IGoogleAnalyticsData,
+		ITrackingInformation {}
+
+/**
+ * Describes methods required to track in Google Analytics.
+ */
+interface IGoogleAnalyticsProvider {
+	/**
+	 * Tracks hit types.
+	 * @param {IGoogleAnalyticsData} data Data that has to be tracked.
+	 * @returns {Promise<void>}
+	 */
+	trackHit(data: IGoogleAnalyticsData): Promise<void>;
+}

package/lib/services/analytics/google-analytics-cross-client-custom-dimensions.d.ts

@@ -0,0 +1,6 @@
+// Sync indexes with the custom dimensions of the cross client analytics project
+declare const enum GoogleAnalyticsCrossClientCustomDimensions {
+	sessionId = "cd9",
+	clientId = "cd10",
+	crossClientId = "cd12",
+}

package/lib/services/analytics/google-analytics-provider.js

@@ -0,0 +1,152 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAnalyticsProvider = void 0;
+const uuid_1 = require("uuid");
+const ua = require("universal-analytics");
+const decorators_1 = require("../../common/decorators");
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class GoogleAnalyticsProvider {
+    constructor(clientId, $staticConfig, $analyticsSettingsService, $logger, $proxyService, $config, analyticsLoggingService) {
+        this.clientId = clientId;
+        this.$staticConfig = $staticConfig;
+        this.$analyticsSettingsService = $analyticsSettingsService;
+        this.$logger = $logger;
+        this.$proxyService = $proxyService;
+        this.$config = $config;
+        this.analyticsLoggingService = analyticsLoggingService;
+    }
+    trackHit(trackInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionId = (0, uuid_1.v4)();
+            try {
+                yield this.track(this.$config.GA_TRACKING_ID, trackInfo, sessionId);
+            }
+            catch (e) {
+                this.analyticsLoggingService.logData({
+                    type: "Error",
+                    message: `Unable to track information ${JSON.stringify(trackInfo)}. Error is: ${e}`,
+                });
+                this.$logger.trace("Analytics exception: ", e);
+            }
+        });
+    }
+    getVisitor(gaTrackingId, proxy) {
+        this.analyticsLoggingService.logData({
+            message: `Initializing Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.`,
+        });
+        const visitor = ua({
+            tid: gaTrackingId,
+            cid: this.clientId,
+            headers: {
+                ["User-Agent"]: this.$analyticsSettingsService.getUserAgentString(`tnsCli/${this.$staticConfig.version}`),
+            },
+            requestOptions: {
+                proxy,
+            },
+            https: true,
+        });
+        this.analyticsLoggingService.logData({
+            message: `Successfully initialized Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.`,
+        });
+        return visitor;
+    }
+    track(gaTrackingId, trackInfo, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proxySettings = yield this.$proxyService.getCache();
+            const proxy = proxySettings && proxySettings.proxy;
+            const visitor = this.getVisitor(gaTrackingId, proxy);
+            yield this.setCustomDimensions(visitor, trackInfo.customDimensions, sessionId);
+            switch (trackInfo.googleAnalyticsDataType) {
+                case "pageview":
+                    yield this.trackPageView(visitor, trackInfo);
+                    break;
+                case "event":
+                    yield this.trackEvent(visitor, trackInfo);
+                    break;
+            }
+        });
+    }
+    setCustomDimensions(visitor, customDimensions, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultValues = {
+                ["cd1"]: this.$staticConfig.version,
+                ["cd6"]: process.version,
+                ["cd3"]: this.clientId,
+                ["cd2"]: null,
+                ["cd9"]: null,
+                ["cd4"]: sessionId,
+                ["cd5"]: "Unknown",
+            };
+            customDimensions = _.merge(defaultValues, customDimensions);
+            _.each(customDimensions, (value, key) => {
+                this.analyticsLoggingService.logData({
+                    message: `Setting custom dimension ${key} to value ${value}`,
+                });
+                visitor.set(key, value);
+            });
+        });
+    }
+    trackEvent(visitor, trackInfo) {
+        return new Promise((resolve, reject) => {
+            visitor.event(trackInfo.category, trackInfo.action, trackInfo.label, trackInfo.value, { p: this.currentPage }, (err) => {
+                if (err) {
+                    this.analyticsLoggingService.logData({
+                        message: `Unable to track event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', ` +
+                            `value: '${trackInfo.value}' attached page: ${this.currentPage}. Error is: ${err}.`,
+                        type: "Error",
+                    });
+                    reject(err);
+                    return;
+                }
+                this.analyticsLoggingService.logData({
+                    message: `Tracked event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', value: '${trackInfo.value}' attached page: ${this.currentPage}.`,
+                });
+                resolve();
+            });
+        });
+    }
+    trackPageView(visitor, trackInfo) {
+        return new Promise((resolve, reject) => {
+            this.currentPage = trackInfo.path;
+            const pageViewData = {
+                dp: trackInfo.path,
+                dt: trackInfo.title,
+            };
+            visitor.pageview(pageViewData, (err) => {
+                if (err) {
+                    this.analyticsLoggingService.logData({
+                        message: `Unable to track pageview with path '${trackInfo.path}' and title: '${trackInfo.title}' Error is: ${err}.`,
+                        type: "Error",
+                    });
+                    reject(err);
+                    return;
+                }
+                this.analyticsLoggingService.logData({
+                    message: `Tracked pageview with path '${trackInfo.path}' and title: '${trackInfo.title}'.`,
+                });
+                resolve();
+            });
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], GoogleAnalyticsProvider.prototype, "getVisitor", null);
+exports.GoogleAnalyticsProvider = GoogleAnalyticsProvider;
+yok_1.injector.register("googleAnalyticsProvider", GoogleAnalyticsProvider);

package/lib/services/analytics-settings-service.js

@@ -0,0 +1,104 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../common/helpers");
+const decorators_1 = require("../common/decorators");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+const color_1 = require("../color");
+class AnalyticsSettingsService {
+    constructor($userSettingsService, $staticConfig, $hostInfo, $osInfo, $logger) {
+        this.$userSettingsService = $userSettingsService;
+        this.$staticConfig = $staticConfig;
+        this.$hostInfo = $hostInfo;
+        this.$osInfo = $osInfo;
+        this.$logger = $logger;
+    }
+    canDoRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    getUserId() {
+        return this.getSettingValueOrDefault("USER_ID");
+    }
+    getClientId() {
+        return this.getSettingValueOrDefault(this.$staticConfig.ANALYTICS_INSTALLATION_ID_SETTING_NAME);
+    }
+    getClientName() {
+        return "" + color_1.color.cyan.bold(this.$staticConfig.CLIENT_NAME_ALIAS);
+    }
+    getUserSessionsCount(projectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionsCountForProject = yield this.$userSettingsService.getSettingValue(this.getSessionsProjectKey(projectName));
+            return sessionsCountForProject || 0;
+        });
+    }
+    setUserSessionsCount(count, projectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$userSettingsService.saveSetting(this.getSessionsProjectKey(projectName), count);
+        });
+    }
+    getUserAgentString(identifier) {
+        let osString = "";
+        const osRelease = this.$osInfo.release();
+        if (this.$hostInfo.isWindows) {
+            osString = `Windows NT ${osRelease}`;
+        }
+        else if (this.$hostInfo.isDarwin) {
+            osString = `Macintosh`;
+            const macRelease = this.getMacOSReleaseVersion(osRelease);
+            if (macRelease) {
+                osString += `; Intel Mac OS X ${macRelease}`;
+            }
+        }
+        else {
+            osString = `Linux x86`;
+            if (this.$osInfo.arch() === "x64") {
+                osString += "_64";
+            }
+        }
+        const userAgent = `${identifier} (${osString}; ${this.$osInfo.arch()})`;
+        return userAgent;
+    }
+    getMacOSReleaseVersion(osRelease) {
+        const majorVersion = osRelease && _.first(osRelease.split("."));
+        return majorVersion && `10.${+majorVersion - 4}`;
+    }
+    getSessionsProjectKey(projectName) {
+        return `${AnalyticsSettingsService.SESSIONS_STARTED_KEY_PREFIX}${projectName}`;
+    }
+    getSettingValueOrDefault(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let guid = yield this.$userSettingsService.getSettingValue(settingName);
+            if (!guid) {
+                guid = (0, helpers_1.createGUID)(false);
+                this.$logger.trace(`Setting new ${settingName}: ${guid}.`);
+                yield this.$userSettingsService.saveSetting(settingName, guid);
+            }
+            return guid;
+        });
+    }
+}
+AnalyticsSettingsService.SESSIONS_STARTED_KEY_PREFIX = "SESSIONS_STARTED_";
+__decorate([
+    (0, decorators_1.exported)("analyticsSettingsService")
+], AnalyticsSettingsService.prototype, "getClientId", null);
+__decorate([
+    (0, decorators_1.exported)("analyticsSettingsService")
+], AnalyticsSettingsService.prototype, "getUserAgentString", null);
+yok_1.injector.register("analyticsSettingsService", AnalyticsSettingsService);