convenienceAPI object

1
2
3
4
5
6
7
8
9
10
11
12
13
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      convenienceApi.actionBar.createDefaultActionBar().then(function() { 
          return convenienceApi.actionBar.containersPromise; 
      }).then(function(containers) { 
          const button = convenienceApi.actionBar.generate.button({ 
              innerText:  "Say Hello" , 
              onclick: function() { 
                  alert( "Hello!" ); 
              } 
          }); 
          containers.centerSlotElement.appendChild(button); 
      }); 
 }

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
function populateCustomActionBar(containers) { 
      const actionBar = convenienceApi.actionBar; 
      const button = actionBar.generate.button({ 
          innerText:  "Say Hello" , 
          onclick: function() { 
              alert( "Hello!" ); 
          } 
      }); 
      const pager = actionBar.generateDefault.objectPager(); 
 
      containers.centerSlotElement.appendChild(button); 
      containers.rightSlotElement.appendChild(pager); 
 } 
 
 function populateDefaultActionBar() { 
      convenienceApi.actionBar.createDefaultActionBar(); 
 } 
 
 function createActionBar() { 
      const actionBar = convenienceApi.actionBar; 
      const formViewModel =  this ; 
      // Change to an artifact ID of an instance of the 
      // given object type that exists in your workspace. 
      const ARTIFACT_ID_THAT_NEEDS_CUSTOM_ACTION_BAR = 1050081; 
 
      return actionBar.destroy().then(function() { 
          return actionBar.containersPromise; 
      }).then(function(containers) { 
          if (formViewModel.artifactId === ARTIFACT_ID_THAT_NEEDS_CUSTOM_ACTION_BAR) { 
              populateCustomActionBar(containers); 
          }  else { 
              populateDefaultActionBar(); 
          } 
      }); 
 } 
 
 const eventHandlers = {}; 
 eventHandlers[eventNames.CREATE_ACTION_BAR] = createActionBar; 
 eventHandlers[eventNames.UPDATE_ACTION_BAR] = createActionBar;

1
2
3
4
5
6
7
8
9
10
11
12
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      const actionBar = convenienceApi.actionBar; 
 
      const button = actionBar.generate.button({ 
          innerText:  "Test button" , 
          onclick: function(e) { console.log( "Button clicked!" ); } 
      }); 
 
      actionBar.containersPromise.then(function(containers) { 
          containers.centerSlotElement.appendChild(button); 
      }); 
 };

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
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      const actionBar = convenienceApi.actionBar; 
 
      const choices = [{ 
          label:  "Choice 1" , 
          value:  "1" 
      }, { 
          label:  "Choice 2" , 
          value:  "2" 
      }]; 
 
      const selectedValue = choices[0].value; 
 
      const drop-down = actionBar.generate.drop-down({ 
          label:  "Choices" , 
          removeNoValueChoice:  true , 
          onchange: function(e) { console.log(e.target.value +  " was selected!" ); } 
      }); 
 
      drop-down.setChoices(choices); 
      drop-down.value = selectedValue; 
 
      actionBar.containersPromise.then(function(containers) { 
          containers.rightSlotElement.appendChild(drop-down); 
      }); 
 };

1
2
3
4
5
6
7
8
9
10
11
12
13
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      const actionBar = convenienceApi.actionBar; 
      const buttons = actionBar.generateDefault.actionButtons(); 
 
      actionBar.containersPromise.then(function(containers) { 
          // optional, adds spacing between buttons 
          containers.rootElement.className =  "rwa-button-group" ; 
          buttons.forEach(function(button) { 
              containers.rightSlotElement.appendChild(button); 
          }); 
      }); 
 };
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      const actionBar = convenienceApi.actionBar; 
      const formSettings = convenienceApi.formSettings; 
      const buttons = actionBar.generateDefault.actionButtonsForAddPopup( 
          popupControlApi, 
          formSettings.ObjectTypeName); 
 
      actionBar.containersPromise.then(function(containers) { 
          containers.rootElement.className =  "rwa-button-group" ; 
          buttons.forEach(function(button) { 
              containers.centerSlotElement.appendChild(button); 
          }); 
      }); 
 };

