Page History

{
    // if value was non-null and had a listener attached before, and a full value update was
    // received from server, this key is set; if newValue is non-null, it will automatically get the old
    // value's listeners registered to itself
    // NOTE: it might be easier to rely just on a shallow $watch of the foundset value (to catch even the
    // null to non-null scenario that you still need) and not use NOTIFY_FULL_VALUE_CHANGED at all
    $foundsetTypeConstants.NOTIFY_FULL_VALUE_CHANGED: { oldValue : ..., newValue : ... },

    // the following keys appear if each of these got updated from server; the names of those
    // constants suggest what it was that changed; oldValue and newValue are the values for what changed
    // (e.g. new server size and old server size) so not the whole foundset property new/old value
    $foundsetTypeConstants.NOTIFY_SERVER_SIZE_CHANGED: { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_HAS_MORE_ROWS_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_MULTI_SELECT_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_COLUMN_FORMATS_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_SORT_COLUMNS_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_SELECTED_ROW_INDEXES_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_VIEW_PORT_START_INDEX_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_VIEW_PORT_SIZE_CHANGED:  { oldValue : ..., newValue : ... },
    $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROWS_COMPLETELY_CHANGED:  { oldValue : ..., newValue : ... },

    // if we received add/remove/change operations on a set of rows from the viewport, this key
    // will be set; as seen below, it contains "updates" which is an array that holds a sequence of
    // granular update operations to the viewport; the array will hold one or more granular add or, remove
    // or update operations;
    //
    // BEFORE Servoy 8.4: all the "startIndex" and "endIndex" values below are relative to the viewport's
state after all  // state after //all previous updates in the array were already processed (so they are NOT relative to
    // the initial or final state); of the viewport  // indexes are 0 based
    $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES_RECEIVED: {data!). Updates can come in a random order so there is
    // NO guarantee related to each change/insert/delete startingindexes with 8.3.2; sometimes knowing the old
   pointing to the correct new data in the
    // final current viewport sizestate
helps calculate incomming granular updates//
easier    // STARTING WITH  Servoy $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES_OLD_VIEWPORTSIZE: ...,

        // starting with 8.3.2 you can use instead of 'updates' below the new constant;
        // $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES
   8.4: all the "startIndex" and "endIndex" values below are relative to the
    // viewport's state after all previous updates in the array were already processed. But due to some
    // before 8.3.2 just use 'updates';
        updates : [
            {
    pre-processing that happens server-side (it merges and sorts these ops), the indexes of update
    // operations THAT POINT TO DATA (so ROWS_INSERTED and ROWS_CHANGED operations) are relative also to
    // the viewport's final/current state, so after ALL updates in the typearray : $foundsetTypeConstants.ROWS_CHANGED,
were already processed
    // (so these indexes are correct both related to the intermediate state of the viewport startIndexdata :
...,    // and to the final state of viewport data).
    // This means that endIndexit :is ...now easier to apply UI changes to the component as these granular updates
},    // GUARANTEE that if you apply them in sequence {(one by one) to the component's UI (delete, insert and
    // change included) you can safely use //the whenindexes anin INSERTthere happenedto butget viewportnew sizedata remainedfrom the same, it is
  present state
    // of the viewport.
    //
    // indexes are 0 based
   // possible that some of the rows that were previously at the end of the viewport
            $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES_RECEIVED: {

        // DEPRECATED in Servoy 8.4: granular updates are much easier to apply now; see comment above
        // slidedAdded out of it; "removedFromVPEnd" givesin 8.3.2; sometimes knowing the number ofold
such rows that were removed    // viewport size helps calculate incomming granular updates easier
        // from the end of the viewport due to the insert operation;
           $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES_OLD_VIEWPORTSIZE: ...,

        // starting with 8.3.2 you can use instead of 'updates' below the new constant;
        // NOTE: insert signifies an insert into the client viewport, not necessarily
  $foundsetTypeConstants.NOTIFY_VIEW_PORT_ROW_UPDATES
        // before 8.3.2 just use 'updates';
        updates : [
      // an insert in the foundset itself;{
for example calling "loadExtraRecordsAsync"                 type : $foundsetTypeConstants.ROWS_CHANGED,
 // can result in an insert notification + bigger viewport size notification,        startIndex : ...,
          // with removedFromVPEnd = 0      endIndex : ...
            type : $foundsetTypeConstants.ROWS_INSERTED},
            {
       startIndex : ...,           // NOTE: insert signifies an insert into the client viewport, endIndexnot :necessarily
...,                    // removedFromVPEndan :insert ...in the foundset itself; for example calling "loadExtraRecordsAsync"
     },             {  // can result in an insert notification + bigger viewport size notification,
       // when a DELETE happened inside the viewport but there were more rows available// inwith theremovedFromVPEnd = 0
                  // foundset aftertype current viewport: $foundsetTypeConstants.ROWS_INSERTED,
it is possible that some of those rows             startIndex : ...,
     // slided into the viewport; "appendedToVPEnd " gives the number of such rows   endIndex : ...,

              //    that were appended// toDEPRECATED thestarting endwith of the viewport due to the DELETE operationServoy 8.4; it would always be 0 here
                    // NOTE: delete signifies aas server-side code will add a separate delete fromoperation theinstead client- viewport,if notnecessary
necessarily                     // a delete in the foundset itself; for example calling "loadLessRecordsAsync" canBEFORE 8.4: when an INSERT happened but viewport size remained the same, it was
                    // resultpossible infor asome deleteof notificationthe +rows smallerthat viewportwere sizepreviously notification,at the end of the viewport
                    // with appendedToVPEnd = 0 to slide out of it; "removedFromVPEnd" gives the number of such rows that were
                    // removed from the end of the viewport due to this insert operation;
                    typeremovedFromVPEnd : $foundsetTypeConstants.ROWS_DELETED,...
            },
          startIndex : ...,{
                    endIndex// NOTE: ...,delete signifies a delete from the client viewport, not necessarily
                     appendedToVPEnd : ...
     // a delete in the foundset itself; for example calling "loadLessRecordsAsync" can
      }         ]     }// 
}

function getChildFoundSet(rowObjFromFoundsetsViewport, parentLevelGroupColumnIndex,
                                                  newLevelGroupColumnIndex) {
    // 'rowObjFromFoundsetsViewport' comes from the foundset (that contributed the expanded row)
    //     property type's viewport so equivalent to something like
    //     $scope.model.foundsetProps[i].viewPort.rows[expandedRowIndex]
    // 'parentLevelGroupColumnIndex' and 'newLevelGroupColumnIndex' are indexes in
    //     an array property that holds the grouping newLevelGroupColumnIndex)column {dataproviders
    // if 'rowObjFromFoundsetsViewportnewLevelGroupColumnIndex' comes from the foundset (that contributed the expanded rowis undefined, then we are requesting tree leafs (not groups)
    //     and then property type's viewport so equivalent to something likethe server-side query is a bit different

    // foundset query needed  $scope.model.foundsetProps[i].viewPort.rows[expandedRowIndex]
    // 'parentLevelGroupColumnIndex' and 'newLevelGroupColumnIndex' are indexes infor leaf level: Select pk from orders where Country = ? and City = ? and ...
    // foundset query needed for intermediate grouped level; anie. arraywhen propertyyou thatwant holdsto theexpand groupinga columncountry dataprovidersgroup
    // if 'newLevelGroupColumnIndex' is undefined, thento wenext arelevel requestingthat treeis leafsgrouped (not groups)
    //     and then the server-side query is a bit different

    // foundset query needed for leaf level: Select pk from orders where Country = ? and City = ? and ...
    // foundset query needed for intermediate grouped level; ie. when you want to expand a country groupby city: SELECT DISTINCT MIN(pk) FROM Customers Where Country = 
    //     "Mexico" GROUP BY City;
                    
    // as you can see below I try to send abstract things to the server (the client shouldn't really know
    // real datasource names, real column/dataprovider tonames nextand levelso thaton is(those groupedcan bybe city:determined SELECT DISTINCT MIN(pkon server)
FROM Customers Where Country =// so both client and server //code should be done so "Mexico"that GROUPthese BYkinds City;of information never reach the
    // client in the first place - only as abstract ids or indexes/names of component properties)
 // as you can see below I try to send abstract things to the server (the client shouldn't really know
    // realso datasourceserver names,needs realto column/dataproviderbe namesgiven andthe soexpanded onrow (those can be determined on server)
it can get the foundset of the Record from that) and
    // so both client and server code should be done so that these kinds of information never reach thethe groupColumn (index of the column) of the child level if that one is an grouped intermediate level
     // clientotherwise, inif theit firstis placegoing -to onlyrequest asleafs abstractit idsshould orset indexes/namesundefined offor component"newLevelGroupColumnIndex"
properties)
    // NOTE: if we could get it nicely from the parent foundset's query there would be no use sending the
 // so server needs// toexpanded benode's givengroup thecolumn expandedbecause rowthat (it can get the foundset ofis already available on the Recordserver from that) andfoundset's
    // thequery groupColumn (indexgroup ofby theclause)
