Update settingsManager to support multiple environments

Composer/packages/server/__tests__/models/settings/fileSettingManager.test.ts

@@ -0,0 +1,35 @@
+import { FileSettingManager } from '../../../src/models/settings/fileSettingManager';
+import { Path } from '../../../src/utility/path';
+
+const dir = './mocks';
+const defaultDir = Path.join(__dirname, dir);
+
+describe('get', () => {
+  it('return values', async () => {
+    const sm = new FileSettingManager(defaultDir);
+    const result = await sm.get('', false);
+    expect(result.label).toBe('default');
+  });
+
+  it('return obfuscated alues', async () => {
+    const sm = new FileSettingManager(defaultDir);
+    const result = await sm.get('', true);
+    expect(result.label).toBe('*****');
+    expect(result.mock1).toBe('*****');
+    expect(result.mock2).toBe('*****');
+    expect(result.mock3.mock3).toBe('*****');
+    expect(result.mock3.mock4).toBe('*****');
+    expect(result.mock3.mock5[0]).toBe('*****');
+    expect(result.mock3.mock5[1]).toBe('*****');
+  });
+
+  it('return slot values', async () => {
+    const sm = new FileSettingManager(defaultDir);
+    const result = await sm.get('integration', false);
+    expect(result.label).toBe('integration');
+    const result2 = await sm.get('production', false);
+    expect(result2.label).toBe('production');
+    const result3 = await sm.get('bonus', false);
+    expect(result3.label).toBe('bonus');
+  });
+});

Composer/packages/server/__tests__/models/settings/hostedSettingManager.test.ts

@@ -0,0 +1,19 @@
+import { HostedSettingManager } from '../../../src/models/settings/hostedSettingManager';
+import { Path } from '../../../src/utility/path';
+
+const dir = './mocks';
+const defaultDir = Path.join(__dirname, dir);
+
+describe('get', () => {
+  it('throws with invalid slot name', async () => {
+    const sm = new HostedSettingManager(defaultDir);
+    let threw = false;
+    try {
+      await sm.get('bad', true);
+    } catch (x) {
+      threw = true;
+    }
+
+    expect(threw).toBeTruthy();
+  });
+});

Composer/packages/server/__tests__/models/settings/mocks/bonus/settings/appsettings.json

@@ -0,0 +1,13 @@
+{
+    "label": "bonus",
+    "mock1": 123,
+    "mock2": "abc",
+    "mock3": {
+        "mock3": 456,
+        "mock4": "xyz",
+        "mock5": [
+            789,
+            "pnm"
+        ]
+    }
+}

Composer/packages/server/__tests__/models/settings/mocks/integration/settings/appsettings.json

@@ -0,0 +1,13 @@
+{
+    "label": "integration",
+    "mock1": 123,
+    "mock2": "abc",
+    "mock3": {
+        "mock3": 456,
+        "mock4": "xyz",
+        "mock5": [
+            789,
+            "pnm"
+        ]
+    }
+}

Composer/packages/server/__tests__/models/settings/mocks/production/settings/appsettings.json

@@ -0,0 +1,13 @@
+{
+    "label": "production",
+    "mock1": 123,
+    "mock2": "abc",
+    "mock3": {
+        "mock3": 456,
+        "mock4": "xyz",
+        "mock5": [
+            789,
+            "pnm"
+        ]
+    }
+}

Composer/packages/server/__tests__/models/settings/mocks/settings/appsettings.json

@@ -0,0 +1,13 @@
+{
+    "label": "default",
+    "mock1": 123,
+    "mock2": "abc",
+    "mock3": {
+        "mock3": 456,
+        "mock4": "xyz",
+        "mock5": [
+            789,
+            "pnm"
+        ]
+    }
+}

Composer/packages/server/settings/appsettings.json

@@ -0,0 +1 @@
+{}

Composer/packages/server/src/controllers/connector.ts

@@ -1,11 +1,12 @@
 import { BotEnvironments } from '../models/connector';
