@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/src/new/main/edit-config/datasource-config/datasources-config-container.helpers.test.ts

@@ -1,341 +0,0 @@
-import { Connect, logger } from '@genesislcap/foundation-comms';
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { actions, DatasourceInputTypes, selectors } from '../../../store';
-import {
-  createNewDatasourceConfig,
-  findFirstValidDatasource,
-  getDatasources,
-} from './datasources-config-container.helpers';
-import { DatasourceChoice } from './types';
-
-const GetDatasources = suite('getDatasources()');
-
-GetDatasources.before.each(() => {
-  sinon.restore();
-});
-
-// GetDatasources('should combine REQ_REP and DATA_PIPELINE datasources', async () => {
-// const mockConnect = {
-// request: sinon.stub(),
-// };
-//
-// // Stub the REQ_REP response
-// mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-// REPLY: [{ DATASOURCE_NAME: 'ReqRep1' }, { DATASOURCE_NAME: 'ReqRep2' }],
-// });
-//
-// // Stub the DATA_PIPELINE response
-// mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-// REPLY: [{ NAME: 'Pipeline1' }, { NAME: 'Pipeline2' }],
-// });
-//
-// const result = await getDatasources(mockConnect as Connect);
-//
-// assert.equal(result.length, 4);
-// assert.equal(result[0], { name: 'ReqRep1', inputType: 'REQ_REP' });
-// assert.equal(result[1], { name: 'ReqRep2', inputType: 'REQ_REP' });
-// assert.equal(result[2], { name: 'Pipeline1', inputType: 'DATA_PIPELINE' });
-// assert.equal(result[3], { name: 'Pipeline2', inputType: 'DATA_PIPELINE' });
-// assert.ok(mockConnect.request.calledTwice);
-// });
-
-GetDatasources('should throw error when REQ_REP request fails', async () => {
-  const mockConnect = {
-    request: sinon.stub(),
-  };
-
-  mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-    REPLY: null,
-  });
-
-  try {
-    await getDatasources(mockConnect as unknown as Connect);
-    assert.unreachable('Should have thrown an error');
-  } catch (error) {
-    assert.instance(error, Error);
-    assert.is(error.message, 'REQ_REP request');
-  }
-});
-
-// GetDatasources('should throw error when DATA_PIPELINE request fails', async () => {
-// const mockConnect = {
-// request: sinon.stub(),
-// };
-//
-// mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-// REPLY: [{ DATASOURCE_NAME: 'ReqRep1' }],
-// });
-//
-// mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-// REPLY: null,
-// });
-//
-// try {
-// await getDatasources(mockConnect as Connect);
-// assert.unreachable('Should have thrown an error');
-// } catch (error) {
-// assert.instance(error, Error);
-// assert.is(error.message, 'DATA_PIPELINE request');
-// }
-// });
-
-GetDatasources('should handle empty responses', async () => {
-  const mockConnect = {
-    request: sinon.stub(),
-  };
-
-  mockConnect.request.withArgs('ALL_REPORT_DATASOURCES', { REQUEST: {} }).resolves({
-    REPLY: [],
-  });
-
-  // mockConnect.request.withArgs('REPORTING_DATA_PIPELINES', { REQUEST: {} }).resolves({
-  // REPLY: [],
-  // });
-  //
-  const result = await getDatasources(mockConnect as unknown as Connect);
-
-  assert.equal(result.length, 0);
-  // assert.ok(mockConnect.request.calledTwice);
-  assert.ok(mockConnect.request.calledOnce);
-});
-
-GetDatasources.run();
-
-const FindFirstValidDatasource = suite('findFirstValidDatasource()');
-
-FindFirstValidDatasource.before.each(() => {
-  sinon.restore();
-});
-
-FindFirstValidDatasource('should return first valid datasource with schema', async () => {
-  const mockSchema = { properties: { someProperty: 'value' } };
-  const getSchemaStub = sinon.stub().resolves(mockSchema);
-
-  const validDatasources: DatasourceChoice[] = [
-    { name: 'TEST_SOURCE', inputType: 'REQ_REP' as DatasourceInputTypes },
-  ];
-
-  const result = await findFirstValidDatasource(getSchemaStub)(validDatasources);
-
-  assert.equal(result.KEY, 'TEST_SOURCE');
-  assert.equal(result.INPUT_TYPE, 'REQ_REP');
-  assert.equal(result.schema, mockSchema);
-  assert.ok(getSchemaStub.calledOnce);
-  assert.ok(getSchemaStub.calledWith('TEST_SOURCE'));
-});
-
-FindFirstValidDatasource('should try next datasource if first fails', async () => {
-  const mockSchema = { properties: { someProperty: 'value' } };
-  const getSchemaStub = sinon.stub();
-  getSchemaStub.onFirstCall().rejects(new Error('Failed'));
-  getSchemaStub.onSecondCall().resolves(mockSchema);
-
-  const validDatasources: DatasourceChoice[] = [
-    { name: 'FAILED_SOURCE', inputType: 'REQ_REP' as DatasourceInputTypes },
-    { name: 'VALID_SOURCE', inputType: 'DATA_PIPELINE' as DatasourceInputTypes },
-  ];
-
-  const result = await findFirstValidDatasource(getSchemaStub)(validDatasources);
-
-  assert.equal(result.KEY, 'VALID_SOURCE');
-  assert.equal(result.INPUT_TYPE, 'DATA_PIPELINE');
-  assert.equal(result.schema, mockSchema);
-  assert.ok(getSchemaStub.calledTwice);
-});
-
-FindFirstValidDatasource('should throw error if no valid datasources found', async () => {
-  const getSchemaStub = sinon.stub().rejects(new Error('Failed'));
-
-  const validDatasources: DatasourceChoice[] = [
-    { name: 'FAILED_SOURCE', inputType: 'REQ_REP' as DatasourceInputTypes },
-  ];
-
-  try {
-    await findFirstValidDatasource(getSchemaStub)(validDatasources);
-    assert.unreachable('Should have thrown an error');
-  } catch (error) {
-    assert.instance(error, Error);
-    assert.equal((error as Error).message, 'No valid datasources found');
-  }
-
-  assert.ok(getSchemaStub.calledOnce);
-});
-
-FindFirstValidDatasource('should skip schema without properties', async () => {
-  const invalidSchema = { properties: null };
-  const validSchema = { properties: { someProperty: 'value' } };
-  const getSchemaStub = sinon.stub();
-  getSchemaStub.onFirstCall().resolves(invalidSchema);
-  getSchemaStub.onSecondCall().resolves(validSchema);
-
-  const validDatasources: DatasourceChoice[] = [
-    { name: 'INVALID_SCHEMA', inputType: 'REQ_REP' as DatasourceInputTypes },
-    { name: 'VALID_SCHEMA', inputType: 'DATA_PIPELINE' as DatasourceInputTypes },
-  ];
-
-  const result = await findFirstValidDatasource(getSchemaStub)(validDatasources);
-
-  assert.equal(result.KEY, 'VALID_SCHEMA');
-  assert.equal(result.INPUT_TYPE, 'DATA_PIPELINE');
-  assert.equal(result.schema, validSchema);
-  assert.ok(getSchemaStub.calledTwice);
-});
-
-FindFirstValidDatasource.run();
-
-const CreateNewDatasourceConfig = suite('createNewDatasourceConfig()');
-
-CreateNewDatasourceConfig.before.each(() => {
-  sinon.restore();
-});
-
-CreateNewDatasourceConfig('should exit when no valid datasources are available', async () => {
-  const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' as DatasourceInputTypes }];
-
-  const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-    REQ_REP_testSource_testSource: {
-      KEY: 'testSource',
-      NAME: 'testSource',
-      INPUT_TYPE: 'REQ_REP' as const,
-      OUTPUT_TYPE: 'TABLE' as const,
-      TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-      GROUPING_STRATEGY: 'NONE',
-      GROUP_KEY: null,
-    },
-  });
-
-  const loggerStub = sinon.stub(logger, 'error');
-  const getSchemaStub = sinon.stub().resolves({});
-
-  await createNewDatasourceConfig(getSchemaStub)(mockChoices);
-
-  assert.ok(getAllConfigSetStub.calledOnce);
-  assert.ok(loggerStub.calledWith('No datasources available to create new config from'));
-  assert.ok(!getSchemaStub.called);
-});
-
-CreateNewDatasourceConfig(
-  'should exit when trying to add multiple datasources with CSV format',
-  async () => {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' as DatasourceInputTypes }];
-
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-      REQ_REP_existingSource_existingAlias: {
-        KEY: 'existingAlias',
-        NAME: 'existingSource',
-        INPUT_TYPE: 'REQ_REP' as const,
-        OUTPUT_TYPE: 'TABLE' as const,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-        GROUPING_STRATEGY: 'NONE' as const,
-        GROUP_KEY: null,
-      },
-    });
-
-    const getConfigStub = sinon.stub(selectors.baseConfig, 'getConfig').returns({
-      DESTINATION_IDS: [],
-      OUTPUT_DIRECTORY: '/reports',
-      OUTPUT_FORMAT: 'CSV',
-    });
-
-    const loggerStub = sinon.stub(logger, 'error');
-    const getSchemaStub = sinon.stub().resolves({});
-
-    await createNewDatasourceConfig(getSchemaStub)(mockChoices);
-
-    assert.equal(getAllConfigSetStub.callCount, 1, 'getAllConfigSetStub should be called once');
-    assert.equal(getConfigStub.callCount, 1, 'getConfigStub should be called once');
-    // assert.ok(loggerStub.calledWith('Cannot add multiple datasources when using csv file without a template'));
-    if (loggerStub.args.length > 0) {
-      assert.equal(
-        loggerStub.args[0][0],
-        'Cannot add multiple datasources when using csv file without a template',
-      );
-    } else {
-      assert.unreachable('Logger was not called');
-    }
-    assert.equal(getSchemaStub.callCount, 0, 'getSchemaStub should not be called');
-  },
-);
-
-CreateNewDatasourceConfig(
-  'should allow adding multiple datasources with CSV format IF template is selected',
-  async () => {
-    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' as DatasourceInputTypes }];
-
-    const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-      REQ_REP_existingSource_existingAlias: {
-        KEY: 'existingAlias',
-        NAME: 'existingSource',
-        INPUT_TYPE: 'REQ_REP' as const,
-        OUTPUT_TYPE: 'TABLE' as const,
-        TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-        GROUPING_STRATEGY: 'NONE' as const,
-        GROUP_KEY: null,
-      },
-    });
-
-    sinon.stub(selectors.baseConfig, 'getConfig').returns({
-      DESTINATION_IDS: [],
-      OUTPUT_DIRECTORY: '/reports',
-      OUTPUT_FORMAT: 'CSV',
-      DOCUMENT_TEMPLATE_ID: 'some-template-id',
-    });
-
-    const mockSchema = {
-      properties: {
-        field1: {},
-        field2: {},
-      },
-    };
-
-    const getSchemaStub = sinon.stub().resolves(mockSchema);
-    const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
-
-    await createNewDatasourceConfig(getSchemaStub)(mockChoices);
-
-    assert.ok(getAllConfigSetStub.calledOnce);
-    assert.ok(getSchemaStub.calledOnce);
-    assert.ok(initConfigStub.called);
-  },
-);
-
-CreateNewDatasourceConfig('should successfully create new datasource configuration', async () => {
-  const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' as DatasourceInputTypes }];
-
-  const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({});
-
-  sinon.stub(selectors.baseConfig, 'getConfig').returns({
-    DESTINATION_IDS: [],
-    OUTPUT_DIRECTORY: '/reports',
-    OUTPUT_FORMAT: 'XLSX',
-  });
-
-  const mockSchema = {
-    properties: {
-      field1: {},
-      field2: {},
-    },
-  };
-
-  const getSchemaStub = sinon.stub().resolves(mockSchema);
-  const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
-
-  await createNewDatasourceConfig(getSchemaStub)(mockChoices);
-
-  assert.ok(getAllConfigSetStub.calledOnce);
-  assert.ok(getSchemaStub.calledOnce);
-  assert.ok(
-    initConfigStub.calledWith(
-      sinon.match({
-        base: sinon.match({
-          KEY: 'testSource',
-          NAME: 'testSource',
-          INPUT_TYPE: 'REQ_REP',
-        }),
-        fields: sinon.match.array.deepEquals(['field1', 'field2']),
-      }),
-    ),
-  );
-});
-
-CreateNewDatasourceConfig.run();