column)
of the child level ifvar thatchildFoundsetPromise;
one
is an grouped intermediate levelif (newLevelGroupColumnIndex) {
  // otherwise, if it is going tochildFoundsetPromise request leafs it should set undefined for "newLevelGroupColumnIndex"= $scope.svyServoyapi.callServerSideApi("getGroupedChildFoundsetId",
           // NOTE: if we could get it nicely from the parent foundset's query there would be no use sending the
 [rowObjFromFoundsetsViewport, parentLevelGroupColumnIndex, newLevelGroupColumnIndex]);
    } else {
   // expanded node's group column becausechildFoundsetPromise that is already available on the server from that foundset's= $scope.svyServoyapi.callServerSideApi("getLeafChildFoundsetId",
            // query (group by clause)      var childFoundsetPromise[rowObjFromFoundsetsViewport, parentLevelGroupColumnIndex]);
	}

   if (newLevelGroupColumnIndexchildFoundsetPromise.then(function(childFoundsetId) {
        var childFoundsetPromisechildFoundset = $scope.svyServoyapi.callServerSideApi("getGroupedChildFoundsetId",
 getFoundSetByFoundsetId(childFoundsetId);
        mergeData(..., childFoundset);
    }, function() {
        // some error happened
  [rowObjFromFoundsetsViewport, parentLevelGroupColumnIndex, newLevelGroupColumnIndex]);      (...)
    } else);
}
(...)
function getFoundSetByFoundsetId(foundsetId) {
    if ($scope.model.childFoundsets)
  childFoundsetPromise = $scope.svyServoyapi.callServerSideApi("getLeafChildFoundsetId",
              for (var i = 0; i < $scope.model.childFoundsets.length; i++) {
            if [rowObjFromFoundsetsViewport, parentLevelGroupColumnIndex]);
	}
($scope.model.childFoundsets[i].foundsetId == foundsetId)
    childFoundsetPromise.then(function(childFoundsetId) {         var childFoundset = getFoundSetByFoundsetId(childFoundsetId);
return $scope.model.childFoundsets[i];
		 
    return  mergeData(..., childFoundset);
    }, function() {null;
}