Interface DataSessionInterface

The DataSessionInterface is the formalization of the connection between a 3djuump infinite proxy and the client.

The DataSessionInterface is created from a connected DirectorySessionInterface and a proxy by the use of the createDataSession function. This function also allows the user to choose a specific proxy by the use of a tChooseProxyCallback.

/** 
 * Sample to illustrate the use of the the choice of a proxy for the open data procedure (DataSessionInterface).
 */
import {
    tChooseProxyCallback, ProxyChoiceInterface, tSetProxyCallback, InfiniteCacheInterface,
    DirectorySessionInterface, DataSessionInterface, DataSessionInterfaceSignal, tListenerCallback
} from 'generated/documentation/appinfiniteapi';

// lDirectorySession has been created previously, the user is now logged in and knows the 3djuump infinite available builds.
let lDirectorySession : DirectorySessionInterface;
// lInfiniteCache may has been created previously (not required)
let lInfiniteCache : InfiniteCacheInterface | undefined;
// the build id to connect to
let lBuildId : string;
// the callback that will be called when the DMU has finished loading
let myDMULoadedCallback : tListenerCallback;

// very simple callback, choose the first available proxy
const lChooseProxyCallback : tChooseProxyCallback = (pProxies: Array<ProxyChoiceInterface>, pFinishLoadingCallback : tSetProxyCallback) : void =>
{
    let i : number;
    const lLength : number = pProxies.length;
    // output all proxies
    for (i = 0; i < lLength; ++i)
    {
        console.log(pProxies[0].getLabel());
    }
    // DO NOT forget to call pFinishLoadingCallback, if not, the DMU loading process will never finish 
    // and with the url of the chosen proxy
    pFinishLoadingCallback(pProxies[0].getUrl());
}

// connect the data session to the build, the proxy choice is asynchronous, and will 
// trigger lChooseProxyCallback when the dev chooses a proxy
const lDataSession : DataSessionInterface | undefined = lDirectorySession.createDataSession(lBuildId, lInfiniteCache, lChooseProxyCallback);
if (!lDataSession)
{
    console.log('something weird happened, the directory session cannot create a data session');
    console.log('Perhaps the directory session is already closed, or closing, or the login procedure failed');
}
else
{
    // we sure want to be notified when the DMU has finished loading
    lDataSession.addEventListener(DataSessionInterfaceSignal.DMULoadingSuccess, myDMULoadedCallback);

    // and GO => open the data session
    if (!lDataSession.openDataSession())
    {
        console.log('something weird happened, this session has already been used, this is not a freshly created one');
    }

    // and wait for myDMULoadedCallback to be called
}