package/src/new/main/edit-config/datasource-config/datasources-config-container.helpers.ts

@@ -1,99 +0,0 @@
-import { Connect, logger } from '@genesislcap/foundation-comms';
-import { actions, selectors } from '../../../store';
-import { Genesis } from '../../../types';
-import { buildDatasourceName, generateUniqueAlias } from '../../../utils';
-import { setDefaultFormatsForDatasource } from '../data-transforms-derived-fields/data-transforms.helpers';
-import { DatasourceChoice } from './types';
-
-export type GetGenesisSchema = (resource: string) => Promise<Genesis.JSONSchema7>;
-
-export const createNewDatasourceConfig =
-  (getSchema: GetGenesisSchema) =>
-  async (choices: DatasourceChoice[]): Promise<void> => {
-    const allDatasources = selectors.datasourceConfig.getAllConfigSet();
-    const validDatasources =
-      choices.filter(
-        (ds) => !(buildDatasourceName(ds.name, ds.name, ds.inputType) in allDatasources),
-      ) ?? [];
-
-    if (validDatasources?.length < 1) {
-      logger.error('No datasources available to create new config from');
-      return;
-    }
-    const baseConfig = selectors.baseConfig.getConfig();
-    if (
-      Object.keys(allDatasources).length > 0 &&
-      baseConfig.OUTPUT_FORMAT === 'CSV' &&
-      !baseConfig.DOCUMENT_TEMPLATE_ID
-    ) {
-      logger.error('Cannot add multiple datasources when using csv file without a template');
-      return;
-    }
-
-    const {
-      KEY: RESOURCE_NAME,
-      INPUT_TYPE,
-      schema,
-    } = await findFirstValidDatasource(getSchema)(validDatasources);
-
-    // Check for duplicate aliases
-    const existingAliases = new Set(Object.values(allDatasources).map((ds) => ds.KEY));
-
-    const uniqueAlias = generateUniqueAlias(RESOURCE_NAME, existingAliases);
-
-    const datasourceName = buildDatasourceName(uniqueAlias, RESOURCE_NAME, INPUT_TYPE);
-
-    actions.datasourceConfig.initDatasourceConfiguration({
-      base: {
-        KEY: uniqueAlias,
-        NAME: RESOURCE_NAME,
-        INPUT_TYPE,
-      },
-      fields: Object.keys(schema.properties!), // Properties is valid as we check in findFirstValidDatasource
-    });
-
-    setDefaultFormatsForDatasource(datasourceName, schema);
-  };
-
-export const findFirstValidDatasource =
-  (getSchema: GetGenesisSchema) => async (validDatasources: DatasourceChoice[]) => {
-    /* oxlint-disable no-await-in-loop -- try datasources until one resolves */
-    for (const { name: KEY, inputType: INPUT_TYPE } of validDatasources) {
-      try {
-        const schema = await getSchema(KEY);
-        if (schema.properties)
-          return {
-            KEY,
-            INPUT_TYPE,
-            schema,
-          };
-      } catch (_) {}
-    }
-    /* oxlint-enable no-await-in-loop */
-    throw new Error(`No valid datasources found`);
-  };
-
-// TODO: temporarily removing data pipelines until later requested
-export const getDatasources = async (connect: Connect): Promise<DatasourceChoice[]> => {
-  const reqRepResponse = await connect.request('ALL_REPORT_DATASOURCES', {
-    REQUEST: {},
-  });
-  if (!reqRepResponse?.REPLY) throw new Error('REQ_REP request');
-
-  // const dataPipelineResponse = await connect.request('REPORTING_DATA_PIPELINES', {
-  // REQUEST: {},
-  // });
-  // if (!dataPipelineResponse?.REPLY) throw new Error('DATA_PIPELINE request');
-
-  return reqRepResponse.REPLY.map(
-    ({ DATASOURCE_NAME }) =>
-      <DatasourceChoice>{
-        name: DATASOURCE_NAME,
-        inputType: 'REQ_REP',
-      },
-  ).sort((a, b) => a.name.localeCompare(b.name)); // .concat(
-  // dataPipelineResponse.REPLY.map(
-  // ({ NAME }) => <DatasourceChoice>{ name: NAME, inputType: 'DATA_PIPELINE' },
-  // ),
-  // );
-};

