Interface IRenderData

Type declaration

• connection: {
      hostname: string;
      layers: (TSession & {
          connected: boolean;
      })[];
      noExternalConnectionRequired: boolean;
      sessionsConnected: INopeObservable<boolean, boolean, boolean, IEventAdditionalData>;
      addCommunicationLayer(_session) => void;
      connect(options?) => Promise<boolean>;
      removeCommunicationLayer(session) => void;
  }

  • Readonly hostname: string

    Hostname used in the browser.

    Author

    M.Karkowski

  • Readonly layers: (TSession & {
        connected: boolean;
    })[]

    Returns the available layers.

    Author

    M.Karkowski

    Memberof

    NoPEService

  • Readonly noExternalConnectionRequired: boolean

    Flag, to define, whether a external connection is required to set the INoPEConnectService.sessionsConnected to true.

    Memberof

    INoPEConnectService

  • Readonly sessionsConnected: INopeObservable<boolean, boolean, boolean, IEventAdditionalData>

    Flag showing whether the Service is connected to a backend or not

  • addCommunicationLayer:function

    • addCommunicationLayer(_session): void

    • Adds an communication Layer.

      Memberof

      NoPEService

      Parameters

      • _session: TSession

        The Parameters for the Session.

      Returns void

  • connect:function

    • connect(options?): Promise<boolean>

    • Helper Function to establish a connection to a backend. If called, to url is changed to the pages/connect and after a sucessfull connection, the original url is loaded again.

      Use with care, if you get problems reloading the side again.

      Returns

      Parameters

      • Optional options: {
            delay: number;
        }

        • delay: number

      Returns Promise<boolean>

  • removeCommunicationLayer:function

    • removeCommunicationLayer(session): void

    • Disconnects the Layer.

      Parameters

      • session: TSession

        The Session Parameters to use.

      Returns void

• data: {
      getData<T>(key, defaultValue) => Promise<T>;
      hasData(key) => Promise<boolean>;
      registerSchema(key, schema) => boolean;
      setData(key, value) => Promise<boolean>;
      store() => Promise<boolean>;
  }

  • getData:function

    • getData<T>(key, defaultValue): Promise<T>

    • Helper to get the a value from the store, which is related to the key. If the data isn't present, the store must store the provided defaultValue. Afterwards it must return the provided defaultValue

      Returns

      The extracted data / defaultValue

      Memberof

      IDataInterface

      Type Parameters

      • T

        expected type. Is defined by the defaultValue

      Parameters

      • key: string

        The key, under which the data is expected.

      • defaultValue: T

        The default value, which should be used if the data isnt present.

      Returns Promise<T>

  • hasData:function

    • hasData(key): Promise<boolean>

    • Helper to test if the data exists.

      Author

      M.Karkowski

      Returns

      Parameters

      • key: string

        The key, under which the data is expected.

      Returns Promise<boolean>

  • registerSchema:function

    • registerSchema(key, schema): boolean

    • Register Schema for data. If you try to store or pull data, the schema will be used to verify the data

      Returns

      Flag to show the shema is stored or not.

      Parameters

      • key: string

        The path of the data which should be observed

      • schema: IJsonSchema

        The schema to store

      Returns boolean

  • setData:function

    • setData(key, value): Promise<boolean>

    • Parameters

      • key: string

      • value: any

      Returns Promise<boolean>

  • store:function

    • store(): Promise<boolean>

    • Helper, to store the configuration.

      Returns

      success of the operation

      Returns Promise<boolean>

• file: {
      download: ((content, fileName?, option?) => void);
      upload: ((options) => void);
  }

  • download: ((content, fileName?, option?) => void)

    • • (content, fileName?, option?): void

      • Downloads some content as file.

        Parameters

        • content: string

        • Optional fileName: string

        • Optional option: {
              autoBom: boolean;
          }

          • autoBom: boolean

            Automatically provide Unicode text encoding hints

            Default

            false
            

        Returns void

  • upload: ((options) => void)

    • • (options): void

      • Helper to upload data to the browser. (Opens a Popup)

        The data is only available in the Browser.

        Parameters

        • options: {
              height?: number;
              title: string;
              width?: number;
              callback(error, data) => void;
          }

          • Optional height?: number

          • title: string

            Title of the upload form

          • Optional width?: number

          • callback:function

            • callback(error, data): void

            • Callback which is called after the data has been received.

              Parameters

              • error: any

                Error, during uploading

              • data: string

                The data formated as string

              Returns void

        Returns void