1
2
3
4
5
6
7
8
eventHandlers[eventNames.CREATE_ACTION_BAR] = function() { 
      const actionBar = convenienceApi.actionBar; 
      const layoutDropdown = actionBar.generateDefault.layoutDropdown(); 
 
      actionBar.containersPromise.then(function(containers) { 
          containers.rightSlotElement.appendChild(layoutDropdown); 
      }); 
 };

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
function generateDefaultConsoleContent() { 
      const consoleApi = convenienceApi.console;  
      const button = consoleApi.generate.button({ 
          innerText:  "Test button" , 
          onclick: function(e) { console.log( "Button clicked!" ); } 
      }); 
 
      const section = consoleApi.generate.section({}, [ 
          button 
      ]); 
 
      return section; 
 } 
 
 function generateCustomConsoleContent() { 
      const consoleApi = convenienceApi.console;  
      const title = consoleApi.generate.title({ 
          innerText:  "Title" 
      }); 
 
      return title; 
 } 
 
 function createConsole() { 
      const consoleApi = convenienceApi.console;  
      // Change to a layout ID for the given object type that exists in your workspace. 
      const LAYOUT_ID_THAT_NEEDS_CUSTOM_CONSOLE = 1043519; 
      let consoleContent; 
 
      // Determine the content that should be added to the console 
      // based on the current layout ID of the form. 
      if ( this .layoutId === LAYOUT_ID_THAT_NEEDS_CUSTOM_CONSOLE) { 
          consoleContent = generateCustomConsoleContent(); 
      }  else { 
          consoleContent = generateDefaultConsoleContent(); 
      } 
 
      return consoleApi.destroy().then(function() { 
          return consoleApi.containersPromise; 
      }).then(function(containers) { 
          containers.rootElement.appendChild(consoleContent); 
      });     
 } 
 
 const eventHandlers = {}; 
 eventHandlers[eventNames.CREATE_CONSOLE] = createConsole; 
 eventHandlers[eventNames.UPDATE_CONSOLE] = createConsole;

1
2
3
4
5
6
7
8
9
10
11
const consoleApi = convenienceApi.console; 
 
const button = consoleApi.generate.button({ 
    innerText:  "Do Something",
    title: "Do Something", // Tooltip to show if full button text cannot be displayed
    onclick: function(e) { console.log( "Button clicked!" ); } 
}); 
 
consoleApi.containersPromise.then(function(containers) { 
    containers.rootElement.appendChild(button); 
});

1
2
3
4
5
6
7
8
9
10
const consoleApi = convenienceApi.console; 
 
 const buttonAsLink = consoleApi.generate.buttonStyledAsLink({ 
      innerText:  "Test button" , 
      onclick: function(e) { console.log( "Button clicked!" ); } 
 }); 
 
 consoleApi.containersPromise.then(function(containers) { 
      containers.rootElement.appendChild(buttonAsLink); 
 });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const consoleApi = convenienceApi.console; 
 
 
 const button = consoleApi.generate.button({ 
      innerText:  "Test button" , 
      onclick: function(e) { console.log( "Button clicked!" ); } 
 }); 
 
 const section = consoleApi.generate.section({}, [ 
      button 
 ]); 
 
 consoleApi.containersPromise.then(function(containers) { 
      containers.rootElement.appendChild(section); 
 });

1
2
3
4
5
6
7
8
9
10
11
12
13
const consoleApi = convenienceApi.console; 
   
 const sectionTitle = consoleApi.generate.sectionTitle({ 
      innerText:  "Test section title" 
 }); 
   
 const section = consoleApi.generate.section({}, [ 
      sectionTitle 
 ]); 
   
 consoleApi.containersPromise.then(function(containers) { 
      containers.rootElement.appendChild(section); 
 });

1
2
3
4
5
6
7
8
9
const consoleApi = convenienceApi.console; 
   
 const title = consoleApi.generate.title({ 
      innerText:  "Test section title" 
 }); 
   
 consoleApi.containersPromise.then(function(containers) { 
      containers.rootElement.appendChild(title); 
 });

1
2
3
4
5
6
7
8
9
var unformattedDateTimeString = "2009-04-27T18:44:50.217";
var myDateTimeFormatter = convenienceApi.dateTime.getFormatter({ 
      isUTC:  true , 
      includeSeconds:  true , 
      includeTime:  true 
 }); 
 
var formattedDateTimeString = myDateTime.format(unformattedDateTimeString);
console.log(formattedDateTimeString); // "4/27/2009, 1:44:50 PM CDT"     