package/src/new/main/edit-config/datasource-config/datasources-config-container.template.ts

@@ -1,68 +0,0 @@
-import { html, repeat, when, whenElse } from '@genesislcap/web-core';
-import { selectors } from '../../../store';
-import { DatasourceConfigItem } from './datasource-config-item';
-import type { DatasourcesConfigContainer } from './datasources-config-container';
-
-DatasourceConfigItem;
-
-const addDatasourceControl = html<DatasourcesConfigContainer>`
-  <rapid-button class="add" @click=${(x) => x.createNewDatasourceConfig()}>
-    <rapid-icon name="add" size="md"></rapid-icon>
-  </rapid-button>
-`;
-
-const container = html<DatasourcesConfigContainer>`
-  <div class="container">
-    <h1>Datasources</h1>
-    ${when(
-      (_) =>
-        selectors.baseConfig.getConfig().OUTPUT_FORMAT &&
-        (selectors.baseConfig.getConfig().OUTPUT_FORMAT !== 'CSV' ||
-          !!selectors.baseConfig.getConfig().DOCUMENT_TEMPLATE_ID),
-      addDatasourceControl,
-    )}
-  </div>
-  <p>Here you can select the datasource(s) you want to use in the generated report.</p>
-  <p>
-    CSV reports may only have a single data source unless a template is selected. XLSX and PDF
-    reports may contain one or more datasources. If a template file is used, you must configure the
-    "Name" of each datasource to correspond with your template data references. Use the + button in
-    the top right to add any additional data sources.
-  </p>
-  <p>
-    Changing the data source will remove any datasource related configurations previously set up for
-    this report (for example column visibility, column renames).
-  </p>
-  <div>
-    ${repeat(
-      (_) => Object.keys(selectors.datasourceConfig.getAllConfigSet()),
-      html<string, DatasourcesConfigContainer>`
-        ${when(
-          (_, ctx) => !ctx.isFirst,
-          html`
-            <rapid-divider></rapid-divider>
-          `,
-        )}
-        <datasource-config-item
-          :datasourceName=${(x) => x}
-          :datasourceChoices=${(_, c) => c.parent.datasourceChoices}
-          ?can-remove=${(_, ctx) => !ctx.isFirst}
-          position="${(_, c) => (c.index > 1 ? 'above' : 'below')}"
-        ></datasource-config-item>
-      `,
-      { recycle: false, positioning: true },
-    )}
-  </div>
-`;
-
-export const template = html<DatasourcesConfigContainer>`
-  <template>
-    ${whenElse(
-      (x) => !x.datasourceChoices,
-      html`
-        Unable to load datasources
-      `,
-      container,
-    )}
-  </template>
-`;

