feat: add caching for getting company information

Add local caching in a file when getting the company information. This allows us to minimize the number of calls to external services. As the companyInsightsService now uses multiple other services and is also exposed publically, rename it to companyInsightsController.
Set the expiration of the cache to 2 days.

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -67,7 +67,7 @@ $injector.require("userSettingsService", "./services/user-settings-service");
 $injector.requirePublic("analyticsSettingsService", "./services/analytics-settings-service");
 $injector.require("analyticsService", "./services/analytics/analytics-service");
 $injector.require("googleAnalyticsProvider", "./services/analytics/google-analytics-provider");
-$injector.requirePublicClass("companyInsightsService", "./services/company-insights-service");
+$injector.requirePublicClass("companyInsightsController", "./controllers/company-insights-controller");
 
 $injector.require("platformCommandParameter", "./platform-command-param");
 $injector.requireCommand("create", "./commands/create-project");

lib/controllers/company-insights-controller.ts

@@ -0,0 +1,89 @@
+import { AnalyticsEventLabelDelimiter } from "../constants";
+import { cache } from "../common/decorators";
+import * as path from "path";
+
+export class CompanyInsightsController implements ICompanyInsightsController {
+	private static CACHE_TIMEOUT = 48 * 60 * 60 * 1000; // 2 days in milliseconds
+	private get $jsonFileSettingsService(): IJsonFileSettingsService {
+		return this.$injector.resolve<IJsonFileSettingsService>("jsonFileSettingsService", {
+			jsonFileSettingsPath: path.join(this.$settingsService.getProfileDir(), "company-insights-data.json")
+		});
+	}
+
+	constructor(private $config: IConfiguration,
+		private $httpClient: Server.IHttpClient,
+		private $injector: IInjector,
+		private $ipService: IIPService,
+		private $logger: ILogger,
+		private $settingsService: ISettingsService) { }
+
+	public async getCompanyData(): Promise<ICompanyData> {
+		let companyData: ICompanyData = null;
+		const { currentPublicIP, cacheKey } = await this.getIPInfo();
+
+		companyData = await this.getCompanyDataFromCache(cacheKey);
+
+		if (!companyData) {
+			companyData = await this.getCompanyDataFromPlaygroundInsightsEndpoint();
+			if (companyData && currentPublicIP) {
+				await this.$jsonFileSettingsService.saveSetting<ICompanyData>(cacheKey, companyData, { useCaching: true });
+			}
+		}
+
+		return companyData;
+	}
+
+	private async getIPInfo(): Promise<{ currentPublicIP: string, cacheKey: string }> {
+		let currentPublicIP: string = null;
+		let keyInJsonFile: string = null;
+
+		try {
+			currentPublicIP = await this.$ipService.getCurrentIPv4Address();
+			keyInJsonFile = `companyInformation_${currentPublicIP}`;
+		} catch (err) {
+			this.$logger.trace(`Unable to get current public ip address. Error is: `, err);
+		}
+
+		return { currentPublicIP, cacheKey: keyInJsonFile };
+	}
+
+	private async getCompanyDataFromCache(keyInJsonFile: string): Promise<ICompanyData> {
+		let companyData: ICompanyData = null;
+
+		try {
+			if (keyInJsonFile) {
+				companyData = await this.$jsonFileSettingsService.getSettingValue<ICompanyData>(keyInJsonFile, { cacheTimeout: CompanyInsightsController.CACHE_TIMEOUT });
+			}
+		} catch (err) {
+			this.$logger.trace(`Unable to get data from file, error is:`, err);
+		}
+
+		return companyData;
+	}
+
+	@cache()
+	private async getCompanyDataFromPlaygroundInsightsEndpoint(): Promise<ICompanyData> {
+		let companyData: ICompanyData = null;
+
+		try {
+			const response = await this.$httpClient.httpRequest(this.$config.INSIGHTS_URL_ENDPOINT);
+			const data = <IPlaygroundInsightsEndpointData>(JSON.parse(response.body));
+			if (data.company) {
+				const industries = _.isArray(data.company.industries) ? data.company.industries.join(AnalyticsEventLabelDelimiter) : null;
+				companyData = {
+					name: data.company.name,
+					country: data.company.country,
+					revenue: data.company.revenue,
+					employeeCount: data.company.employeeCount,
+					industries
+				};
+			}
+		} catch (err) {
+			this.$logger.trace(`Unable to get data for company. Error is: ${err}`);
+		}
+
+		return companyData;
+	}
+}
+
+$injector.register("companyInsightsController", CompanyInsightsController);

lib/definitions/company-insights-service.d.ts renamed to lib/definitions/company-insights-controller.d.ts