• layout: {
      toolbar: {
          generateRadioMenuEntry<D, T>(options) => void;
          generateSelectMenuEntry<D, T>(options) => void;
      };
      createLayout(panelConfig, options, ...args) => {
          layout: {
              destroy: (() => void);
              element: any;
              layout: any;
          };
          panels: IPossiblePanels;
      };
  }

  • toolbar: {
        generateRadioMenuEntry<D, T>(options) => void;
        generateSelectMenuEntry<D, T>(options) => void;
    }

    • generateRadioMenuEntry:function

      • generateRadioMenuEntry<D, T>(options): void

      • Helper function, to generate a Radio Menu Entry for a Toolbar.

        Export

        Returns

        Type Parameters

        • D extends IMinProvidedDataSet = IMinProvidedDataSet

          The desired callback Data.

        • T extends IRadioMenuItemDescription = IRadioMenuItemDescription

          The desired data of the item.

        Parameters

        • options: {
              items: T[];
              onSelect: ((data, item) => void);
              selected?: string;
          }

          The Options to define the radio-menu. Must contain items and a onSelect callback.

          • items: T[]

            The Toolbar Entries.

          • onSelect: ((data, item) => void)

            • • (data, item): void

              • Callback, that should be called on selecting a radio-box item.

                Parameters

                • data: D

                • item: T

                Returns void

          • Optional selected?: string

            The Id of the already selected radio-element

        Returns void

    • generateSelectMenuEntry:function

      • generateSelectMenuEntry<D, T>(options): void

      • Helper to render a Select Toobar.

        Type Parameters

        • D extends IMinProvidedDataSet

        • T extends IRadioMenuItemDescription

        Parameters

        • options: {
              items: (string | T)[];
              onSelect: ((data, selection) => void);
              selected?: string;
              text: string;
          }

          • items: (string | T)[]

            The Items which can be selected

          • onSelect: ((data, selection) => void)

            • • (data, selection): void

              • Parameters

                • data: D

                • selection: {
                      [index: string]: boolean;
                  }

                  • [index: string]: boolean

                Returns void

          • Optional selected?: string

            The Selected Item

          • text: string

            The Text to Show

        Returns void

  • createLayout:function

    • createLayout(panelConfig, options, ...args): {
          layout: {
              destroy: (() => void);
              element: any;
              layout: any;
          };
          panels: IPossiblePanels;
      }

    • Helper to create a W2UI Layout

      Returns

      Parameters

      • panelConfig: IPanel[]

      • options: TcreateLayoutOptions

      • Rest ...args: any[]

      Returns {
          layout: {
              destroy: (() => void);
              element: any;
              layout: any;
          };
          panels: IPossiblePanels;
      }

      • layout: {
            destroy: (() => void);
            element: any;
            layout: any;
        }

        • destroy: (() => void)

          • • (): void

            • Returns void

        • element: any

        • layout: any

      • panels: IPossiblePanels

• logging: {
      log(level, sender, message) => any;
      toast(level, sender, message) => any;
  }

  • log:function

    • log(level, sender, message): any

    • Helper to log a message

      Parameters

      • level: LoggerLevel

        The Level of the Message

      • sender: string

        The Sender

      • message: string

        The Message. Should be a human friendly text

      Returns any

  • toast:function

    • toast(level, sender, message): any

    • Helper to create a toast. See https://akveo.github.io/nebular/docs/components/toastr/overview#nbtoastrservice for examples.

      Parameters

      • level: LoggerLevel

        The Level of the Message

      • sender: string

        The Sender

      • message: string

        The Message. Should be a human friendly text

      Returns any

• ui: {
      fullscreen: INopeObservable<boolean, boolean, boolean, IEventAdditionalData>;
      closeFullscreen() => void;
      getTheme() => IUiTheme;
      openFullscreen() => void;
  }

  • Readonly fullscreen: INopeObservable<boolean, boolean, boolean, IEventAdditionalData>

    Contains a Flag to toggle the ui into fullscreen or not.

  • closeFullscreen:function

    • closeFullscreen(): void

    • Function, used to close the fullscreen.

      Returns void

  • getTheme:function

    • getTheme(): IUiTheme

    • Returns a defintion of the currently used colors.

      Returns IUiTheme

  • openFullscreen:function

    • openFullscreen(): void

    • Function, used to set the system to Fullscreen

      Returns void

• url: {
      generateLinkWithQueryParams(...objects) => Promise<string>;
      getObjectFromQuery(simpleSchema) => Promise<false | {
          [index: string]: any;
      }>;
      getObjectFromQueryWithSchema(schema) => Promise<false | {
          [index: string]: any;
      }>;
  }

  • generateLinkWithQueryParams:function

    • generateLinkWithQueryParams(...objects): Promise<string>

    • Generates a link with Query Parameters.

      Returns

      Parameters

      • Rest ...objects: TSettingsObject[]

      Returns Promise<string>

  • getObjectFromQuery:function

    • getObjectFromQuery(simpleSchema): Promise<false | {
          [index: string]: any;
      }>

    • Extract the data based on some query parameters. The Parameters to use are provided in the schema object.

      Returns

      Parameters

      • simpleSchema: TSimpleSchema

      Returns Promise<false | {
          [index: string]: any;
      }>

  • getObjectFromQueryWithSchema:function

    • getObjectFromQueryWithSchema(schema): Promise<false | {
          [index: string]: any;
      }>

    • Helper to get an Object from a schema. The Schema must be from type Object and is only allowed to have types "number", "boolean", "integer", "string". If a different type is used an error is thrown.

      Returns

      Parameters

      • schema: IJsonSchema

        The JSON-Schema

      Returns Promise<false | {
          [index: string]: any;
      }>