package/src/new/main/edit-config/datasource-config/datasources-config-container.ts

@@ -1,55 +0,0 @@
-import { Connect } from '@genesislcap/foundation-comms';
-import { logger } from '@genesislcap/foundation-utils';
-import { customElement, GenesisElement, observable } from '@genesislcap/web-core';
-import { selectors } from '../../../store';
-import { getDatasourceSchema, showNotificationToast } from '../../../utils';
-import { styles } from './datasource-config-container.styles';
-import { createNewDatasourceConfig, getDatasources } from './datasources-config-container.helpers';
-import { template } from './datasources-config-container.template';
-import { DatasourceChoice } from './types';
-
-@customElement({
-  name: 'datasource-config-container',
-  template,
-  styles,
-})
-export class DatasourcesConfigContainer extends GenesisElement {
-  @Connect connect!: Connect;
-  private getSchema = getDatasourceSchema(this.connect);
-  private initDatasource = createNewDatasourceConfig(this.getSchema);
-
-  @observable datasourceChoices: DatasourceChoice[] | null = null;
-
-  async connectedCallback() {
-    super.connectedCallback();
-    await this.getDatasources();
-
-    if (Object.keys(selectors.datasourceConfig.getAllConfigSet()).length === 0) {
-      this.createNewDatasourceConfig();
-    }
-  }
-
-  async createNewDatasourceConfig(): Promise<void> {
-    if (!this.datasourceChoices) {
-      console.error('No datasourceChoices!');
-      return;
-    }
-    this.initDatasource(this.datasourceChoices);
-  }
-
-  /**
-   * Fetch a list of datasources
-   */
-  private async getDatasources(): Promise<void> {
-    try {
-      this.datasourceChoices = await getDatasources(this.connect);
-    } catch (err) {
-      logger.error(err);
-      showNotificationToast({
-        title: 'Reporting Config',
-        body: 'There were errors when loading the available datasources',
-        toast: { type: 'critical' as any },
-      });
-    }
-  }
-}

