List Page Interaction Event Handler API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// EventHandler module declaration
define(function handlerFactory() {
  // Illustrates the main EventHandler function initializer. It takes an  api parameter.
  function initializer(api) {
    // Specify a handler for the page change event. It takes pageApi parameter.
    function handlePageChange(pageApi) {
      var info = pageApi.getNavigationInfo();
      if (info.newStart > 100) {
        pageApi.abortNavigation("Can't go that far");
      }
    }

    // Perform any initialization here.

    // Illustrates the main function, which should return an object describing any events of interest.
    return {
      // Set a handler for a page change event.
      listPageChange: handlePageChange
    };
  }

  // Return the main EventHandler function.
  return initializer;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
describe(function() {
  function sampleHandler(api) {
    // Ilustrates a function that handles page change events. Takes the Page Navigation API as a parameter.
    function handlePageChange(pageApi) {
      // Request the current page navigation information.
      var info = pageApi.getNavigationInfo();
      // Prevents a page change when attempting to go beyond the first 100 items.
      if (info.newStart > 100) {
        pageApi.abortNavigation("Can't go that far!");
      }
    }
    return {
      // Subscribes to the "listPageChange" event.
      listPageChange: handlePageChange
    };
  }
  return sampleHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
describe(function() {
  function sampleHandler(api) {
    // Illustrates aA function that handles page change events. It takes the Page Navigation API as a parameter.
    function handleNewItemButtomCustomizeEvent(buttonApi) {
      buttonApi.setButton({
        text: "Open my custom modal",
        eventName: "show_my_modal"
      });
    }
    return {
      // Subscribe to the "newItemButtonInit" event.
      newItemButtonInit: handleNewItemButtomCustomizeEvent
    };
  }
  return sampleHandler;
});

1
2
3
formatterApi.setFormatter("columnName", function (defaultValue, columnOptions, rowData, api) {
  return api.getCellData(defaultValue);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
{
    // Value alignment
       align:"left",
    // Current column name
       columnName:"File Type",
    // Column display name
    friendlyLabelName:"File Type",
    // Indicates whether the column is visible.
       hidden:false,
    // Indicates whether the column label is hidden.
       hideColumnLabel:false,
    // Default column width
       initialWidth:150,
    // Indicates whether the column is a key column.
       key:false,
    // Full name of the column
       label:"File Type",
    // Column width
       minWidth:75,
    // Indicates whether the column is sortable.
       sortable:true,
    // Column width
       width:194,
    // Indicates whether the column can wrap.
       wrapping:true,
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
define(function() {
     "use strict";
     function testHandler(api) {
          var api = api;

          // FORMATTING TEXT EXAMPLE
          function subjectFormatter(cellValue, options, rowObject, formatterApi) {
               var data,
                    resultHtml;
               data = formatterApi.getCellData(cellValue) || "";
               data = formatterApi.escapeString(data);
               if (options.colModel.gridFormatter.isLinked) {
                    resultHtml = "<a target='_top' href='"+rowObject["viewUrl"]+"'>Name: "+data+"</a>"
               } else {
                    resultHtml = "Name: "+data;
               }
               resultHtml = "<span style='color: #0b3e6f'>"+resultHtml+"</span><hr><span>Another Line</span>";
               return resultHtml;
          }


          // OPEN MODAL EXAMPLE
          function authorFormatter(cellValue, options, rowObject, formatterApi) {
               var valueText, resultHtml, modalId, modalContent;
               valueText = formatterApi.getCellData(cellValue) || "";
                   valueText = formatterApi.escapeString(valueText);
               modalContent = {
                    title: "Modal for " + valueText,
                    modalClass: "rlh-new-rdo-dialog",
                    modalName: "rlhRdoModalDialog",
                    template: "<span>Some sample text</span>",
                    buttons: [{
                         name: "Apply",
                         eventName: "apply_click",
                    }, {
                         name: "Close",
                         eventName: "close_click"
                    }],
                    init: function (scope, el) {
                         scope.$on("apply_click", function() {
                              alert("OK clicked - " + valueText);
                         });
                         scope.$on("close_click", function() {
                              api.modalService.hideModal(modalId);
                         });
                    }
               }
               var modalId = api.modalService.createModal(modalContent);
               resultHtml = valueText + "<br><a href='#' " + formatterApi.getOnClickForModal(modalId) + ">Open modal (formatterApi)</a>";
               return resultHtml;
          }
          function cellFormattersInit(formatterApi) {
               var fieldSubject, fieldAuthor;
               fieldSubject = formatterApi.fields.find(function (field) {
                    return field.displayName === "Subject";
               });
               if (fieldSubject) {
                    formatterApi.setFormatter(fieldSubject.columnName, subjectFormatter);
               }
               fieldAuthor = formatterApi.fields.find(function (field) {
                    return field.columnName === "1001306";
               });
               if (fieldAuthor) {
                    formatterApi.setFormatter(fieldAuthor.columnName, authorFormatter);
               }
          }
          return {
               cellFormattersInit: cellFormattersInit
          };
     }
     return testHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
overrideApi.setItemListDataSource(function(itemListDataSourceParams) {
  return {
    getData: {
      method: function(payload) {
        // ...
      }
    },
    inboundTransformer: {
      method: function(data) {
        // ...
      }
    },
    outboundTransformer: {
      method: function(data) {
        // ...
      }
    }
  };
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
{
  "filter": {
    "hidden": {
      "info": {
        "type": 1,
        "data": {
          "field": "Folder Id",
          "conditions": [
            {
              "value": 1003697,
              "operation": "in"
            }
          ],
          "enabled": false,
          "hidden": true,
          "global": true
        }
      }
    }
  },
  "startIndex": 1,
  "pageSize": 25,
  "fields": [
    "Edit",
    "Security",
    "File Icon",
    "Control Number",
    "Author",
    "Custodian - Single Choice",
    "Duplicate",
    "File Type",
    "File Size",
    "Artifact ID"
  ],
  "sorts": [],
  "localSort": {},
  "useQueryToken": true,
  "queryToken": null,
  "activeRowId": null
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
{
  "items": [
    {
      "fieldData": {
        "Artifact ID": 1039212,
        "editPermission": true,
        "runScriptPermission": true,
        "securityMetadata": {
          "img": {
            "alt": "Locked"
          },
          "anchor": {
            "id": "security_popup_1039212",
            "title": "Change Security Permissions",
            "class": "tabableListLink"
          },
          "permission": true
        },
        "relativityCompareMetadata": {
          "img": {
            "alt": "Compare Document"
          },
          "anchor": {
            "title": "Compare Document",
            "id": "relativity_compare_1039212"
          },
          "permission": true
        },
        "fileIconMetadata": {
          "img": {
            "alt": "Open Stand-Alone Viewer"
          },
          "anchor": {
            "id": "file_icon_1039212",
            "title": "Open Stand-Alone Viewer",
            "class": "tabableListLink"
          },
          "permission": true,
          "enableRedirect": false,
          "windowName": "StandAloneViewer",
          "features": "height=1040,width=1920,location=no,scrollbars=no,menubar=no,toolbar=no,status=no,resizable=yes"
        },
        "editUrl": "/Relativity/Case/Document/Review.aspx?AppID=1019859&ArtifactID=1039212&profilerMode=Edit&ArtifactTypeID=10&SelectedTab=null",
        "viewUrl": "/Relativity/Case/Document/Review.aspx?AppID=1019859&ArtifactID=1039212&ArtifactTypeID=10&profilerMode=View&SelectedTab=null",
        "securityUrl": "/Relativity/Permissions/Edit.aspx?AppID=1019859&ArtifactID=1039212",
        "securityImgSrc": "/Relativity/Images/unlock.gif",
        "fileIconImgSrc": "/Relativity/Images/FileIcons/msg.png",
        "compareUrl": "/Relativity/Case/Document/DocumentComparePopup.aspx?ArtifactID=1039212&AppID=1019859&PageArtifactID=1003663",
        "compareImgSrc": "/Relativity/Images/compare.png",
        "viewerPopupLinkUrl": "/Relativity/Case/Document/DocumentViewerPopup.aspx?AppID=1019859&ArtifactID=1039212",
        "downloadUrl": "/Relativity/Case/Document/DocumentViewerPopup.aspx?AppID=1019859&ArtifactID=1039212",
        "Edit": null,
        "Security": null,
        "File Icon": "EN000019.MSG",
        "Control Number": "EN000019",
        "Author": "phillip.allen@enron.com",
        "Custodian - Single Choice": {
          "Name": "Allen, Paul",
          "Artifact ID": 1038170
        },
        "Duplicate": false,
        "File Type": "E-mail",
        "File Size": "440.00"
      }
    }
  ],
  "currentMinItemIndex": 1,
  "currentMaxItemIndex": 25,
  "grandTotalItems": 73973
}

1
2
3
4
5
6
7
{
    USER_GLOBAL: "userGlobal",
    HIDDEN: "hidden",
    GLOBAL: "global",
    WIDGET_NATIVE: "widgetNative",
    USER: "user"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
overrideApi.setPivotDataSource(function(pivotDataSourceParams) {
  return {
    getData: {
      method: function(payload) {
        // ...
      }
    },
    inboundTransformer: {
      method: function(data) {
        // ...
      }
    },
    outboundTransformer: {
      method: function(data) {
        // ...
      }
    }
  };
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
overrideApi.setObjectFieldDataSource(function(objectFieldDataSourceParams) {
  return {
    getData: {
      method: function(payload) {
        // ...
      }
    },
    inboundTransformer: {
      method: function(data) {
        // ...
      }
    },
    outboundTransformer: {
      method: function(data) {
        // ...
      }
    }
  };
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
define(function() {
  function testHandler(api) {
    function handleDataSourceOverrideEvent(overrideApi) {
      // Set a custom data source for ItemList widget.
      // Pass a data source factory function to the overrideApi.setItemListDataSource() function.
      overrideApi.setItemListDataSource(function(itemListDataSourceParams) {
        // The data source factory function receives an itemListDataSourceParams object with query parameters
        // and should return a data source object.
        return {
          getData: {
            method: function(payload) {
              // The getData.method should return a promise, resolving with the data received from server.
              var result = api.promise.defer();
              result.resolve({
                Success: true,
                Data: {
                  ArtifactTypeGuids: ["15c36703-74ea-4ff8-9dfb-ad30ece7530d"],
                  ArtifactTypeId: 10,
                  CurrentStartIndex: 1,
                  DataResults: [{
                    ArtifactGuids: [],
                    ArtifactId: 1039253,
                    ArtifactTypeGuids: ["15c36703-74ea-4ff8-9dfb-ad30ece7530d"],
                    ArtifactTypeId: 10,
                    Fields: [{
                      ArtifactGuids: ["2a3f1212-c8ca-4fa9-ad6b-f76c97f05438"],
                      ArtifactId: 1003667,
                      FieldType: "FixedLengthText",
                      Name: "Control Number",
                      Value: "AMEYERS_0000047"
                    },{
                      ArtifactGuids: ["1f036749-a691-4aa8-8cf7-5eeb80c36caf"],
                      ArtifactId: 1003671,
                      FieldType: "FixedLengthText",
                      Name: "Group Identifier",
                      Value: "AMEYERS_0000047"
                    }],
                    ParentArtifactId: 0,
                    Permissions: [{ID: 4, Name: "Secure"}],
                    WorkspaceId: itemListDataSourceParams.workspaceId
                  },{
                    ArtifactGuids: [],
                    ArtifactId: 1039254,
                    ArtifactTypeGuids: ["15c36703-74ea-4ff8-9dfb-ad30ece7530d"],
                    ArtifactTypeId: 10,
                    Fields: [{
                      ArtifactGuids: ["2a3f1212-c8ca-4fa9-ad6b-f76c97f05438"],
                      ArtifactId: 1003667,
                      FieldType: "FixedLengthText",
                      Name: "Control Number",
                      Value: "AMEYERS_0000048"
                    },{
                      ArtifactGuids: ["1f036749-a691-4aa8-8cf7-5eeb80c36caf"],
                      ArtifactId: 1003671,
                      FieldType: "FixedLengthText",
                      Name: "Group Identifier",
                      Value: "AMEYERS_0000048"
                    }],
                    ParentArtifactId: 0,
                    Permissions: [{ID: 4, Name: "Secure"}],
                    WorkspaceId: itemListDataSourceParams.workspaceId
                  }],
                  NextPage: "",
                  PreviousPage: "",
                  ResultCount: 2,
                  TotalResultCount: 2,
                  Window: [1039253, 1039254],
                  WorkspaceId: itemListDataSourceParams.workspaceId
                }
              });
              return result.promise;
            }
          },
          inboundTransformer: {
            method: function(data) {
              // The inboundTransformer.method should implement a server-to-ItemList data transformation.
              return data;
            }
          },
          outboundTransformer: {
            method: function(data) {
              // The outboundTransformer.method should implement ItemList-to-server data transformation.
              return data;
            }
          }
        };
      });
    }
    return {
      dataSourceInit: handleDataSourceOverrideEvent
    };
  }
  return testHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
define(function() {
    function sampleHandler(api) {
        // A function called when view or browser changes. It gets the data object that has the viewId, viewLabel and browser properties.
        function viewChange(data) {
            var viewId = data.viewId;
            var browser = data.browser;
            if (viewId === 123 && browser !== "savedSearchExecute") {
                // ....
            }
        }

        return {
            // Subscribe to the viewChange event.
            viewChange: viewChange
        }
    }
    return sampleHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
define(function() {
    function sampleHandler(api) {
        // This function receives notifications about changes in widget menus.
        function handleWidgetMenuCustomizeEvent(menuApi) {
            // To examine and modify menu items for a widget, use the menuApi object.
            if (menuApi.getWidgetTypeName() === "pivotWgt") { // Check if this is a pivot widget.
                var menu = menuApi.getWidgetMenu();
                menu.forEach(function(category) {
                    if (category.title === "Properties") { // Find 'Properties' submenu.
                        category.items.forEach(function(item) {
                            if (item.title === "Edit Pivot") {
                                // Hide 'Edit Pivot' menu item from Pivot menu.
                                item.visible = false;
                            }
                        });
                    }
                });
                menuApi.setWidgetMenu(menu); // Apply menu changes to a widget.
            }
        }
        return {
            // Add the following to receive  notifications about changes in widgets' menu items.
            widgetMenuCreate: handleWidgetMenuCustomizeEvent
        };
    }
    return sampleHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// eventHandler1.js
define(function() {
  function eventHandler1(api) {
    // Subscribe to a "custom-event" event.
    api.eventService.subscribe("custom-event", handleCustomEvent);

    function handleCustomEvent(event, payload) {
      // On receiving the event, show an alert message with an event payload.
      alert("Got the event from " + payload);
    }

    return {};
  }

  return eventHandler1;
});

// eventHandler2.js
define(function() {
  function eventHandler2(api) {
    // Send a "custom-event" event.
    api.eventService.emit("custom-event", "Event Handler 2");

    return {};
  }

  return eventHandler2;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var FieldTreeManagerService = function(baseUrl) {

     api.keplerProviderService.KeplerProxy.call(this, baseUrl);
     var proxy = this;

     this.getFieldTreeItems = function(workspaceId, fieldTypeId, parentArtifactId, associatedId, fieldArtifactId)
     {
         var payload = {
             workspaceId: workspaceId,
             fieldTypeId: fieldTypeId,
             parentArtifactId: parentArtifactId,
             associatedId: associatedId,
             fieldArtifactId: fieldArtifactId
         };
         return api.keplerProviderService.callLRP(
            proxy,
            "Relativity.Services.FieldTree.IFieldTreeModule/Field Tree Manager",
            "GetFieldTreeItemsAsync",
            payload, null, null, keplerVersion = 2);
     };
};

var fieldTreeManagerService = new FieldTreeManagerService(api.commonUtilities.applicationPaths.kepler);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
define(function() {
  function sampleHandler(api) {
    function showMyModal() {
      var id = api.modalService.createModal({
        title: "My awesome modal",
        template: "<span>Some text</span>",
        buttons: [{name: "OK", eventName: "awesome_modal_ok_click"}],
        init: function(scope) {
          scope.$on("awesome_modal_ok_click", function() {
            // Close modal on the OK button click.
            api.modalService.hideModal(id);
          });
        }
      });
           api.modalService.showModal(id);
    }
    // Show this modal in 2 seconds.
    setTimeout(showMyModal, 2000);
    return {};
  }
  return sampleHandler;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
define(function() {
    function sampleHandler(api) {
        var toolbarId;
        var api = api;

        // First, create a toolbar.
        toolbarId = api.toolbarService.createToolbar({
            template: "<span>Greetings</span>",
            buttons: [{name: "Close", eventName: "close_toolbar"}],
            init: function(scope) {
                scope.$on("close_toolbar", function() {
                    // on click - hide it
                    api.toolbarService.hideToolbar(toolbarId);
                });
            }
        });
        
        function viewChange(data) {
            // Next, display it when view changes.
            api.toolbarService.showToolbar(toolbarId);
        }

        return {
            // Subscribe to the "onViewChanged" event.
            viewChange: viewChange
        }
    }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
define(function () {
    "use strict";
 
    function testHandler(api) {
        var _api = api, _widgetId, _viewIdToShow = 1188142,
        _workspaceId = 1017106, _fieldArtifactId = 1112594,
        _widgetOptions = {
            title: "My custom widget",
            template: "<div style='merge: 10px; padding: 10px'>" +
                "<div ng-show='noData'> NO DATA </div>" +
                "<div ng-hide='noData'>Data recieved from server.</div>" +
                "<div><div ng-repeat=\"row in resultSet\">"+
                "{{row}}"+
                "</div></div>"+
                "</div>",
            sizeX: 6,
            sizeY: 10,
            enableMaximize: false,
            enableRemove: true,
            enabledMenu: true,
            dataSource: getDataSource(),
            init: initWidget
        };
        var reviewQueues, viewId;
 
        function initWidget(widgetManager) {
            var scope = widgetManager.scope;
            scope.noData = true;
 
            function checkAndSetErrorFromServer(data) {
                var hasError = false;
                if(data.Message && (data.Message !== "SUCCESS" || !data.Success || !data.Results)) {
                    widgetManager.showMessage({
                        message: data.Message,
                        type: widgetManager.errorTypes.SERVER,
                        icon: data.messageIcon || widgetManager.canceledIcon,
                        messageType: "error",
                        hideContent: false
                    });
                    hasError = true;
                }
                return hasError;
            }
 
            // Called by EventHandler, triggers watcher
            scope.metaData.setData = function (data) {
                /// <summary>Sets the data for the Pivot widget to use.</summary>
                /// <param name="data" type="Object">Data object to set.</param>
                scope.noData = true;
                scope.resultSet = [];
                scope.metaData.fullDataSet = [];
                if (!data) {
                    widgetManager.showMessage({
                        message: "This chart did not return any results.",
                        type: widgetManager.errorTypes.NO_DATA,
                        icon: widgetManager.canceledIcon,
                        messageType: "info"
                    });
                } else {
                    if (checkAndSetErrorFromServer(data)) {
                        return;
                    } else {
                        widgetManager.clearMessage();
                    }
                    scope.metaData.fullDataSet = data;
                    scope.$broadcast("reload_options");
                }
                scope.noData = false;
                scope.resultSet = data.Results || [];
 
                widgetManager.hideLoading();
            };
        }
 
        function viewChange(activeView) {
            widgetViewChanged(activeView);
        }
 
        function widgetViewChanged(activeView) {
            if (activeView && activeView.browser === "folder" && activeView.viewId === _viewIdToShow) {
                _widgetId = _api.customWidgetService.createWidget(_widgetOptions);
            } else if (!!_widgetId) {
                _api.customWidgetService.removeWidget(_widgetId);
                _widgetId = (void 0);
            }
        }
 
        function getData() {
            var settings =
                {
                    dataAggregationServicePath: "Relativity.Services.Pivot.IPivotModule/Pivot Manager"
                };
            return {
                method: function (payload) {
                    return _api.dataSourceService.kepler.pivot.getDataWithSettings(payload, settings);
                }
            };
        }
 
        function getDataSource(parameters) {
            return {
                getData: getData(),
                outboundTransformer: outboundTransformer(),
                onFailure: {
                    method: function () { }
                }
            }
        }
 
        function outboundTransformer() {
            return {
                method: function (payload) {
                    var treeNames,
                        filterTree,
                        filters,
                        rowFilterTree,
                        translatedFilters,
                        conditions,
                        rowConditions,
                        relationalField,
                        folderCondition;
 
                    if (typeof payload.filter.getFullTree === "function") {
                        treeNames = payload.filter.getTreeNames();
                        filterTree = payload.filter.getFullTree([treeNames.USER_GLOBAL, treeNames.HIDDEN, treeNames.GLOBAL, treeNames.USER]);
                        rowFilterTree = payload.filter.getFullTree([treeNames.WIDGET_NATIVE]);
                    }
 
                    filters = filterTree ? filterTree.getAllOperands() : [];
                    // WARNING: find() method doesn't supproted by IE11. Used only for testing purposes in chrome
                    folderCondition = filters.find(function (row) { return !!row && row.field === "Folder Id"; });
 
                    return _api.promise.when({
                        groupByField: {
                            id: _fieldArtifactId,
                            ArtifactID: _fieldArtifactId,
                            ViewFieldID: 0,
                            Guids: [],
                            label: "Custodian - Object",
                            title: "Custodian - Object",
                            value: _fieldArtifactId,
                            fieldTypeID: 10,
                            artifactTypeId: 1000036,
                            fieldAxisType: "category"
                        },
                        pivotOnField: {
                            title: "<Grand Total>",
                            id: -1
                        },
                        artifactTypeId: 10,
                        conditions: "(('Folder Name' IN [" + (folderCondition ? folderCondition.conditions[0].value : 0).toString() + "]))",
                        rowConditions: "",
                        searchProviderCondition: null,
                        relationalField: null,
                        workspaceId: _workspaceId,
                        sampleParameters: null
                    });
                }
            };
        }
 
        return {
            viewChange: viewChange
        };
    }
 
    return testHandler;
});