The open data session procedure is detailed below :
The DataSession can only be opened once, when closed, there is no way to reuse this object. You will have to call again the [createDataSession](DirectorySessionInterface.html#createDataSession) function.

/** 
 * Sample to illustrate the use of the open data session procedure with the DataSessionInterface.
 */
import { DataSessionInterface, DataSessionInterfaceSignal, DirectorySessionInterface, InfiniteCacheInterface, tListenerCallback } from 'generated/documentation/appinfiniteapi';

// callbacks called when IdleDataSession, DataSessionClosed, DMULoadingSuccess and DMULoadingFailed events are triggered
let onInactivityDetection : tListenerCallback;
let onCloseDBSuccess : tListenerCallback;
let onDMULoaded : tListenerCallback;
let onOpenDBFailed : tListenerCallback;

// the id of the build to open (retrieved previously)
let sBuildId : string;
// the optional cache (may be created previously)
let lCache : InfiniteCacheInterface | undefined;
// the directory session should have been created previously
let lDirectorySession : DirectorySessionInterface;

const lDataSession : DataSessionInterface | undefined = lDirectorySession.createDataSession(sBuildId, lCache);
// open the database
if (lDataSession)
{
    // do something with your GUI
    // ...
    // when the data session is closed due to inactivity
    lDataSession.addEventListener(DataSessionInterfaceSignal.IdleDataSession, onInactivityDetection);
    // when the data session is closed
    lDataSession.addEventListener(DataSessionInterfaceSignal.DataSessionClosed, onCloseDBSuccess);
    // when the data session has retrieved all required data
    lDataSession.addEventListener(DataSessionInterfaceSignal.DMULoadingSuccess, onDMULoaded);
    // if unfortunately something went wrong with the loading 		
    lDataSession.addEventListener(DataSessionInterfaceSignal.DMULoadingFailed, onOpenDBFailed);
    // and trigger the data session loading
    lDataSession.openDataSession();
}

Idle System.

In order to save resources on the proxy, the api features an automatic data session closing mechanism when the user is not interacting with the application. The DataSessionInterface will be closed if restartIdleTimer is not called on user interactions.

It is composed of three pseudo-states :

• Normal : the user is interacting regularly with the system.
• Warning : the user has not interacted with the system from some time (2/3 of the idle duration as configured in the architecture).
• Idle : the server resources have been cleaned up, the session is closed with no possibility to resume or recover. This state happens after the "warning" state.

The idle system.

/** 
 * Sample to illustrate the binding of events to avoid being idle and disconnected.
 */
import { DataSessionInterface } from 'generated/documentation/appinfiniteapi';

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

// restart the timer on user interactions
const cActiveCallback = (_event: Event): void => {
    if (lDataSession && lDataSession.isConnected())
    {
        lDataSession.restartIdleTimer();
    }
};

// and bind to specific event
// you may choose your own callbacks
document.addEventListener('keydown', cActiveCallback);
document.addEventListener('mousedown', cActiveCallback);
document.addEventListener('mousemove', cActiveCallback);
document.addEventListener('wheel', cActiveCallback);
document.addEventListener('contextmenu', cActiveCallback);
document.addEventListener('touchstart', cActiveCallback);
document.addEventListener('touchmove', cActiveCallback);
document.addEventListener('touchend', cActiveCallback);

Please see [DirectorySessionInterface](DirectorySessionInterface.html) for more explanations about sessions.

All metadata filters, search procedure, data retrieval procedures are created from this interface.

The DataSessionInterface, once successfully connected to a 3djuump infinite build (see DMULoadingSuccess) provides access to

• Filtering interface creation : FilterItemInterfaces / VisibilityContextInterface / FilterSolverInterface / ConfContextInterface.
• Id converters creation :DocumentIdConverterInterface, PartInstanceConverterInterface, GeometricInstanceConverterInterface.
• data retrieval interfaces : IdCardGetterInterface, DocumentContentGetterInterface, SearchInterface.

Id converters and data retrieval interfaces are somewhat autonomous. They only rely on a filtering Context to be used.

However, filtering interfaces are linked together, making difficult to find the correct order to update them and when. For these reasons, and to avoid too many requests being sent to the 3djuump infinite server, the update is triggered by the DataSessionInterface that handles the dependency graph of all these items, and updates only the required interfaces with update.

All these interfaces (filtering, id conversion, data retrieval) work asynchronously : they all feature some kind of "ready" signal telling the result is available, just call addEventListener with the correct signal on the required interfaces.

These interfaces has a dispose function to get rid of them. Do not forget to call these functions to save memory and CPU usage.

The only way to create sets of part instances is to use a FilterSolverInterface that allows computing the result of the intersection of filtering queries with some infinite configurations (see ConfigurationInterface, ConfContextInterface) and optionally other FilterSolverInterface(s). Available configurations (created by the 3djuump infinite maintainer) are accessed through getConfigurationList, they are then "included" by id in a ConfContextInterface.

DMU statistics (Axis Aligned Bounding Box (AABB) of each geometric instance, diagonal length of each geometric instance, min/max of diagonal length, DMU AABB, DMU Unit, maximum geometric instance id, maximum part instance id) and the metadata dictionary (AttributesDictionaryInterface) are accessed through the DataSessionInterface.

/** 
 * Sample to illustrate the use of multiple FilterSolverInterfaces to define a set of visible pieces, and
 * colorize a subset.
 * The visibility is composed of all the part instances included in a Box, that have the "CompletionStatus" attribute
 * set to "done".
 * The colorization set is based on the visibility, the part instances that have the attribute "ToBeRedesigned"
 * true should be colored in yellow.
 * This colors all part instance in yellow in the given box, that ave the attribute "ToBeRedesigned"
 * true and  "CompletionStatus" attribute set to "done".
 * This sample uses multiple FilterSolverInterface, VisibilityContextInterface, 
 * It uses some FilterAABBInterface, FilterAttributeInterface, FilterBooleanInterface.
 */
import {
    AttributesDictionaryInterface, AttributeInfoInterface, AttributeType, DataSessionInterface,
    InfiniteEngineInterface, ConfContextInterface, Vector3, AABB, FilterSolverInterface, VisibilityContextInterface, FilterAABBInterface, FilterAttributeInterface, FilterOperator, FilterSolverInterfaceSignal, VisualStates, FilterBooleanInterface,
} from 'generated/documentation/appinfiniteapi';

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

// MAKE SURE the attributes "CompletionStatus", "ToBeRedesigned" are relevant
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
let lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo('CompletionStatus');
// make sure the attribute is a string one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_STRING));

lAttributeInfo = lAttributeDictionary.getAttributeInfo('ToBeRedesigned');
// make sure the attribute is a date one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_BOOLEAN));

// create a custom material yellow
const lMaterialId : number = lEngineInterface.getMaterialManager().createNewMaterial(new Vector3(1, 1, 0));
// create a conf context
const lConfContext : ConfContextInterface = lDataSession.createConfContext();
// no configuration for the moment (all `part instances`)
lConfContext.setActiveConfs([]);
// the AABB to use
const lABB : AABB = new AABB();
lABB.mCenter.x = 3.0;
lABB.mCenter.y = 3.0;
lABB.mCenter.z = 3.0;

lABB.mHalfExtent.x = 10.0;
lABB.mHalfExtent.y = 10.0;
lABB.mHalfExtent.z = 10.0;

// create the visibility Filter Solver
const lVisibilityFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();

// create the filtering context of the filter solver
const lInnerFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
lInnerFilteringContext.setConfContext(lConfContext);
lVisibilityFilterSolver.setVisibilityContext(lInnerFilteringContext);

// create a box filter
const lFilterAABB : FilterAABBInterface = lDataSession.createFilterAABB();
// useless, FilterOperator.FO_UNION is the default operator when creating a new filter
// lFilterAABB.setFilterOperator(FilterOperator.FO_UNION);
lFilterAABB.setAABB(lABB);

// create a FilterAttributeInterface
const lFilterAttributes : FilterAttributeInterface = lDataSession.createFilterAttribute();
// completion status to done
lFilterAttributes.setAttributeName('CompletionStatus');
lFilterAttributes.setExactValues(['done']);
// no n/a
lFilterAttributes.setNaValueChecked(false);

// intersection is the way to go since intersection of box and instances that have the field "CompletionStatus"
// to "done"
// only change the operator of the filters except the first
lFilterAttributes.setFilterOperator(FilterOperator.FO_INTERSECTION);

// and add the filters
// push back (-1) the AABB filter
lVisibilityFilterSolver.insertFilter(-1, lFilterAABB);
// push back (-1) the FilterAttributeInterface, as it is the second one, its operator is used and therefore
// intersection is used
lVisibilityFilterSolver.insertFilter(-1, lFilterAttributes);

// create the filtering context
const lFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
// sets the conf context
lFilteringContext.setConfContext(lConfContext);
// the colorize filter should be set a sub set of the visibility
lFilteringContext.insertFilterSolver(-1, lVisibilityFilterSolver);

lVisibilityFilterSolver.addEventListener(FilterSolverInterfaceSignal.SolverReady, () =>
{
    const lGeometries : Uint32Array | undefined = lVisibilityFilterSolver.getGeometricInstanceIds();
    if (lGeometries)
    {
        // set hidden and not ghosted for everyone
        lEngineInterface.updateGeometricStateForAll(VisualStates.S_Ghost | VisualStates.S_Hidden, (~VisualStates.S_Ghost) | VisualStates.S_Hidden);
        // and set not hidden for the given geometries 
        lEngineInterface.updateGeometricState(lGeometries, VisualStates.S_Hidden, ~VisualStates.S_Hidden);
    }
});

// create the colorize Filter Solver
const lColorizeFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();
// create an attribute filter
const lColorizeFilterAttributes : FilterBooleanInterface = lDataSession.createBooleanFilter();
// search ToBeRedesigned attribute
lColorizeFilterAttributes.setAttributeName('ToBeRedesigned');
// value should be true
lColorizeFilterAttributes.setBooleanValue(true);

// when the FilterSolverInterface is ready, colorize the given `geometric instances` 
lColorizeFilterSolver.addEventListener(FilterSolverInterfaceSignal.SolverReady, () =>
{
    const lGeomIds : Uint32Array | undefined = lColorizeFilterSolver.getGeometricInstanceIds();
    if (lGeomIds)
    {
        // change material for these elements
        lEngineInterface.getMaterialManager().changeMaterialOfInstances(lGeomIds, lMaterialId);
    }
});

// set the filtering context of the given `part instances` list
lColorizeFilterSolver.setVisibilityContext(lFilteringContext);
// add the colorize filter
lColorizeFilterSolver.insertFilter(-1, lColorizeFilterAttributes);
// and tell the DataSessionInterface to update the modified ConfContextInterface, VisibilityContextInterface and FilterSolverInterfaces
lDataSession.update();
// the filtering context may then be used to restrict a search, or a metadata retrieval to the given FilteringContext.

or asynchronously :

/** 
 * Sample to illustrate the asynchronous use of multiple FilterSolverInterfaces to define a set of visible pieces, and
 * colorize a subset.
 * The visibility is composed of all the part instances included in a Box, that have the "CompletionStatus" attribute
 * set to "done".
 * The colorization set is based on the visibility, the part instances that have the attribute "ToBeRedesigned"
 * true should be colored in yellow.
 * This colors all part instance in yellow in the given box, that ave the attribute "ToBeRedesigned"
 * true and  "CompletionStatus" attribute set to "done".
 * This sample uses multiple FilterSolverInterface, VisibilityContextInterface, 
 * It uses some FilterAABBInterface, FilterAttributeInterface, FilterBooleanInterface.
 */
import {
    AttributesDictionaryInterface, AttributeInfoInterface, AttributeType, DataSessionInterface,
    InfiniteEngineInterface, ConfContextInterface, Vector3, AABB, FilterSolverInterface, VisibilityContextInterface,
    FilterAABBInterface, FilterAttributeInterface, FilterOperator, VisualStates, FilterBooleanInterface,
    AsyncUInt32ArrayResult,
} from 'generated/documentation/appinfiniteapi';

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

// MAKE SURE the attributes "CompletionStatus", "ToBeRedesigned" are relevant
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
let lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo('CompletionStatus');
// make sure the attribute is a string one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_STRING));

lAttributeInfo = lAttributeDictionary.getAttributeInfo('ToBeRedesigned');
// make sure the attribute is a date one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_BOOLEAN));

// create a custom material yellow
const lMaterialId : number = lEngineInterface.getMaterialManager().createNewMaterial(new Vector3(1, 1, 0));
// create a conf context
const lConfContext : ConfContextInterface = lDataSession.createConfContext();
// no configuration for the moment (all `part instances`)
lConfContext.setActiveConfs([]);
// the AABB to use
const lABB : AABB = new AABB();
lABB.mCenter.x = 3.0;
lABB.mCenter.y = 3.0;
lABB.mCenter.z = 3.0;

lABB.mHalfExtent.x = 10.0;
lABB.mHalfExtent.y = 10.0;
lABB.mHalfExtent.z = 10.0;

// create the visibility Filter Solver
const lVisibilityFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();

// create the filtering context of the filter solver
const lInnerFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
lInnerFilteringContext.setConfContext(lConfContext);
lVisibilityFilterSolver.setVisibilityContext(lInnerFilteringContext);

// create a box filter
const lFilterAABB : FilterAABBInterface = lDataSession.createFilterAABB();
// useless, FilterOperator.FO_UNION is the default operator when creating a new filter
// lFilterAABB.setFilterOperator(FilterOperator.FO_UNION);
lFilterAABB.setAABB(lABB);

// create a FilterAttributeInterface
const lFilterAttributes : FilterAttributeInterface = lDataSession.createFilterAttribute();
// completion status to done
lFilterAttributes.setAttributeName('CompletionStatus');
lFilterAttributes.setExactValues(['done']);
// no n/a
lFilterAttributes.setNaValueChecked(false);

// intersection is the way to go since intersection of box and instances that have the field "CompletionStatus"
// to "done"
// only change the operator of the filters except the first
lFilterAttributes.setFilterOperator(FilterOperator.FO_INTERSECTION);

// and add the filters
// push back (-1) the AABB filter
lVisibilityFilterSolver.insertFilter(-1, lFilterAABB);
// push back (-1) the FilterAttributeInterface, as it is the second one, its operator is used and therefore
// intersection is used
lVisibilityFilterSolver.insertFilter(-1, lFilterAttributes);

// create the filtering context
const lFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
// sets the conf context
lFilteringContext.setConfContext(lConfContext);
// the colorize filter should be set a sub set of the visibility
lFilteringContext.insertFilterSolver(-1, lVisibilityFilterSolver);

// create the colorize Filter Solver
const lColorizeFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();
// create an attribute filter
const lColorizeFilterAttributes : FilterBooleanInterface = lDataSession.createBooleanFilter();
// search ToBeRedesigned attribute
lColorizeFilterAttributes.setAttributeName('ToBeRedesigned');
// value should be true
lColorizeFilterAttributes.setBooleanValue(true);

// set the filtering context of the given `part instances` list
lColorizeFilterSolver.setVisibilityContext(lFilteringContext);
// add the colorize filter
lColorizeFilterSolver.insertFilter(-1, lColorizeFilterAttributes);

// the filtering context may then be used to restrict a search, or a metadata retrieval to the given FilteringContext.

const waitForResult = async () : Promise<any> =>
{
    // and tell the DataSessionInterface to update the modified ConfContextInterface, VisibilityContextInterface and FilterSolverInterfaces (true)
    const lVisibleResult : AsyncUInt32ArrayResult = await lVisibilityFilterSolver.asyncGetGeometricInstanceIds(true);
    // no need to call DataSessionInterface update again (false)
    const lColorizeResult : AsyncUInt32ArrayResult = await lColorizeFilterSolver.asyncGetGeometricInstanceIds(false);

    if (lVisibleResult.value)
    {
        // set hidden and not ghosted for everyone
        lEngineInterface.updateGeometricStateForAll(VisualStates.S_Ghost | VisualStates.S_Hidden, (~VisualStates.S_Ghost) | VisualStates.S_Hidden);
        // and set not hidden for the given geometries 
        lEngineInterface.updateGeometricState(lVisibleResult.value, VisualStates.S_Hidden, ~VisualStates.S_Hidden);
    }
    if (lColorizeResult.value)
    {
        // change material for these elements
        lEngineInterface.getMaterialManager().changeMaterialOfInstances(lColorizeResult.value, lMaterialId);
    }
}

waitForResult();

The DataSessionInterface now offers the same functionalities than the former [MetadataManagerInterface](MetadataManagerInterface.html).

See

DataSessionInterfaceSignal