package/src/new/main/edit-config/datasource-config/types.ts

@@ -1,6 +0,0 @@
-import { DatasourceInputTypes } from '../../../store';
-
-export type DatasourceChoice = {
-  name: string;
-  inputType: DatasourceInputTypes;
-};

package/src/new/main/edit-config/outputs-config/outputs-config.style.ts

@@ -1,11 +0,0 @@
-import { css } from '@genesislcap/web-core';
-import { formLabel, optionMessageBubble } from '../../../styles';
-
-export const styles = css`
-  :host {
-    display: flex;
-    flex-direction: column;
-  }
-  ${formLabel}
-  ${optionMessageBubble('data-option-label-text')}
-`;

package/src/new/main/edit-config/outputs-config/outputs-config.template.ts

@@ -1,66 +0,0 @@
-import { MultiselectOption } from '@genesislcap/rapid-design-system';
-import { html, ref, whenElse } from '@genesislcap/web-core';
-import { selectors } from '../../../store';
-import { Permissions } from '../../../types';
-import { permissionTemplateGuard, TOOLTIP, tooltip } from '../../../utils';
-import type { OutputsConfig } from './outputs-config';
-
-export type OutputChoice = {
-  id: string;
-  name: string;
-  topic: string;
-  type: 'NOTIFY' | 'SMTP';
-};
-
-const container = html<OutputsConfig>`
-      <label class="label">Outputs ${tooltip(TOOLTIP.DELIVERY_OUTPUTS)}</label>
-      <rapid-multiselect
-        data-test-id="output-multiselect"
-        ${ref('multiselect')}
-        @selectionChange=${(x) => x.updateOutputDestinationHandler()}
-        :selectedOptions=${() => selectors.baseConfig.getConfig().DESTINATION_IDS || []}
-        :options=${(x) =>
-          x.outputChoices?.map(
-            ({ type, topic, name, id }) =>
-              <MultiselectOption>{
-                value: id,
-                label: `${topic}/${name}`,
-                optionLabelText: type,
-              },
-          )}
-      ></rapid-multiselect>
-
-
-  </div>
-`;
-
-const dataSwitchTemplate = html<OutputsConfig>`
-  <template>
-    ${whenElse(
-      (x) => !x.outputChoices,
-      html`
-        Unable to load outputs
-      `,
-      container,
-    )}
-  </template>
-`;
-
-export const template = html<OutputsConfig>`
-  ${(x) =>
-    permissionTemplateGuard(
-      x,
-      Permissions.ReportDestinationView,
-      dataSwitchTemplate,
-      html`
-        <not-permitted>
-          <p
-            style="border-color: var(--error-color); border-radius: 7px; border-style: solid; border-width: 4px; padding: 5px;"
-          >
-            You do not have permission to access this part of the application, please contact your
-            administrator
-          </p>
-        </not-permitted>
-      `,
-    )}
-`;