@finos/legend-application-data-cube 0.3.5 → 0.3.7

package/src/components/builder/source/AdhocQueryDataCubeSourceBuilder.tsx

@@ -15,14 +15,358 @@
  */
 
 import { observer } from 'mobx-react-lite';
+import { CustomSelectorInput, WarningIcon } from '@finos/legend-art';
+import { useEffect, useState } from 'react';
+import { flowResult } from 'mobx';
+import { type LegendDataCubeBuilderStore } from '../../../stores/builder/LegendDataCubeBuilderStore.js';
+import { LATEST_VERSION_ALIAS } from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  compareSemVerVersions,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import {
+  CORE_PURE_PATH,
+  V1_Mapping,
+  V1_PackageableRuntime,
+  V1_deserializePackageableElement,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
 import type { AdhocQueryDataCubeSourceBuilderState } from '../../../stores/builder/source/AdhocQueryDataCubeSourceBuilderState.js';
+import {
+  buildProjectOption,
+  buildRuntimeOption,
+  buildVersionOption,
+  type ProjectOption,
+  type RuntimeOption,
+  type VersionOption,
+} from './UserDefinedFunctionDataCubeSourceBuilder.js';
+import { DataCubeCodeEditor } from '@finos/legend-data-cube';
+
+export type MappingOption = {
+  label: string;
+  value: V1_Mapping;
+};
+export const buildMappingOption = (mapping: V1_Mapping): MappingOption => ({
+  label: mapping.name,
+  value: mapping,
+});
 
 export const AdhocQueryDataCubeSourceBuilder = observer(
-  (props: { sourceBuilder: AdhocQueryDataCubeSourceBuilderState }) => {
+  (props: {
+    sourceBuilder: AdhocQueryDataCubeSourceBuilderState;
+    store: LegendDataCubeBuilderStore;
+  }) => {
+    const { sourceBuilder, store } = props;
+    const [fetchSelectedProjectVersionsStatus] = useState(ActionState.create());
+    const [fetchSelectedVersionRuntimesStatus] = useState(ActionState.create());
+    const [fetchSelectedVersionMappingsStatus] = useState(ActionState.create());
+
+    //projects
+    const projectOptions = sourceBuilder.projects.map(buildProjectOption);
+    const selectedProjectOption = sourceBuilder.currentProject
+      ? buildProjectOption(sourceBuilder.currentProject)
+      : null;
+    const projectSelectorPlaceholder = sourceBuilder.loadProjectsState
+      .isInProgress
+      ? 'Loading projects'
+      : sourceBuilder.loadProjectsState.hasFailed
+        ? 'Error fetching projects'
+        : sourceBuilder.projects.length
+          ? 'Choose a project'
+          : 'No Projects available from depot';
+    const onProjectOptionChange = async (
+      option: ProjectOption | null,
+    ): Promise<void> => {
+      if (option?.value !== sourceBuilder.currentProject) {
+        sourceBuilder.setCurrentProject(option?.value);
+
+        // cascade
+        sourceBuilder.setCurrentVersionId(undefined);
+        sourceBuilder.setCurrentProjectVersions([]);
+        sourceBuilder.setCurrentRuntime(undefined);
+        sourceBuilder.setRuntimes([]);
+        sourceBuilder.setModelPointer(undefined);
+        sourceBuilder.setMappings([]);
+        sourceBuilder.setCurrentMapping(undefined);
+        sourceBuilder.codeEditorState.clearQuery();
+
+        try {
+          fetchSelectedProjectVersionsStatus.inProgress();
+          const versions = await store.depotServerClient.getVersions(
+            guaranteeNonNullable(option?.value.groupId),
+            guaranteeNonNullable(option?.value.artifactId),
+            true,
+          );
+          sourceBuilder.setCurrentProjectVersions(versions);
+        } catch (error) {
+          assertErrorThrown(error);
+          store.application.notificationService.notifyError(error);
+        } finally {
+          fetchSelectedProjectVersionsStatus.reset();
+        }
+      }
+    };
+
+    //versions
+    const versionOptions = [
+      LATEST_VERSION_ALIAS,
+      ...(sourceBuilder.currentProjectVersions ?? []),
+    ]
+      .toSorted((v1, v2) => compareSemVerVersions(v2, v1))
+      .map(buildVersionOption);
+    const selectedVersionOption = sourceBuilder.currentVersionId
+      ? buildVersionOption(sourceBuilder.currentVersionId)
+      : null;
+    const versionSelectorPlaceholder = !sourceBuilder.currentProject
+      ? 'No project selected'
+      : 'Choose a version';
+    const onVersionChange = async (
+      option: VersionOption | null,
+    ): Promise<void> => {
+      if (option?.value !== sourceBuilder.currentVersionId) {
+        sourceBuilder.setCurrentVersionId(option?.value);
+
+        //cascade
+        sourceBuilder.setCurrentRuntime(undefined);
+        sourceBuilder.setRuntimes([]);
+        sourceBuilder.setCurrentMapping(undefined);
+        sourceBuilder.setMappings([]);
+        sourceBuilder.codeEditorState.clearQuery();
+
+        //by this point, we should have all the necessary info to build the model context pointer
+        sourceBuilder.setModelPointer(
+          sourceBuilder.buildPureModelContextPointer(),
+        );
+
+        try {
+          const plugins =
+            store.application.pluginManager.getPureProtocolProcessorPlugins();
+
+          //runtimes
+          fetchSelectedVersionRuntimesStatus.inProgress();
+          const allFetchedRuntimes =
+            await store.depotServerClient.getVersionEntities(
+              guaranteeNonNullable(sourceBuilder.currentProject?.groupId),
+              guaranteeNonNullable(sourceBuilder.currentProject?.artifactId),
+              guaranteeNonNullable(option?.value),
+              CORE_PURE_PATH.RUNTIME,
+            );
+          const fetchedRuntimeOptions: V1_PackageableRuntime[] = [];
+          allFetchedRuntimes.forEach((runtime) => {
+            const runtimeEntity = runtime.entity as Entity;
+            const currentRuntimeElement = V1_deserializePackageableElement(
+              runtimeEntity.content,
+              plugins,
+            );
+            if (currentRuntimeElement instanceof V1_PackageableRuntime) {
+              fetchedRuntimeOptions.push(currentRuntimeElement);
+            }
+          });
+          sourceBuilder.setRuntimes(fetchedRuntimeOptions);
+          fetchSelectedVersionRuntimesStatus.reset();
+
+          //mappings
+          fetchSelectedVersionMappingsStatus.inProgress();
+          const allFetchedMappings =
+            await store.depotServerClient.getVersionEntities(
+              guaranteeNonNullable(sourceBuilder.currentProject?.groupId),
+              guaranteeNonNullable(sourceBuilder.currentProject?.artifactId),
+              guaranteeNonNullable(option?.value),
+              CORE_PURE_PATH.MAPPING,
+            );
+          const fetchedMappingOptions: V1_Mapping[] = [];
+          allFetchedMappings.forEach((mapping) => {
+            const mappingEntity = mapping.entity as Entity;
+            const currentMappingElement = V1_deserializePackageableElement(
+              mappingEntity.content,
+              plugins,
+            );
+            if (currentMappingElement instanceof V1_Mapping) {
+              fetchedMappingOptions.push(currentMappingElement);
+            }
+          });
+          sourceBuilder.setMappings(fetchedMappingOptions);
+          fetchSelectedVersionMappingsStatus.reset();
+        } catch (error) {
+          assertErrorThrown(error);
+          store.application.notificationService.notifyError(error);
+        }
+      }
+    };
+
+    //runtimes
+    const runtimeOptions = sourceBuilder.runtimes?.map(buildRuntimeOption);
+    const selectedRuntimeOption = sourceBuilder.currentRuntime
+      ? buildRuntimeOption(sourceBuilder.currentRuntime)
+      : null;
+    const runtimeSelectorPlaceholder = !sourceBuilder.currentVersionId
+      ? 'No version selected'
+      : 'Choose a  runtime';
+    const onRuntimeChange = (option: RuntimeOption | null) => {
+      if (option === null) {
+        sourceBuilder.codeEditorState.clearQuery();
+      }
+      if (option?.value !== sourceBuilder.currentRuntime) {
+        sourceBuilder.setCurrentRuntime(option?.value);
+      }
+    };
+
+    //mappings
+    const mappingOptions = sourceBuilder.mappings?.map(buildMappingOption);
+    const selectedMappingOption = sourceBuilder.currentMapping
+      ? buildMappingOption(sourceBuilder.currentMapping)
+      : null;
+    const mappingSelectorPlaceholder = !sourceBuilder.currentVersionId
+      ? 'No version selected'
+      : 'Choose a mapping';
+    const onMappingChange = (option: MappingOption | null) => {
+      if (option?.value !== sourceBuilder.currentMapping) {
+        sourceBuilder.setCurrentMapping(option?.value);
+      }
+    };
+
+    const allowQueryEditing = (): boolean => {
+      return Boolean(
+        sourceBuilder.currentProject &&
+          sourceBuilder.currentVersionId &&
+          sourceBuilder.currentRuntime,
+      );
+    };
+
+    useEffect(() => {
+      flowResult(sourceBuilder.loadProjects()).catch(
+        store.application.alertUnhandledError,
+      );
+    }, [sourceBuilder, store.application]);
+
     return (
-      <div className="flex h-full w-full p-2">
-        <div className="flex h-6 items-center text-neutral-500">
-          This is a work-in-progress.
+      <div className="flex h-full w-full">
+        <div className="m-3 flex w-full flex-col items-stretch gap-2 text-neutral-500">
+          <div className="query-setup__wizard__group">
+            <div className="query-setup__wizard__group__title">Project</div>
+            <CustomSelectorInput
+              className="query-setup__wizard__selector"
+              options={projectOptions}
+              disabled={
+                sourceBuilder.loadProjectsState.isInProgress ||
+                !projectOptions.length
+              }
+              isLoading={sourceBuilder.loadProjectsState.isInProgress}
+              onChange={(option: ProjectOption | null) => {
+                onProjectOptionChange(option).catch(
+                  store.application.alertUnhandledError,
+                );
+              }}
+              value={selectedProjectOption}
+              placeholder={projectSelectorPlaceholder}
+              isClearable={true}
+              escapeClearsValue={true}
+            />
+          </div>
+
+          <div className="query-setup__wizard__group">
+            <div className="query-setup__wizard__group__title">Version</div>
+            <CustomSelectorInput
+              className="query-setup__wizard__selector"
+              options={versionOptions}
+              disabled={
+                !sourceBuilder.currentProject ||
+                fetchSelectedProjectVersionsStatus.isInProgress ||
+                !versionOptions.length
+              }
+              isLoading={fetchSelectedProjectVersionsStatus.isInProgress}
+              onChange={(option: VersionOption | null) => {
+                onVersionChange(option).catch(
+                  store.application.alertUnhandledError,
+                );
+              }}
+              value={selectedVersionOption}
+              placeholder={versionSelectorPlaceholder}
+              isClearable={true}
+              escapeClearsValue={true}
+            />
+          </div>
+
+          <div className="query-setup__wizard__group">
+            <div className="query-setup__wizard__group__title">Runtime</div>
+            <CustomSelectorInput
+              className="query-setup__wizard__selector"
+              options={runtimeOptions}
+              disabled={
+                !sourceBuilder.currentVersionId ||
+                fetchSelectedVersionRuntimesStatus.isInProgress ||
+                !versionOptions.length
+              }
+              isLoading={fetchSelectedVersionRuntimesStatus.isInProgress}
+              onChange={(option: RuntimeOption | null) => {
+                onRuntimeChange(option);
+              }}
+              value={selectedRuntimeOption}
+              placeholder={runtimeSelectorPlaceholder}
+              isClearable={true}
+              escapeClearsValue={true}
+            />
+          </div>
+
+          <div className="query-setup__wizard__group">
+            <div className="query-setup__wizard__group__title">
+              Mapping (optional)
+            </div>
+            <CustomSelectorInput
+              className="query-setup__wizard__selector"
+              options={mappingOptions}
+              disabled={
+                !sourceBuilder.currentVersionId ||
+                fetchSelectedVersionMappingsStatus.isInProgress ||
+                !versionOptions.length
+              }
+              isLoading={fetchSelectedVersionMappingsStatus.isInProgress}
+              onChange={(option: MappingOption | null) => {
+                onMappingChange(option);
+              }}
+              value={selectedMappingOption}
+              placeholder={mappingSelectorPlaceholder}
+              isClearable={true}
+              escapeClearsValue={true}
+            />
+          </div>
+
+          <div className="query-setup__wizard__group">
+            <div className="query-setup__wizard__group__title">Query</div>
+
+            <div
+              className="mt-2 h-40 w-full"
+              style={{
+                border: '2px solid #e5e7eb',
+                padding: '5px',
+                borderRadius: '5px',
+                position: 'relative',
+                backgroundColor: allowQueryEditing() ? '#ffffff' : '#f2f2f2',
+              }}
+            >
+              {allowQueryEditing() ? (
+                <DataCubeCodeEditor state={sourceBuilder.codeEditorState} />
+              ) : (
+                <div>No runtime selected </div>
+              )}
+            </div>
+            {sourceBuilder.codeEditorState.compilationError ? (
+              <div
+                className="flex h-full w-full flex-shrink-0 text-sm"
+                style={{ color: 'red' }}
+              >
+                <WarningIcon />
+                Compilation Error: Ensure TDS is returned and all class names
+                are correct
+              </div>
+            ) : sourceBuilder.queryCompileState.isInProgress ? (
+              <div className="flex h-full w-full flex-shrink-0 text-sm">
+                Compiling query...
+              </div>
+            ) : null}
+          </div>
         </div>
       </div>
     );

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -88,7 +88,6 @@ import {
 import {
   _elementPtr,
   DataCubeEngine,
-  type DataCubeSource,
   type CompletionItem,
   _function,
   DataCubeFunction,
@@ -103,6 +102,7 @@ import {
   DataCubeExecutionError,
   RawUserDefinedFunctionDataCubeSource,
   ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
+  type DataCubeSource,
   UserDefinedFunctionDataCubeSource,
   DataCubeQueryFilterOperator,
 } from '@finos/legend-data-cube';
@@ -177,6 +177,9 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         const rawSource =
           RawAdhocQueryDataCubeSource.serialization.fromJson(value);
         const source = new AdhocQueryDataCubeSource();
+        if (rawSource.mapping) {
+          source.mapping = rawSource.mapping;
+        }
         source.runtime = rawSource.runtime;
         source.model = rawSource.model;
         source.query = await this.parseValueSpecification(
@@ -406,7 +409,10 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
             ),
           ),
         );
-        source.query = at(source.lambda.body, 0);
+        // If the lambda has multiple expressions, the source query should only be the final
+        // expression of the lambda. All previous expressions should be left untouched and will
+        // be prepended to the transformed query when it is executed.
+        source.query = at(source.lambda.body, source.lambda.body.length - 1);
         try {
           source.columns = (
             await this._getLambdaRelationType(
@@ -527,35 +533,43 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
   override async getQueryTypeahead(
     code: string,
     baseQuery: V1_Lambda,
-    source: DataCubeSource,
+    context: DataCubeSource | PlainObject,
   ) {
     const baseQueryCode = await this.getValueSpecificationCode(baseQuery);
     let codeBlock = baseQueryCode + code;
     codeBlock = codeBlock.startsWith(LAMBDA_PIPE)
       ? codeBlock.substring(LAMBDA_PIPE.length)
       : codeBlock;
-    if (source instanceof AdhocQueryDataCubeSource) {
+    if (context instanceof AdhocQueryDataCubeSource) {
       return (
         await this._engineServerClient.completeCode({
           codeBlock,
-          model: source.model,
+          model: context.model,
         })
       ).completions as CompletionItem[];
-    } else if (source instanceof UserDefinedFunctionDataCubeSource) {
+    } else if (context instanceof UserDefinedFunctionDataCubeSource) {
       return (
         await this._engineServerClient.completeCode({
           codeBlock,
-          model: source.model,
+          model: context.model,
         })
       ).completions as CompletionItem[];
-    } else if (source instanceof LegendQueryDataCubeSource) {
+    } else if (context instanceof LegendQueryDataCubeSource) {
+      return (
+        await this._engineServerClient.completeCode({
+          codeBlock,
+          model: context.model,
+        })
+      ).completions as CompletionItem[];
+    } else if (Object.getPrototypeOf(context) === Object.prototype) {
       return (
         await this._engineServerClient.completeCode({
           codeBlock,
-          model: source.model,
+          model: context,
         })
       ).completions as CompletionItem[];
     }
+
     throw new UnsupportedOperationError(
       `Can't get code completion for lambda with unsupported source`,
     );
@@ -642,7 +656,16 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
         result = await this._runQuery(query, source.model, undefined, options);
       } else if (source instanceof LegendQueryDataCubeSource) {
         query.parameters = source.lambda.parameters;
-        query.body = [...source.letParameterValueSpec, ...query.body];
+        // If the source lambda has multiple expressions, we should prepend all but the
+        // last expression to the transformed query body (which came from the final
+        // expression of the source lambda).
+        query.body = [
+          ...source.letParameterValueSpec,
+          ...(source.lambda.body.length > 1
+            ? source.lambda.body.slice(0, -1)
+            : []),
+          ...query.body,
+        ];
         result = await this._runQuery(
           query,
           source.model,
@@ -741,7 +764,10 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     if (source instanceof AdhocQueryDataCubeSource) {
       return _function(
         DataCubeFunction.FROM,
-        [_elementPtr(source.runtime)].filter(isNonNullable),
+        [
+          source.mapping ? _elementPtr(source.mapping) : undefined,
+          _elementPtr(source.runtime),
+        ].filter(isNonNullable),
       );
     } else if (source instanceof UserDefinedFunctionDataCubeSource) {
       return _function(
@@ -879,7 +905,7 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
     );
   }
 
-  private async _getLambdaRelationType(
+  async _getLambdaRelationType(
     lambda: PlainObject<V1_Lambda>,
     model: PlainObject<V1_PureModelContext>,
   ) {

package/src/stores/builder/LegendDataCubeCreatorState.tsx

@@ -107,6 +107,7 @@ export class LegendDataCubeCreatorState {
           this._application,
           this._engine,
           this._alertService,
+          this._store,
         );
       case LegendDataCubeSourceBuilderType.LOCAL_FILE:
         return new LocalFileDataCubeSourceBuilderState(

package/src/stores/builder/source/AdHocCodeEditorState.tsx

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { clearMarkers, setErrorMarkers } from '@finos/legend-code-editor';
+import {
+  DataCubeCodeEditorState,
+  type DataCubeEngine,
+} from '@finos/legend-data-cube';
+import { EngineError, type V1_Lambda } from '@finos/legend-graph';
+import {
+  uuid,
+  ActionState,
+  type PlainObject,
+  assertErrorThrown,
+} from '@finos/legend-shared';
+import { action, makeObservable, observable, runInAction } from 'mobx';
+
+export class AdHocCodeEditorState extends DataCubeCodeEditorState {
+  protected override readonly uuid = uuid();
+  codeSuffix: string;
+
+  readonly validationState = ActionState.create();
+  compilationError?: Error | undefined;
+  override currentlyEditing = false;
+
+  alertHandler: (error: Error) => void;
+  override model: PlainObject | undefined;
+  compileQueryCheck: () => Promise<boolean | undefined>;
+  queryLambda: () => V1_Lambda;
+
+  constructor(
+    alertHandler: (error: Error) => void,
+    model: PlainObject | undefined,
+    compileQueryCheck: () => Promise<boolean | undefined>,
+    queryLambda: () => V1_Lambda,
+    engine: DataCubeEngine,
+  ) {
+    super(engine);
+    makeObservable(this, {
+      code: observable,
+
+      editor: observable.ref,
+      setEditor: action,
+
+      codeError: observable.ref,
+      compilationError: observable,
+      showError: action,
+      clearError: action,
+
+      returnType: observable,
+      setReturnType: action,
+    });
+
+    this.codePrefix = '';
+    this.codeSuffix = '';
+
+    this.alertHandler = alertHandler;
+    this.model = model;
+    this.compileQueryCheck = compileQueryCheck;
+    this.queryLambda = queryLambda;
+    this.engine = engine;
+  }
+
+  compileFunction = async (): Promise<boolean | undefined> => {
+    if (this.code.length !== 0) {
+      try {
+        this.currentlyEditing = false;
+        return await this.compileQueryCheck();
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof EngineError) {
+          this.validationState.fail();
+          // correct the source information since we added prefix to the code
+          // and reveal error in the editor
+          if (error.sourceInformation) {
+            error.sourceInformation.startColumn -=
+              error.sourceInformation.startLine === 1
+                ? this.codePrefix.length
+                : 0;
+            error.sourceInformation.endColumn -=
+              error.sourceInformation.endLine === 1
+                ? this.codePrefix.length
+                : 0;
+            const fullRange = this.editorModel.getFullModelRange();
+            if (
+              error.sourceInformation.startLine < 1 ||
+              (error.sourceInformation.startLine === 1 &&
+                error.sourceInformation.startColumn < 1) ||
+              error.sourceInformation.endLine > fullRange.endLineNumber ||
+              (error.sourceInformation.endLine === fullRange.endLineNumber &&
+                error.sourceInformation.endColumn > fullRange.endColumn)
+            ) {
+              error.sourceInformation.startColumn = fullRange.startColumn;
+              error.sourceInformation.startLine = fullRange.startLineNumber;
+              error.sourceInformation.endColumn = fullRange.endColumn;
+              error.sourceInformation.endLine = fullRange.endLineNumber;
+            }
+          }
+          this.showError(error);
+          return undefined;
+        } else if (error instanceof Error) {
+          this.setCompilationError(error);
+        }
+        this.alertHandler(error);
+      }
+    }
+    return undefined;
+  };
+
+  override get hasErrors(): boolean {
+    return Boolean(this.codeError ?? this.compilationError);
+  }
+
+  isValid(): boolean {
+    return Boolean(
+      !this.hasErrors &&
+        this.code.length !== 0 &&
+        !this.currentlyEditing &&
+        !this.validationState.isInProgress,
+    );
+  }
+
+  setCompilationError(val: Error | undefined) {
+    runInAction(() => {
+      this.compilationError = val;
+    });
+  }
+
+  setModel(val: PlainObject | undefined) {
+    this.model = val;
+  }
+
+  clearQuery() {
+    this.clearError();
+    this.editor?.getModel()?.setValue('');
+  }
+
+  override clearError() {
+    this.codeError = undefined;
+    this.compilationError = undefined;
+    clearMarkers(this.uuid);
+  }
+
+  showError(error: EngineError) {
+    this.codeError = error;
+    if (error.sourceInformation) {
+      setErrorMarkers(
+        this.editorModel,
+        [
+          {
+            message: error.message,
+            startLineNumber: error.sourceInformation.startLine,
+            startColumn: error.sourceInformation.startColumn,
+            endLineNumber: error.sourceInformation.endLine,
+            endColumn: error.sourceInformation.endColumn,
+          },
+        ],
+        this.uuid,
+      );
+    }
+  }
+
+  async getReturnType() {
+    this.validationState.inProgress();
+
+    // properly reset the error state before revalidating
+    this.clearError();
+    this.setReturnType(undefined);
+
+    await this.compileFunction();
+
+    this.validationState.complete();
+
+    return undefined;
+  }
+}