Interface DocumentContentGetterInterface

The DocumentContentGetterInterface interface is used to get the content of an attached document knowing its properties (this cannot be used to get metadata documents).

The attached document content can be retrieved by an AttachedDocumentInfoInterface obtained by a call to InstanceMetadataInterface.getAttachedDocumentInfos. If the user knows the attached document id and its mime type, then the attached document can also be retrieved using this information and using DataSessionInterface.createAttachedDocumentInfo. attached document ids are string based.

Warning : any attached document with a URL will NOT be retrieved.

The DocumentContentGetterInterface interfaces are created through the DataSessionInterface.createDocumentContentGetter method.

/** 
 * Sample to illustrate how to download an attached document.
 */
import { DataSessionInterface, DocumentContentGetterInterface, AttachedDocumentInfoInterface, DocumentContentGetterInterfaceSignal, tListenerCallback } from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// user callback code called when the document data content is ready 
let myCallback : tListenerCallback;

const lDocumentContentGetterInterface : DocumentContentGetterInterface = lDataSession.createDocumentContentGetter();
// get an AttachedDocumentInfoInterface from an IdCardGetterInterface
// ....
let lAttachedDocumentInfo : AttachedDocumentInfoInterface;

lDocumentContentGetterInterface.addEventListener(DocumentContentGetterInterfaceSignal.DocumentContentReady, myCallback);

// if no url, then we can retrieve data content
if (lAttachedDocumentInfo.documentUrl === '')
{
    lDocumentContentGetterInterface.retrieveDocumentContent(lAttachedDocumentInfo);
}
// myCallback will be called when the data is available

Copy

or asynchronously :

/** 
 * Sample to illustrate how to asynchronously download an attached document.
 */
import { DataSessionInterface, DocumentContentGetterInterface, AttachedDocumentInfoInterface, AsyncDocumentContentGetterResult, AsyncResultReason } from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;

const lDocumentContentGetterInterface : DocumentContentGetterInterface = lDataSession.createDocumentContentGetter();
// get an AttachedDocumentInfoInterface from an IdCardGetterInterface
// ....
let lAttachedDocumentInfo : AttachedDocumentInfoInterface;

// the code to parse the document content
let handleDocumentContent : (pContent : string | Uint8Array) => void;

const getDocument = async () : Promise<void> =>
{
    // if no url, then we can retrieve data content
    if (lAttachedDocumentInfo.documentUrl === '')
    {
        const lResult : AsyncDocumentContentGetterResult = await lDocumentContentGetterInterface.asyncRetrieveDocumentContent(lAttachedDocumentInfo);
        // it it successful ?
        if (lResult.reason !== AsyncResultReason.ARR_Success)
        {
            console.log('some fancy error message');
            return;
        }
        // was the document id correct ?
        if (!lResult.value)
        {
            console.log('some other fancy error message');
            return;
        }
        handleDocumentContent(lResult.value);
    }
};

getDocument();

Copy

The list of signals the DocumentContentGetterInterface may trigger is available in the DocumentContentGetterInterfaceSignal enumeration.

The attached document retrieval procedure is triggered through the retrieveDocumentContent methods. The result is not available right away, but the event DocumentContentGetterInterfaceSignal.DocumentContentReady is triggered when the result of the DocumentContentGetterInterface is available. The result is available through the getDocumentContent function.

Warning : there may be cases when the getDocumentContent is not available such as when the DocumentContentGetterInterface is updating, i.e. when isRunning returns true, or when the DocumentContentGetterInterface has been cancelled, i.e. when isCancelled returns true.

A DocumentContentGetterInterface may be interrupted (cancelled) when the DocumentContentGetterInterface is updating and cancel is called. In such cases, the DocumentContentGetterInterfaceSignal.DocumentContentCancelled signal is fired, and shortly after, DocumentContentGetterInterfaceSignal.DocumentContentReady signal is fired, but getDocumentContent will return undefined. Just call retrieveDocumentContent with another (or the same) attached document properties to trigger a new retrieval.

If you call multiple times retrieveDocumentContent before receiving the DocumentContentGetterInterfaceSignal.DocumentContentReady, only one DocumentContentGetterInterfaceSignal.DocumentContentReady will be sent with the content of the last call to retrieveDocumentContent.

The result may be undefined (getDocumentContent) if no such document was found, this is not considered as an error.

The developer may trigger a download on the user browser by the following code :

/** 
 * Sample to illustrate how to trigger a file dialog to save the content of an attached document.
 */
import { AttachedDocumentInfoInterface, DocumentContentGetterInterface } from 'generated_files/documentation/appinfiniteapi';

let getDocumentData : (pDocumentContentGetterInterface : DocumentContentGetterInterface) => boolean = undefined;

// pDocumentContentGetterInterface.retrieveDocumentContent(lAttachedDocumentInfo) has been called previously

getDocumentData = (pDocumentContentGetterInterface : DocumentContentGetterInterface) : boolean =>
{
    // do nothing in case of error
    if (pDocumentContentGetterInterface.getLastError() !== undefined)
    {
        return false;
    }
    const lAttachedDocumentInfo: AttachedDocumentInfoInterface | undefined = pDocumentContentGetterInterface.getAttachedDocumentInfo();
    // document is set ?
    if (!lAttachedDocumentInfo) {
        return false;
    }
    const lDocumentContent: string | Uint8Array | undefined = pDocumentContentGetterInterface.getDocumentContent();
    // document is ready ?
    if (!lDocumentContent) {
        return false;
    }
    // create a <a> markup for download
    const downloadLink = document.createElement('a');
    downloadLink.target = '_blank';
    let lExtension: string;
    switch (lAttachedDocumentInfo.documentMimeType) {
        case 'application/json': lExtension = 'json'; break;
        case 'application/xml': lExtension = 'xml'; break;
        case 'application/x-qt-richtext': lExtension = 'html'; break;
        case 'image/jpg': lExtension = 'jpg'; break;
        case 'image/jpeg': lExtension = 'jpeg'; break;
        case 'image/png': lExtension = 'png'; break;
        case 'text/csv': lExtension = 'csv'; break;
        case 'text/html': lExtension = 'html'; break;
        case 'text/plain': lExtension = 'txt'; break;
        case 'text/xml': lExtension = 'xml'; break;
        // do nothing in case of "unknown" mime type 
        default: return false;
    }
    // nice default file name for download
    downloadLink.download = lAttachedDocumentInfo.documentName + '.' + lExtension;
    // convert downloaded data to a Blob
    const blob = new Blob([(typeof lDocumentContent === 'string') ? lDocumentContent : <BlobPart> lDocumentContent.buffer], { type: lAttachedDocumentInfo.documentMimeType });
    // create an object URL from the Blob
    const URL = window.URL;
    const downloadUrl = URL.createObjectURL(blob);
    // set object URL as the anchors href
    downloadLink.href = downloadUrl;
    // append the anchor to document body
    document.body.appendChild(downloadLink);
    // fire a click event on the anchor
    downloadLink.click();
    // cleanup: remove element and revoke object URL
    downloadLink.remove();
    URL.revokeObjectURL(downloadUrl);
    return true;
};

// lDocumentContentGetterInterface has been created previously and 
// retrieveDocumentContent has been called
let lDocumentContentGetterInterface : DocumentContentGetterInterface;

getDocumentData(lDocumentContentGetterInterface);

Copy

Please refer to the AttachedDocumentInfoInterface for additional information.

See

• DocumentContentGetterInterfaceSignal
• AttachedDocumentInfoInterface