ozone-typescript-client

ozone-typescript-client is a typescript module that manage connection and communication to ozone v3 API.

State machine

Interface

export interface OzoneClient extends StateMachine<ClientState> {

    /* Get the client config */
    readonly config: ClientConfiguration

    /* Get the current Authentication if available */
    readonly authInfo?: AuthInfo

    /* Get the last failed login call if any */
    readonly lastFailedLogin?: Response<AuthInfo>

    /*
        Convenience props for getting the status of the client.
    */
    readonly isAuthenticated: boolean
    readonly isConnected: boolean

    /*
        Start the client. To be called once
    */
    start(): Promise<void>

    /*
        The array of filters to apply to all HTTP calls
        BEFORE this OzoneClient's own internal filters.
        This array can be modified at any time to add/remove filters
     */
    readonly preFilters: InstalledFilter[]

    /*
        The array of filters to apply to all HTTP calls
        AFTER this OzoneClient's own internal filters.
        This array can be modified at any time to add/remove filters
     */
    readonly postFilters: InstalledFilter[]

    /*
        Update the WS URL.
        The client will attempt to connect automatically to the new URL.
    */
    updateWSURL(url: string): void

    /*
        Update the Ozone credentials.
        The client will attempt to login automatically.
    */
    updateCredentials(ozoneCredentials: OzoneCredentials): void

    /*
        Stop the client. To be called once
    */
    stop(): Promise<void>

    /*
        Perform a low-level call
        All calls towards Ozone or other Microservices secured by Ozone should use those calls
    */
    callForResponse<T>(request: Request): Promise<Response<T>>

    call<T>(request: Request): Promise<T>

    /*
        Register a message listener.

        @param messageType The type of message to register for
        @param callBack The callBack that will be called
    */
    onMessage<M extends DeviceMessage>(messageType: string, callBack: (message: M) => void): ListenerRegistration

    onAnyMessage(callBack: (message: DeviceMessage) => void): ListenerRegistration

    /*
        Send a message
    */
    send(message: DeviceMessage): void

    // BEGIN HIGH LEVEL CALLS

    /*
        Get a client for working with items of the given type
    */
    itemClient<T extends Item>(typeIdentifier: string): ItemClient<T>
    /*
        Get a ``lob`` for working with blob
    */
    blobClient(): BlobClient

    /*
        Get a client for working with role
    */
    roleClient(): RoleClient

    /**
     * get client to work with type
     */
    typeClient(): TypeClient

    /**
     * get task client to wait manage task
     */
    taskClient(): TaskClient

    /**
     * get client to work with permission
     */
    permissionClient(): PermissionClient

    /**
     * get client to work with permission
     */
    importExportClient(): ImportExportClient

    /**
     *  file file type client
     */
    fileTypeClient(): FileTypeClient

    /*
        Insert the current Ozone session ID in the given URL ("/dsid=...).
        This call throws an error if there is no session available.
        The given string may or may not contain the host part.
        Example input strings :
        "/rest/v3/blob"
        "https://taktik.io/rest/v2/media/view/org.taktik.filetype.original/123"
    */
    insertSessionIdInURL(url: string): string
}

Usage

Initialization example:

import { OzoneClient } from 'ozone-typescript-client'
import UserCredentials = OzoneClient.UserCredentials
import OzoneCredentials = OzoneClient.OzoneCredentials
import ClientConfiguration = OzoneClient.ClientConfiguration
import newOzoneClient = OzoneClient.newOzoneClient

let client: OzoneClient.OzoneClient
async function init() {
const credentials = new UserCredentials('ozoneUser', 'ozonePassword')
        const config: ClientConfiguration = {
            ozoneURL: `http://my.ozone.domain/ozone`,
            ozoneCredentials: credentials
        }
        client = newOzoneClient(config)
        await client.start()
}

Using API client example:

import { OzoneClient } from 'ozone-typescript-client'
import { Video, toPatch } from 'ozone-type'

declare function getClient(): OzoneClient.OzoneClient

const videoClient = getClient().itemClient<Video>('video')
const myOriginalVideo = await videoClient.findOne('uuid-yyyy-zzz')
const videoToUpdate = toPatch(myOriginalVideo)
videoToUpdate.name = 'a new name'
const updatedVideo = await videoClient.save(videoToUpdate)

login application example

import { OzoneClient } from 'ozone-typescript-client'
import UserCredentials = OzoneClient.UserCredentials
import ClientStates = OzoneClient.states
import { getDefaultClient } from 'ozone-default-client'
import once from 'ozone-components-utils/once'

export class PageLoginDefault extends Polymer.Element {
  /* ... */

  ready(): void {
     super.ready()
     const defaultClient = getDefaultClient()
     defaultClient.onEnterState(ClientStates.STOPPED,() => {
        this.set('isConnected', false)
     })
     defaultClient.onEnterState(ClientStates.AUTHENTICATED,() => {
        this.set('isConnected', true)
     })
     if (defaultClient.authInfo) {
        this.set('isConnected', true) // client is already logged
     }
  }

  public async submitForm(e: Event): Promise<void> {
        /* ... */
     const updateMessagesOnError = once(() => {
        this.set('isConnected', false)
        const err = defaultClient.lastFailedLogin
        if (err && err.status === 400) {
           this.set('errorMessage', this.localized.msgEmptyCredentials)
        } else if (err && err.status === 403) {
           this.set('errorMessage', this.localized.msgInvalidCredentials)
        } else {
           this.set('errorMessage', this.localized.msgUnknownError)
        }
     })

     const defaultClient = getDefaultClient()
     defaultClient.onEnterState(ClientStates.AUTHENTICATION_ERROR, updateMessagesOnError)
     const userCredentials: UserCredentials = new UserCredentials(this.username, this.password)
     defaultClient.updateCredentials(userCredentials)
     try {
           // start if needed
        await defaultClient.start()
     } catch (err) {
           // error are handle inside the client state machine
     }
  }
}

Install

$ npm install --save ozone-typescript-client