1
2
3
convenienceApi.fieldHelper.getValue(identifier).then(function (value) {
      console.log( "The field has a value of " + value);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var relativityObject1 = {
    ArtifactID: 10010,
    Name: "Object1"
};
 
var relativityObject2 = {
    ArtifactID: 10011,
    Name: "Object2"
};
 
convenienceApi.fieldHelper.setValue( singleChoiceOrObjectFieldId, relativityObject1||null );
 
convenienceApi.fieldHelper.setValue( TrueOrFalseFieldId, true);
 
convenienceApi.fieldHelper.setValue( textFieldId, "string" );
 
// To clear out the value of a mutli choice.object field, set the value to an empty array
convenienceApi.fieldHelper.setValue( multiChoiceOrMultiObjectFieldId, [relativityObject1, relativityObject2] );
 
convenienceApi.fieldHelper.setValue( numberFieldId, 1000 );
 
convenienceApi.fieldHelper.setValue( dateField, "1999-02-01T10:05:00" );

1
2
3
4
5
convenienceApi.fieldHelper.getHtmlElement(identifier).then((element) => {
      if (!!element) {
          element.style.color( "blue" );
      }
 });

1
 convenienceApi.fieldHelper.setIsEditMode(identifier,  false );

1
  convenienceApi.fieldHelper.setIsDisabled(identifier,  true );

1
   convenienceApi.fieldHelper.setIsLoading(identifier,  true );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// for non-User fields
var data = [
    { label: "Chicago" , value: 1 },
    { label: "Boston" , value: 2 },
    { label: "New York" , value: 3 }
];
convenienceApi.fieldHelper.addAdditionalData(nonUserIdentifier, { options: data, limitForUIExceeded: false });
  
// for User fields
// values are artifact IDs
var userData = [
    { label: "John Doe", value: 1234567 },
    { label: "Jane Smith", value: 8901234 }
];
convenienceApi.fieldHelper.addAdditionalData(userIdentifier, userData);

1
   convenienceApi.fieldHelper.setIsHidden(identifier,  false );

1
convenienceApi.fieldHelper.setIsRequired(identifier, true );

1
2
3
4
5
6
const objectTypeFieldId = "ObjectType";
const descriptionTextId = "DescriptionStaticText";
// Setting a description text.
convenienceApi.staticTextHelper.setValue(descriptionTextId, "<span id=\"object-type-description\">Please select Object Type value to see other fields.</span>");
// A description text is used to describe the ObjectType field.
convenienceApi.fieldHelper.setAriaDescribedBy(objectTypeFieldId, "object-type-description");

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
// Use ItemListDataProviderFactory to get an ItemListDataProvider instance that can be customized
const option = {
     objectTypeId: artifactTypeId,
     workspaceId: workspaceID,
     textIdentifierColumnName: "ArtifactID",
     viewArtifactId: viewToDisplayID
};
const customItemListDataProvider = convenienceApi.itemListDataProviderFactory.create("object", option);
 
// Override the query method to define a custom data source for the list
customItemListDataProvider.query = function customQuery(request){
     const customData = [
          { "col1": "row1 col1 value", "col2": "row1 col2 value" },
          { "col2": "row2 col1 value", "col2": "row2 col2 value" }
     ];
     return {
          Results: customData,
          TotalCount: customData.length;
          CurrentStartIndex: 0
     };
};
 
// Define the modal for a list picker that references our custom item list data provider
const listPickerModalModel = {
     label: "My custom picker modal",
     itemListDataProvider: customItemListDataProvider
};
 
// Open the modal
convenienceApi.modalService.open(listPickerModalModel);

1
2
3
4
5
6
7
8
9
10
(function(eventNames, convenienceApi) {
    var ASSOCIATED_DOCUMENTS_LIST_NAME = "Associated Documents";
    eventHandlers[eventNames.HYDRATE_LAYOUT_COMPLETE] = function() {
        var itemListHelper = convenienceApi.itemListHelper;
        var ITEM_LIST_COMMAND_COLUMN_TYPE = convenienceApi.constants.ITEM_LIST_COMMAND_COLUMN_TYPE;
 
        itemListHelper.setCommandColumnType(ASSOCIATED_DOCUMENTS_LIST_NAME, ITEM_LIST_COMMAND_COLUMN_TYPE.SINGLE_SELECTION);
    };
    return eventHandlers;
})(eventNames, convenienceApi);

1
2
3
var localizedButtonName = convenienceApi.i18n.tr( "action_bar.edit" ); 
 console.log(localizedButtonName);  // "Edit" if locale is set to "en-US" 
 // "Editar" if locale is set to "es-ES"

1
2
var currentLocale = convenienceApi.i18n.getLocale(); 
 console.log(currentLocale);  // "en"

1
2
3
4
5
6
7
8
9
10
11
// Get an object that formats to the current locale. 
 var numberOptions = { 
      style:  "currency" , 
      currency:  "EUR" 
 }; 
 var numberFormatter = convenienceApi.i18n.nf(numberOptions, convenienceApi.i18n.getLocale()); 
 
 // Format 
 var localizedNumber = numberFormatter.format(123456.123); 
 console.log(localizedNumber);  // "€123,456.123" if locale is set to "en-US". 
 // "123.456,123 €" if locale is set to "de-DE".

1
2
3
4
5
6
7
8
9
10
11
12
// Get an object that formats to the current locale. 
 var dateOptions = { 
      year:  'numeric' , 
      month:  '2-digit' , 
      day:  '2-digit' 
 }; 
 var dateFormatter = convenienceApi.i18n.df(dateOptions, convenienceApi.i18n.getLocale()); 
 
 // Format 
 var localizedDate = dateFormatter.format( new Date(2017, 5, 1)); 
 console.log(localizedDate);  // "05/01/2017" if locale is set to "en-US". 
 // "01.05.2017" if locale is set to "de-DE".

1
2
3
4
convenienceApi.i18n.addResources( "en" , { 
      "console_title" :  "Batch Set" , 
      "console_section_manageBatches.title" :  "Manage Batches" 
 });

1
2
3
4
5
6
7
var removedObject = convenienceApi.layout.removeFieldFromLayout( layoutData, "LastModifiedOn");
if(removedObject == null) {
     console.log("Object was not deleted."); 
}
else {
      console.log("Object was deleted.");
}

1
2
var logger = convenienceApi.logFactory.getLogger( "arbitrary-log-identifier" ); 
            logger.info( "Info-level message!" )

1
2
3
4
5
6
7
8
9
10
var model = {
  title: "Confirmation Modal Example",
  acceptAction: function acceptAction() {
    console.log("Accept button was clicked");
  },
  cancelAction: function cancelAction() {
    console.log("Cancel button was clicked");
  }
};
convenienceApi.modalService.confirm(model);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var model = {
     title:  "Progress Modal Example",
     value: 0,
     cancelAction: function cancelAction() {
          console.log( "Cancel button was clicked" );
     }
};
 
var fakeAfterModalOpeningHandler = function fakeAfterModalOpeningHandler() {
     // This sets the progress value to 100 after 1 second.
     setTimeout(function () {
          model.value = 100;
     }, 1000);
};
 
convenienceApi.modalService.openProgressModal(model, fakeAfterModalOpeningHandler);

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
// Create custom modal content container.
var contentContainer = document.createElement("div");
 
// Create custom modal model. Initially, display it in loading state.
var model = {
     isLoading: true,
     theme: convenienceApi.constants.MODAL_THEMES.CONFIRMATION,
     contentElement: contentContainer
};
 
convenienceApi.modalService.openCustomModal(model).then(function (closeResult) {
     if (closeResult.wasCancelled) {
          console.log("Custom modal was cancelled");
     } else {
          console.log("Custom modal was accepted");
     }
     console.log(closeResult);
});
 
// This section could be an async data load for custom modal content.
setTimeout(function () {
     // Disable loading state.
     model.isLoading = false;
     // Populate DOM content.
     contentContainer.innerText = "Loaded content";
 
     // Define actions for the custom modal.
     model.actions = [
          {
               text: "Ok" ,
               click: function click() {
                    model.accept("Accept payload");
               }
          },
          {
               text: "Disabled action" ,
               disabled: true
          },
          {
               text: "Cancel" ,
               click: function click() {
                    model.cancel("Cancel payload");
               }
          }
     ];
}, 1000);

1
2
3
4
5
6
7
8
9
10
11
12
var modalData = {
     title: "Demo advanced condition",
     conditions: []
};
convenienceApi.modalService.openAdvancedConditionModal(modalData).then(function (action) {
     if (!action.wasCancelled) {
          console.log("Advanced condition entered");
          // Action.output holds an array of Condition objects.
     } else {
          console.log("Advanced condition entering cancelled");
     }
});

1
2
3
4
5
6
7
8
9
10
var modalData = {
     objectTypeName: "Object Type Name"
};
convenienceApi.modalService.openDeleteModal(modalData).then(function (action) {
     if (!action.wasCancelled) {
          console.log("Delete the thing here");
     } else {
          console.log("Cancelled, so don't delete the thing");
     }
});

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
var mockData = [
     {
          "Name": "test1 name",
          "ArtifactID": 1039665
     },
     {
          "Name": "test2 name",
          "ArtifactID": 1039666
     }
];
 
// Create item list data provider instance.
var itemListDataProvider = {
     getFieldMetadata: function (fieldName) {
          // not used in this example, but it is an example of what the return shape looks like
          return {
               artifactID: 0,
               artifactViewFieldID: 0,
               associativeObjectTypeID: 0,
               columnName: "Name",
               fieldTypeID: 0, // fixed length text
               filterType: "None",
               headerName: null,
               itemListType: "Text",
               isSystem: false
          };
     },
     getColumns: function (itemListReloadHandler) {
          var toolbarContentElement = document.createElement("span");
          toolbarContentElement.innerText = "Content of Toolbar Content element";
          var noop = function () {};
          return convenienceApi.promiseFactory.resolve([
               {
                    id: "0",
                    actAsAdvanced: false,
                    defaultWidth: 150,
                    content: {
                         comparer: null,
                         dataLocation: "ArtifactID", // key to look for in each data entry
                         formatDefinition: null,
                         formatters: null
                    },
                    contentAlignment: null,
                    headerContent: {
                         clickable: false,
                         indicators: null,
                         title: null,
                         toolbarContent: toolbarContentElement
                    },
                    highlighted: false,
                    minWidth: 75,
                    resizable: true,
                    separatorVisible: true,
                    title: "Artifact ID",
                    width: 150,
                    wrapped: true,
 
                    filter: null,
                    filterable: false,
                    filterAdvanced: false,
                    filterOperators: null,
                    filterTitle: null,
                    filterAriaLabel: null,
                    filterOperatorAriaLabel: null,
                    sortable: false,
                    sortDirection: null,
                    sortTitle: null,
                    containerClass: null,
 
                    prepareForGrid: noop,
                    generateFilterElement: noop
               },
               {
                    id: "1",
                    actAsAdvanced: false,
                    defaultWidth: 150,
                    content: {
                         comparer: null,
                         dataLocation: "Name", // key to look for in each data entry
                         formatDefinition: null,
                         formatters: null
                    },
                    contentAlignment: null,
                    headerContent: {
                         clickable: false,
                         indicators: null,
                         title: null,
                         toolbarContent: toolbarContentElement
                    },
                    highlighted: false,
                    minWidth: 75,
                    resizable: true,
                    separatorVisible: true,
                    title: "Name",
                    width: 150,
                    wrapped: true,
 
                    filter: null,
                    filterable: false,
                    filterAdvanced: false,
                    filterOperators: null,
                    filterTitle: null,
                    filterAriaLabel: null,
                    filterOperatorAriaLabel: null,
                    sortable: false,
                    sortDirection: null,
                    sortTitle: null,
                    containerClass: null,
 
                    prepareForGrid: noop,
                    generateFilterElement: noop
               }
          ]);
     },
     getTextIdentifierColumnName: function () {
          return "Name";
     },
     query: function (request, columns) {
          var filteredData = mockData.slice();
 
          if (request.idsToExclude !== void 0) {
               // exclude certain values from result
               filteredData = filteredData.filter(function (entry) {
                    var includeEntry = true;
                    var i;
                    for (i = 0; i < request.idsToExclude.length; ++i) {
                         if (request.idsToExclude[i] === entry.ArtifactID) {
                              includeEntry = false;
                              break;
                         }
                    }
                    return includeEntry;
               });
          }
 
          if (request.idsToInclude !== void 0) {
               // include certain values in result
               filteredData = filteredData.filter(function (entry) {
                    var includeEntry = false;
                    var i;
                    for (i = 0; i < request.idsToInclude.length; ++i) {
                         if (request.idsToInclude[i] === entry.ArtifactID) {
                              includeEntry = true;
                              break;
                         }
                    }
                    return includeEntry;
               });
          }
 
          return convenienceApi.promiseFactory.resolve({
               "Results": filteredData,
               "TotalCount": filteredData.length,
               "CurrentStartIndex": 1
          });
     },
     getValuesByIds: function (ids) {
          // not used in this example; dummy data only to show shape of response
          return convenienceApi.promiseFactory.resolve(mockData.slice());
     }
};
 
 
// Create item list setting persistence service.
var itemListSettingPersistenceService = {
     getItemListState: function (itemListKey) {
          // read item list state from persistence based on itemListKey
          return {
               startIndex: 1,
               totalItems: 1,
               pageSize: 10,
               data: [],
               filters: [],
               sorts: [],
               columnWidths: {}
          };
     },
     getItemListStateOrDefault: function (itemListKey, columnWidthsKey) {
          var state = this.getItemListState(itemListKey);
          var columnWidths = this.getItemListColumnWidths(columnWidthsKey);
 
          if (!state) {
               state = {
                    startIndex: 1,
                    totalItems: 0,
                    pageSize: 10,
                    data: [],
                    filters: [],
                    sorts: [],
                    columnWidths: {}
               };
          }
 
          state.columnWidths = columnWidths;
          return state;
     },
     setItemListState: function (itemListKey, itemListStateValue) {
          // write item list state to persistence based on itemListKey
     },
     getFiltersVisible: function (itemListKey, workspaceId) {
          // read filters boolean from persistence or remotely based on itemListKey or workspaceId
          return convenienceApi.promiseFactory.resolve(false);
     },
     setFiltersVisible: function (itemListKey, filtersVisibleValue) {
          // write filters boolean to persistence based on itemListKey
     },
     getGridStyle: function () {
          // read grid style from persistence or remotely based on itemListKey
          return convenienceApi.promiseFactory.resolve(false);
     },
     setGridStyle: function (gridStyleValue) {
          // write grid style boolean to persistence
     },
     getItemListColumnWidths: function (columnWidthsKey) {
          // read item list column widths from persistence based on columnWidthsKey
          return {};
     },
     setItemListColumnWidth: function (itemListKey, columnKey, width) {
          // write item list column width to persistence based on itemListKey and columnKey
     }
};
 
var model = {
     label:  "MLP sample",
     persistenceKey:  "MY_PERSISTENCE_STRING",
     columnsPersistenceKey:  "MY_COLUMN_WIDTH_PERSISTENCE_KEY",
     rowKeyName:  "ArtifactID", // determines the key of each row (used in itemListDataProvider.query)
     selectedValues: [],
     itemListDataProvider: itemListDataProvider,
     itemListSettingPersistenceService: itemListSettingPersistenceService,
     workspaceId: -1,
     objectTypeId: 0
};
 
// could put this in an onclick event for a button, for example
convenienceApi.modalService.openMultiListPickerModal(model).then(function (action) {
     if (!action.wasCancelled) {
          console.log("Multiple items selected");
          // action.output contains the artifact IDs of selected items.
          console.dir(action.output);
     }  else {
          console.log("Selection of multiple items cancelled");
     }
});

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
// Create item list data provider instance and item list setting persistence service. (see openMultiListPickerModal sample above for details)
var itemListDataProvider = // ...
var itemListSettingPersistenceService = // ...
 
var model = {
     label:  "SLP sample",
     persistenceKey:  "MY_PERSISTENCE_STRING",
     columnsPersistenceKey:  "MY_COLUMN_WIDTH_PERSISTENCE_KEY",
     rowKeyName:  "ArtifactID",
     selectedValue: 0,
     itemListDataProvider: itemListDataProvider,
     itemListSettingPersistenceService: itemListSettingPersistenceService,
     workspaceId: -1,
     objectTypeId: 0
};
 
convenienceApi.modalService.openSingleListPickerModal(model).then(function (action) {
     if (!action.wasCancelled) {
          console.log("Item selected");
          // action.output contains ArtifactID of selected item
          console.log(action.output);
     }  else {
          console.log("Item selection cancelled");
     }
});

1
2
3
4
convenienceApi.popupService.open( "https://google.com" ,  "Google" , { 
      width: 200, 
      height: 200 
 });

1
2
var groupArtifactId = 1015028; 
 convenienceApi.previewSecurity.openForGroup(groupArtifactId);

1
2
3
4
5
6
7
8
9
var promise1 = convenienceApi.promiseFactory.resolve(3); 
 var promise2 = 42; 
 var promise3 =  new Promise(function (resolve, reject) { 
    setTimeout(resolve, 100,  'tests' ); 
 }); 
 var promise = convenienceApi.promiseFactory.all([promise1, promise2, promise3]); 
 promise.then(function (values) { 
    console.log(values);  // [3, 42, "tests"] 
 });

1
2
3
4
5
6
7
var promise = convenienceApi.promiseFactory.reject( "rejection" ); 
 
 promise.then(function(resolvesTo) { 
      console.log(resolvesTo);     // Never called. 
 }, function(rejectsTo) { 
      console.log(rejectsTo);         // "rejection" 
 });

1
2
3
4
5
var promise = convenienceApi.promiseFactory.resolve( "resolution" ); 
 
 promise.then(function(resolvesTo) { 
      console.log(resolvesTo);     // "resolution" 
 });

1
2
3
4
5
6
7
8
openAdd({ 
   workspaceId: Number, 
   artifactTypeId: Number, 
   parentArtifactId: Number,  
   associatedArtifactId: Number,  // optional 
   connectorFieldArtifactId: Number,  // optional 
   eventHandlerFactory: Function  // optional 
 })

1
2
3
4
5
6
openEdit({  
   workspaceId: Number, 
   artifactTypeId: Number, 
   artifactId: Number, 
   eventHandlerFactory: Function  // optional 
 })

1
2
3
4
5
6
openView({  
   workspaceId: Number, 
   artifactTypeId: Number, 
   artifactId: Number, 
   eventHandlerFactory: Function  // optional 
 })

1
2
3
4
5
6
7
8
9
var url = "any/url";
var requestOptions = {
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
};
var responseJsonPromise = convenienceApi.relativityHttpClient.get(url, requestOptions)
    .then(function (response) { return response.json(); });

1
2
3
4
5
6
7
8
9
10
11
12
var url = "any/url";
var payload = {
     any: "parameter"
};
var requestOptions = {
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
};
var responseJsonPromise = convenienceApi.relativityHttpClient.post(url, payload, requestOptions)
    .then(function (response) { return response.json(); });

1
2
3
4
5
6
7
8
9
10
11
12
var url = "any/url";
var payload = {
    any: "parameter"
};
var requestOptions = {
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
};
var responseJsonPromise = convenienceApi.relativityHttpClient.put(url, requestOptions)
    .then(function(response) { return response.json(); });

1
2
3
4
5
6
7
8
var url = "any/url";
var requestOptions = {
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
};
var deleteCompletePromise = convenienceApi.relativityHttpClient.delete(url, requestOptions);

1
var relativityUrl = makeRelativityRelativeUrl( "some/path/and/service.asmx" );

1
2
3
4
5
6
7
var requestOptions= makeRelativityBaseRequestOptions({
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
});
var responsePromise = convenienceApi.relativityHttpClient.get("any/relativity/url", requestOptions);

1
var relativityRestUrl = makeRelativityRestRelativeUrl( "/Workspace/3040506/Custodian" );

1
2
3
4
5
6
7
var requestOptions= makeRelativityRestBaseRequestOptions({
     cache: "no-store",
     headers: {
          "header-name": "header-value"
     }
});
var responsePromise = convenienceApi.relativityHttpClient.get("any/relativity/rest/url", requestOptions);

1
2
3
4
5
6
7
8
exampleTypeEventHandlers[eventNames.PAGE_INTERACTION] = function() { 
      const reviewQueueBrowser = convenienceApi.reviewQueueBrowser; 
 
      reviewQueueBrowser.navigate.first().then( 
          function() { console.log("navigated to the first index") }, 
          function(err) { console.error(err) } 
      ); 
 };

1
2
3
4
5
6
7
8
exampleTypeEventHandlers[eventNames.PAGE_INTERACTION] = function() { 
      const reviewQueueBrowser = convenienceApi.reviewQueueBrowser; 
 
      reviewQueueBrowser.navigate.previous().then( 
          function() { console.log("navigated to " + reviewQueueBrowser.currentQueueIndex) }, 
          function(err) { console.error(err) } 
      ); 
 };

1
2
3
4
5
6
7
8
exampleTypeEventHandlers[eventNames.PAGE_INTERACTION] = function() { 
      const reviewQueueBrowser = convenienceApi.reviewQueueBrowser; 
 
      reviewQueueBrowser.navigate.next().then( 
          function() { console.log("navigated to " + reviewQueueBrowser.currentQueueIndex) }, 
          function(err) { console.error(err) } 
      ); 
 };

1
2
3
4
5
6
7
8
exampleTypeEventHandlers[eventNames.PAGE_INTERACTION] = function() { 
      const reviewQueueBrowser = convenienceApi.reviewQueueBrowser; 
 
      reviewQueueBrowser.navigate.last().then( 
          function() { console.log("navigated to the last index") }, 
          function(err) { console.error(err) } 
      ); 
 };

1
2
3
4
5
6
7
8
exampleTypeEventHandlers[eventNames.PAGE_INTERACTION] = function() { 
      const reviewQueueBrowser = convenienceApi.reviewQueueBrowser; 
 
      reviewQueueBrowser.navigate.byIndex(2).then( 
          function() { console.log("navigated to the 3rd object") },
          function(err) { console.error(err) } 
      ); 
 };

1
   convenienceApi.user.getCurrentAclUserId(workspaceId).then(function (userId) {  someCallback(userId);});

1
2
3
4
5
6
var htmlEvent = { target: 1, __target: 2 }; 
 var target = convenienceApi.utilities.getHtmlEventTarget(htmlEvent); 
 console.log(target); 
 /* Console output: 
   *     2 
   */

1
2
3
4
5
6
7
8
9
var relativityWindow = convenienceApi.utilities.getRelativityPageBaseWindow();

console.log(relativityWindow.GetRelativityApplicationWebResourceFile("some-guid", "latest", "file.txt"));

/* Console output:

 * "/Relativity/RelativityApplicationWebResourceFile/some-guid/latest/file.txt"

 */

1
2
3
4
5
6
7
8
9
10
11
12
var someArray = [ 
      { Order: 1, Letter:  "A" },  
      { Order: 2, Letter:  "B" },  
      { Order: 3, Letter:  "C" },  
      { Order: 4, Letter:  "D" } 
 ]; 
 
 var arr = convenienceApi.utilities.keyValueArrayToJsonArrayTransformer(someArray,  "Order" ); 
 console.log(arr); 
 /* Console output: 
   *     [1, 2, 3, 4] 
   */

1
   convenienceApi.utilities.reload();

1
2
3
4
5
6
7
8
9
{
    scope: {                      // an object that will make a validation object show failures against a particular field
        type: const,              // FIELD_VALIDATION_SCOPE
        id:   String or Number,   // id of the field that owns the validation object
    }
    result:   List<String>,       // list of validation messages
    success:  bool,               // result of validation check
    errors:   List<String>        // list of error messages
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* 
   * 1. Single message example 
   */ 
 
 function validateSaveHandler(response, validationArray) { 
    /* 
     * For example, a response from the save request contains error object of the following shape: 
     * response = { 
     *     success: false,     
     *     message: "Name already exists." 
     * } 
     */ 
    if (!response.success) { 
      var errorSummary = convenienceApi.validation.getFailedSummaryObject(response.message);  // Create a validation object for displaying the given error message below the action bar. 
      validationArray.push(errorSummary);  // Append it to the validationArray for the application to display. 
    } 
 }

1
2
3
4
5
6
7
8
9
10
11
/* 
   * 2. Multiple message example 
   */
 
function validateSaveHandler(response, validationArray) { 
    var multipleMessages = [ "First error" ,  "Second error" ,  "Third error" ];
 
 
   var  errorSummary = convenienceApi.validation.getFailedSummaryObject(multipleMessages);  // Create a validation object for displaying the given error message below the action bar. 
    validationArray.push(errorSummary);  // Append it to the validationArray for the application to display. 
 }

1
2
3
4
5
6
7
8
9
{
    scope: {                      // an object that will make a validation object show failures against a particular field
        type: const,              // FIELD_VALIDATION_SCOPE
        id:   String or Number,   // id of the field that owns the validation object
    }
    result:   List<String>,       // list of validation messages
    success:  bool,               // result of validation check
    errors:   List<String>        // list of error messages
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function validateSaveHandler(response, validationArray) {
 /*
  * For example, a response from the save request contains error object of the following shape:
  * response = {
  *     success: false,    
  *     messages: [
  *         { propertyName: "Name", message: "Field is mandatory" }
  *     ]
  * }
  */
  if (!response.success) {
    for (var i = 0; i < response.messages.length; i++) {
      var message = response.messages[i];
      var fieldId = this.fieldNameToFieldIdMap.get(message.propertyName);
      var fieldError = convenienceApi.validation.getFailedFieldObject(fieldId, message.message); // Create a validation object for displaying the given error message below a field.
      validationArray.push(fieldError); // Append it to the validationArray for the application to display.
    }
  }
};

1
2
3
4
5
6
7
8
9
10
function validateSaveHandler(response, validationArray) {
  if (!response.success) {
    var summaryMessage = convenienceApi.validation.getDefaultSummaryErrorForAction(convenienceApi.constants.ACTIONS.SAVE);
    // When localized to EN, summaryMessage = "Cannot Save."
    // When localized to ES, summaryMessage = "No puede Salvar."    
     
    var errorSummary = convenienceApi.validation.getFailedSummaryObject(summaryMessage); // Create a validation object for displaying the default save error message in the current localization
    validationArray.push(errorSummary); // Append it to the validationArray for the application to display.
  }
}