@@ -50,7 +50,7 @@ interface IPlaygroundInsightsEndpointData {
 /**
  * Describes the service that can be used to get insights about the company using the CLI.
  */
-interface ICompanyInsightsService {
+interface ICompanyInsightsController {
 	/**
 	 * Describes information about the company.
 	 * @returns {Promise<ICompanyData>}

lib/services/analytics/analytics-service.ts

@@ -15,7 +15,7 @@ export class AnalyticsService implements IAnalyticsService, IDisposable {
 		private $options: IOptions,
 		private $staticConfig: Config.IStaticConfig,
 		private $prompter: IPrompter,
-		private $userSettingsService: UserSettings.IUserSettingsService,
+		private $userSettingsService: IUserSettingsService,
 		private $analyticsSettingsService: IAnalyticsSettingsService,
 		private $childProcess: IChildProcess,
 		private $projectDataService: IProjectDataService,

lib/services/analytics/google-analytics-provider.ts

@@ -12,7 +12,7 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 		private $logger: ILogger,
 		private $proxyService: IProxyService,
 		private $config: IConfiguration,
-		private $companyInsightsService: ICompanyInsightsService,
+		private $companyInsightsController: ICompanyInsightsController,
 		private analyticsLoggingService: IFileLogService) {
 	}
 
@@ -81,7 +81,7 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 			defaultValues[GoogleAnalyticsCustomDimensions.usedTutorial] = playgrounInfo.usedTutorial.toString();
 		}
 
-		const companyData = await this.$companyInsightsService.getCompanyData();
+		const companyData = await this.$companyInsightsController.getCompanyData();
 		if (companyData) {
 			defaultValues[GoogleAnalyticsCustomDimensions.companyName] = companyData.name;
 			defaultValues[GoogleAnalyticsCustomDimensions.companyCountry] = companyData.country;

lib/services/company-insights-service.ts

@@ -0,0 +1,226 @@
+import { assert } from "chai";
+import { Yok } from "../../lib/common/yok";
+import { LoggerStub } from "../stubs";
+import { CompanyInsightsController } from "../../lib/controllers/company-insights-controller";
+
+describe("companyInsightsController", () => {
+	const insightsUrlEndpoint = "/api/insights";
+	const currentIp = "8.8.8.8";
+	const profileDir = "profileDir";
+	const cacheTimeout = 48 * 60 * 60 * 1000; // 2 days in milliseconds
+	const defaultCompanyData = {
+		company: {
+			name: "Progress",
+			country: "Bulgaria",
+			revenue: "123131",
+			industries: [
+				"Software",
+				"Software 2"
+			],
+			employeeCount: "500"
+		}
+	};
+
+	const defaultExpectedCompanyData: ICompanyData = {
+		name: "Progress",
+		country: "Bulgaria",
+		revenue: "123131",
+		industries: "Software__Software 2",
+		employeeCount: "500"
+	};
+
+	const defaultExpectedDataPassedToGetSetting: any[] = [{ settingName: `companyInformation_${currentIp}`, cacheOpts: { cacheTimeout } }];
+	const defaultExpectedDataPassedToSaveSetting: any[] = [
+		{
+			cacheOpts: {
+				useCaching: true
+			},
+			key: "companyInformation_8.8.8.8",
+			value: {
+				country: "Bulgaria",
+				employeeCount: "500",
+				industries: "Software__Software 2",
+				name: "Progress",
+				revenue: "123131"
+			}
+		}
+	];
+
+	let dataPassedToGetSettingValue: { settingName: string, cacheOpts?: ICacheTimeoutOpts }[] = [];
+	let dataPassedToSaveSettingValue: { key: string, value: any, cacheOpts?: IUseCacheOpts }[] = [];
+	let getSettingValueResult: IDictionary<any> = null;
+	let httpRequestCounter = 0;
+	let httpRequestResult: any = null;
+	let testInjector: IInjector = null;
+	let companyInsightsController: ICompanyInsightsController = null;
+
+	const createTestInjector = (): IInjector => {
+		const injector = new Yok();
+		injector.register("config", {
+			INSIGHTS_URL_ENDPOINT: insightsUrlEndpoint
+		});
+
+		injector.register("httpClient", {
+			httpRequest: async (options: any, proxySettings?: IProxySettings): Promise<any> => {
+				httpRequestCounter++;
+				return { body: JSON.stringify(httpRequestResult) };
+			}
+		});
+
+		injector.register("logger", LoggerStub);
+		injector.register("injector", injector);
+		injector.register("ipService", {
+			getCurrentIPv4Address: async (): Promise<string> => currentIp
+		});
+
+		injector.register("settingsService", {
+			getProfileDir: (): string => profileDir
+		});
+
+		injector.register("jsonFileSettingsService", {
+			getSettingValue: async (settingName: string, cacheOpts?: ICacheTimeoutOpts): Promise<any> => {
+				dataPassedToGetSettingValue.push({ settingName, cacheOpts });
+				return getSettingValueResult;
+			},
+
+			saveSetting: async (key: string, value: any, cacheOpts?: IUseCacheOpts): Promise<void> => {
+				dataPassedToSaveSettingValue.push({ key, value, cacheOpts });
+			}
+		});
+
+		injector.register("companyInsightsController", CompanyInsightsController);
+
+		return injector;
+	};
+
+	beforeEach(() => {
+		dataPassedToGetSettingValue = [];
+		dataPassedToSaveSettingValue = [];
+		getSettingValueResult = null;
+		httpRequestCounter = 0;
+		httpRequestResult = defaultCompanyData;
+		testInjector = createTestInjector();
+		companyInsightsController = testInjector.resolve<ICompanyInsightsController>("companyInsightsController");
+	});
+
+	describe("getCompanyData", () => {
+		describe("returns null when data does not exist in the cache and", () => {
+			it("the http client fails to get data", async () => {
+				const httpClient = testInjector.resolve<Server.IHttpClient>("httpClient");
+				const errMsg = "custom error";
+				httpClient.httpRequest = async () => {
+					throw new Error(errMsg);
+				};
+
+				const companyData = await companyInsightsController.getCompanyData();
+				assert.isNull(companyData);
+				const logger = testInjector.resolve<LoggerStub>("logger");
+				assert.isTrue(logger.traceOutput.indexOf(errMsg) !== -1);
+			});
+
+			it("the body of the response is not a valid JSON", async () => {
+				const httpClient = testInjector.resolve<Server.IHttpClient>("httpClient");
+				httpClient.httpRequest = async (): Promise<any> => {
+					return { body: "invalid JSON" };
+				};
+
+				const companyData = await companyInsightsController.getCompanyData();
+				assert.isNull(companyData);
+				const logger = testInjector.resolve<LoggerStub>("logger");
+				assert.isTrue(logger.traceOutput.indexOf("SyntaxError: Unexpected token") !== -1);
+			});
+
+			it("response does not contain company property", async () => {
+				httpRequestResult = {
+					foo: "bar"
+				};
+
+				const companyData = await companyInsightsController.getCompanyData();
+				assert.deepEqual(companyData, null);
+			});
+		});
+
+		describe("returns correct data when", () => {
+			it("data for current ip exist in the cache", async () => {
+				httpRequestResult = null;
+
+				getSettingValueResult = defaultExpectedCompanyData; // data in the file should be in the already parsed format
+				const companyData = await companyInsightsController.getCompanyData();
+				assert.deepEqual(companyData, defaultExpectedCompanyData);
+
+				assert.equal(httpRequestCounter, 0, "In case we have data for the company in our cache, we should not make any http requests");
+				assert.deepEqual(dataPassedToGetSettingValue, defaultExpectedDataPassedToGetSetting);
+				assert.deepEqual(dataPassedToSaveSettingValue, []);
+			});
+
+			describe("data for current ip does not exist in the cache and", () => {
+
+				it("unable to get current ip address, but still can get company information", async () => {
+					const ipService = testInjector.resolve<IIPService>("ipService");
+					ipService.getCurrentIPv4Address = async (): Promise<string> => { throw new Error("Unable to get current ip addreess"); };
+
+					const companyData = await companyInsightsController.getCompanyData();
+					assert.deepEqual(companyData, defaultExpectedCompanyData);
+					assert.equal(httpRequestCounter, 1, "We should have only one http request");
+					assert.deepEqual(dataPassedToGetSettingValue, [], "When we are unable to get IP, we should not try to get value from the cache.");
+					assert.deepEqual(dataPassedToSaveSettingValue, [], "When we are unable to get IP, we should not persist anything.");
+				});
+
+				it("response contains company property", async () => {
+					const companyData = await companyInsightsController.getCompanyData();
+					assert.deepEqual(companyData, defaultExpectedCompanyData);
+					assert.deepEqual(dataPassedToGetSettingValue, defaultExpectedDataPassedToGetSetting);
+					assert.deepEqual(dataPassedToSaveSettingValue, defaultExpectedDataPassedToSaveSetting);
+				});
+
+				it("response contains company property and industries in it are not populated", async () => {
+					httpRequestResult = {
+						company: {
+							name: "Progress",
+							country: "Bulgaria",
+							revenue: "123131",
+							employeeCount: "500"
+						}
+					};
+
+					const companyData = await companyInsightsController.getCompanyData();
+					assert.deepEqual(companyData, {
+						name: "Progress",
+						country: "Bulgaria",
+						revenue: "123131",
+						industries: null,
+						employeeCount: "500"
+					});
+
+					assert.deepEqual(dataPassedToGetSettingValue, defaultExpectedDataPassedToGetSetting);
+					assert.deepEqual(dataPassedToSaveSettingValue, [
+						{
+							cacheOpts: {
+								useCaching: true
+							},
+							key: "companyInformation_8.8.8.8",
+							value: {
+								country: "Bulgaria",
+								employeeCount: "500",
+								industries: null,
+								name: "Progress",
+								revenue: "123131"
+							}
+						}
+					]);
+				});
+
+			});
+		});
+
+		it("is called only once per process", async () => {
+			const companyData = await companyInsightsController.getCompanyData();
+			assert.deepEqual(companyData, defaultExpectedCompanyData);
+			assert.equal(httpRequestCounter, 1);
+
+			const companyDataSecondCall = await companyInsightsController.getCompanyData();
+			assert.deepEqual(companyDataSecondCall, defaultExpectedCompanyData);
+			assert.equal(httpRequestCounter, 1);
+		});
+	});
+});