-import BotConnectorService from '../services/connector';
+import { EnvironmentProvider } from '../models/environment';
 
 async function connect(req: any, res: any) {
   try {
     const hostName = req.hostname;
     const env: BotEnvironments = req.query && req.query.botEnvironment ? req.query.botEnvironment : 'production';
-    const botEndpoint = await BotConnectorService.connect(env, hostName);
+    const environment = EnvironmentProvider.getCurrent();
+    const botEndpoint = await environment.getBotConnector().connect(env || 'production', hostName);
     res.send({ botEndpoint });
   } catch (error) {
     res.status(400).json({
@@ -16,7 +17,8 @@ async function connect(req: any, res: any) {
 
 async function sync(req: any, res: any) {
   try {
-    await BotConnectorService.sync({ ...req.body, user: req.user });
+    const environment = EnvironmentProvider.getCurrent();
+    await environment.getBotConnector().sync({ ...req.body, user: req.user });
     res.send('OK');
   } catch (error) {
     res.status(400).json({
@@ -26,7 +28,8 @@ async function sync(req: any, res: any) {
 }
 
 function status(req: any, res: any) {
-  res.send(BotConnectorService.status());
+  const environment = EnvironmentProvider.getCurrent();
+  res.send(environment.getBotConnector().status);
 }
 
 export const BotConnectorController = {

Composer/packages/server/src/controllers/project.ts

@@ -234,10 +234,61 @@ async function createLuFile(req: Request, res: Response) {
   }
 }
 
+async function getDefaultSlotEnvSettings(req: Request, res: Response) {
+  if (ProjectService.currentBotProject !== undefined) {
+    try {
+      const settings = await ProjectService.currentBotProject.getDefaultSlotEnvSettings(req.query.obfuscate);
+      res.send(settings);
+    } catch (err) {
+      res.status(404).json({
+        message: err.message,
+      });
+    }
+  } else {
+    res.status(404).json({
+      message: 'No such bot project opened',
+    });
+  }
+}
+
+async function getEnvSettings(req: Request, res: Response) {
+  if (ProjectService.currentBotProject !== undefined) {
+    try {
+      const settings = await ProjectService.currentBotProject.getEnvSettings(req.params.slot, req.query.obfuscate);
+      res.send(settings);
+    } catch (err) {
+      res.status(404).json({
+        message: err.message,
+      });
+    }
+  } else {
+    res.status(404).json({
+      message: 'No such bot project opened',
+    });
+  }
+}
+
 async function updateEnvSettings(req: Request, res: Response) {
   if (ProjectService.currentBotProject !== undefined) {
     try {
-      await ProjectService.currentBotProject.updateEnvSettings(req.body.settings);
+      await ProjectService.currentBotProject.updateEnvSettings(req.params.slot, req.body.settings);
+      res.send('ok');
+    } catch (err) {
+      res.status(404).json({
+        message: err.message,
+      });
+    }
+  } else {
+    res.status(404).json({
+      message: 'No such bot project opened',
+    });
+  }
+}
+
+async function updateDefaultSlotEnvSettings(req: Request, res: Response) {
+  if (ProjectService.currentBotProject !== undefined) {
+    try {
+      await ProjectService.currentBotProject.updateDefaultSlotEnvSettings(req.body.settings);
       res.send('ok');
     } catch (err) {
       res.status(404).json({
@@ -300,7 +351,10 @@ export const ProjectController = {
   updateLgFile,
   createLgFile,
   removeLgFile,
+  getEnvSettings,
+  getDefaultSlotEnvSettings,
   updateEnvSettings,
+  updateDefaultSlotEnvSettings,
   updateLuFile,
   createLuFile,
   removeLuFile,

Composer/packages/server/src/models/bot/botProject.ts

@@ -5,15 +5,16 @@ import { isEqual } from 'lodash';
 import { Path } from '../../utility/path';
 import { copyDir } from '../../utility/storage';
 import StorageService from '../../services/storage';
-import { absHosted } from '../../settings/env';
+import { currentConfig } from '../../settings/env';
+import { IEnvironment, EnvironmentProvider } from '../environment';
 
 import { IFileStorage } from './../storage/interface';
 import { LocationRef, FileInfo, LGFile, Dialog, LUFile, LuisStatus, FileUpdateType } from './interface';
 import { DialogIndexer } from './indexers/dialogIndexers';
 import { LGIndexer } from './indexers/lgIndexer';
 import { LUIndexer } from './indexers/luIndexer';
 import { LuPublisher } from './luPublisher';
-import { SettingManager } from './settingManager';
+import { ISettingManager } from '../settings';
 import { DialogSetting } from './interface';
 
 const oauthInput = () => ({
@@ -34,7 +35,8 @@ export class BotProject {
   public luPublisher: LuPublisher;
   public defaultSDKSchema: { [key: string]: string };
   public defaultEditorSchema: { [key: string]: string };
-  public settingManager: SettingManager;
+  public environment: IEnvironment;
+  public settingManager: ISettingManager;
   public settings: DialogSetting | null = null;
   constructor(ref: LocationRef) {
     this.ref = ref;
@@ -45,7 +47,9 @@ export class BotProject {
     this.defaultEditorSchema = JSON.parse(
       fs.readFileSync(Path.join(__dirname, '../../../schemas/editor.schema'), 'utf-8')
     );
-    this.settingManager = new SettingManager(this.dir);
+
+    this.environment = EnvironmentProvider.get({ ...currentConfig, basePath: this.dir });
+    this.settingManager = this.environment.getSettingsManager();
     this.fileStorage = StorageService.getStorageClient(this.ref.storageId);
 
     this.dialogIndexer = new DialogIndexer(this.name);
@@ -56,7 +60,7 @@ export class BotProject {
 
   public index = async () => {
     this.files = await this._getFiles();
-    this.settings = await this.getDialogSetting();
+    this.settings = await this.getEnvSettings(this.environment.getDefaultSlot(), false);
     this.dialogIndexer.index(this.files);
     this.lgIndexer.index(this.files);
     await this.luIndexer.index(this.files); // ludown parser is async
@@ -74,25 +78,35 @@ export class BotProject {
       lgFiles: this.lgIndexer.getLgFiles(),
       luFiles: this.mergeLuStatus(this.luIndexer.getLuFiles(), this.luPublisher.status),
       schemas: this.getSchemas(),
-      botEnvironment: absHosted ? this.name : undefined,
+      botEnvironment: this.environment.getEnvironmentName(this.name),
       settings: this.settings,
     };
   };
 
-  private getDialogSetting = async () => {
-    const settings = await this.settingManager.get();
-    if (settings && oauthInput().MicrosoftAppId !== '') {
+  public getDefaultSlotEnvSettings = async (obfuscate: boolean) => {
+    const defaultSlot = this.environment.getDefaultSlot();
+    return await this.settingManager.get(defaultSlot, obfuscate);
+  };
+
+  public getEnvSettings = async (slot: string, obfuscate: boolean) => {
+    const settings = await this.settingManager.get(slot, obfuscate);
+    if (settings && oauthInput().MicrosoftAppId !== '*****') {
       settings.MicrosoftAppId = oauthInput().MicrosoftAppId;
     }
-    if (settings && oauthInput().MicrosoftAppPassword !== '') {
+    if (settings && oauthInput().MicrosoftAppPassword !== '*****') {
       settings.MicrosoftAppPassword = oauthInput().MicrosoftAppPassword;
     }
     return settings;
   };
 
+  public updateDefaultSlotEnvSettings = async (config: DialogSetting) => {
+    const defaultSlot = this.environment.getDefaultSlot();
+    await this.updateEnvSettings(defaultSlot, config);
+  };
+
   // create or update dialog settings
-  public updateEnvSettings = async (config: DialogSetting) => {
-    await this.settingManager.set(config);
+  public updateEnvSettings = async (slot: string, config: DialogSetting) => {
+    await this.settingManager.set(slot, config);
     await this.luPublisher.setLuisConfig(config.luis);
   };