Esempio: Recuperare più record utilizzando l'endpoint OData con JavaScript

Articolo
07/06/2017

Data di pubblicazione: novembre 2016

Si applica a: Dynamics CRM 2015

Questo codice di esempio è per Aggiornamento di Microsoft Dynamics CRM 2015 e Microsoft Dynamics CRM Online 2015. Scarica il pacchetto SDK di Microsoft Dynamics CRM. È disponibile nel percorso seguente nel pacchetto di download:

SDK/SampleCode/JS/RESTEndpoint/JavaScriptRESTRetrieveMultiple

Se si desidera visualizzare solo il funzionamento di questo esempio, è possibile installare (importare) la soluzione gestita JavaScriptRESTRetrieveMultiple_1_0_0_0_managed.zip inclusa nei file di download. Se si installa questa soluzione gestita e si desidera creare le risorse Web utilizzando i nomi riportati di seguito, il prefisso di personalizzazione dell'autore della soluzione non può essere "sample" a meno che non si disinstalli (elimini) la soluzione gestita.

Requisiti

È possibile visualizzare questo esempio nella pagina di configurazione per la soluzione in seguito all'installazione della stessa.

Interfaccia utente di esempio

In questo esempio vengono utilizzate le seguenti quattro risorse Web:

sample_/JavaScriptRESTRetrieveMultiple.htm
Una pagina HTML contenente l'interfaccia utente e le funzioni per chiamare la funzione SDK.REST.retrieveMultipleRecords per recuperare i dati. Questa pagina viene impostata come pagina di configurazione per la soluzione di esempio.
sample_/Scripts/SDK.REST.js
Questa libreria JavaScript fornisce la funzione SDK.REST.retrieveMultipleRecords nonché altre funzioni per l'utilizzo dell'endpoint di REST per le risorse Web.
sample_/Styles/JavaScriptRESTRetrieveMultiple.css
Il file di foglio di stile CSS fornisce stili per sample_/JavaScriptRESTRetrieveMultiple.htm.

Nota

Il prefisso di personalizzazione ” sample_” non è utilizzato nel codice. Tali esempi funzioneranno utilizzando il prefisso di personalizzazione di qualsiasi autore. Tuttavia, il percorso relativo della cartella di Scripts and Styles simulata deve essere incluso nel nome delle risorse Web.

Dimostra

Per impostazione predefinita il numero di record restituiti dall'endpoint di REST è limitato a 50 record. In questo esempio viene illustrato come recuperare più record indipendentemente da questa limitazione.

In questo esempio viene utilizzato il seguente approccio:

Il gestore eventi document.onreadystatechange include il codice per impostare diversi elementi di interfaccia utente come variabili globali, impostare la funzione retrieveAccounts come gestore evento Click per il pulsante Recupera account (btnRetrieveAccounts) e quindi chiamare il metodo click per il pulsante btnRetrieveAccounts.
La funzione retrieveAccounts cancella accountGrid e recupera il numero di record da recuperare per il controllo di selezione numberOfAccountsToRetrieve. Questo valore viene aggiunto alle opzioni di query di sistema OData per essere passato al parametro di opzioni SDK.REST.retrieveMultipleRecords.
Il metodo SDK.REST.retrieveMultipleRecords accetta i parametri seguenti:
- type: Il nome dello schema del record del tipo di entità da recuperare. In questo esempio viene utilizzato "Account" in modo che vengano recuperati i record di account.
- options: Stringa che rappresenta opzioni query di sistema OData per controllare i dati restituiti. In questo esempio l'account Name e gli attributi Telephone1 sono impostati e un'opzione di query di $top è impostata su un valore superiore al valore massimo predefinito di 50 record.
- successCallback: La funzione che sarà passata e chiamata per ogni pagina di record restituita. Questo esempio utilizza la funzione retrieveAccountsCallBack.
- errorCallback: La funzione che dovrà essere passata e chiamata da una risposta non riuscita. Questo esempio utilizza una funzione anonima che visualizza il messaggio di qualunque errore utilizzando la funzione alert.
- OnComplete: La funzione che verrà chiamata quando tutti i record necessari sono stati restituiti. Questo esempio utilizza la funzione accountsRetrieveComplete.
La funzione SDK.REST.retrieveMultipleRecords prepara una XMLHttpRequest per recuperare i record di account richiesti e invia la richiesta.
- All'interno del gestore eventi onreadystatechange della richiesta, i primi 50 risultati vengono passati di nuovo alla funzione retrieveAccountsCallBack come successCallback. Questa funzione genera righe HTML per ogni record e le aggiunge alla tabella accountsGrid.
- Se il numero totale di record richiesti utilizzando l'opzione di query $top non è stato ancora recuperato, l'oggetto __next contiene un URL per recuperare il successivo set di 50 record. L'URL viene modificato per estrarre solo le opzioni query e quindi è passato alla funzione SDK.REST.retrieveMultipleRecords. Queste chiamata di funzione autoreferenziale si ripete fino a che il numero di record richiesto non viene restituito o non ci sono più record da restituire.
- Quando l'oggetto __next non viene più restituito con i risultati, la funzione accountsRetrieveComplete viene eseguita come la funzione OnComplete. Questa funzione imposta il numero totale di record restituiti e visualizza un messaggio che indica l'esito positivo dell'operazione.
Dopo il caricamento della pagina con i valori predefiniti, è possibile richiedere un numero di record diverso utilizzando il controllo di selezione Numero massimo di account da recuperare (numberOfAccountsToRetrieve) e inviare un'altra richiesta utilizzando il pulsante Recupera account (btnRetrieveAccounts).

sample_/JavaScriptRESTRetrieveMultiple.htm


<html lang="en-us">
<head>
 <title>REST Endpoint Paging with JScript</title>
 <meta http-equiv="X-UA-Compatible" content="IE=edge" />
 <script src="../ClientGlobalContext.js.aspx" type="text/javascript"></script>
 <script src="Scripts/SDK.REST.js" type="text/javascript"></script>
 <link href="Styles/JavaScriptRESTRetrieveMultiple.css" rel="stylesheet" type="text/css" />
 <script type="text/javascript">
  var accountsGrid; //The tbody element of the accountsTable
  var numberOfAccountsToRetrieve; // The select control with options for the number of records to retrieve.
  var btnRetrieveAccounts; //The button to retrieve accounts
  var accountsRetrieved; //The span displaying the number of account records retrieved.
  var successMessage; // The message displayed when records are returned.
  var totalAccountCount = 0;
  document.onreadystatechange = function () {
   if (document.readyState == "complete") {
    btnRetrieveAccounts = document.getElementById("btnRetrieveAccounts");
    accountsGrid = document.getElementById("accountsGrid");
    numberOfAccountsToRetrieve = document.getElementById("numberOfAccountsToRetrieve");
    accountsRetrieved = document.getElementById("accountsRetrieved");
    successMessage = document.getElementById("successMessage");
    btnRetrieveAccounts.onclick = retrieveAccounts;
    btnRetrieveAccounts.click();
   }
  }
  function retrieveAccounts() {
   ///<summary>
   /// Retrieves accounts by passing a filter to the SDK.RestEndpointPaging.RetrieveRecords function
   ///</summary>
   clearaccountsGrid();
   var number = parseInt(numberOfAccountsToRetrieve.options[numberOfAccountsToRetrieve.selectedIndex].value, 10);
   var options = "$select=Name,Telephone1&amp;$top=" + number;
   //The retrieveAccountsCallBack function is passed through as the successCallBack.
   SDK.REST.retrieveMultipleRecords("Account", options, retrieveAccountsCallBack, function (error) { alert(error.message); }, accountsRetrieveComplete);
  }
  function retrieveAccountsCallBack(retrievedAccounts) {
   ///<summary>
   /// This function is passed through the request and is iterated for each page of data
   /// This function appends rows to the accountsGrid.
   ///</summary>
   totalAccountCount = totalAccountCount + retrievedAccounts.length;
   for (var i = 0; i < retrievedAccounts.length; i++) {
    var account = retrievedAccounts[i];
    var row = document.createElement("tr");
    var nameCell = document.createElement("td");
    setElementText(nameCell, account.Name);
    row.appendChild(nameCell);
    var mainPhoneCell = document.createElement("td");
    setElementText(mainPhoneCell, (account.Telephone1 == null) ? "" : account.Telephone1);
    mainPhoneCell.className = "rightColumn";
    row.appendChild(mainPhoneCell);
    accountsGrid.appendChild(row);
   }
  }
  function accountsRetrieveComplete() {
   ///<summary>
   /// This function is called after all the records have been returned to update the actual total number of records.
   ///</summary>
   accountsRetrieved.innerText = totalAccountCount;
   successMessage.style.display = "block";
  }
  function clearaccountsGrid() {
   ///<summary>
   /// This function initializes the totalAccountCount and  clears all the rows from the accountsGrid
   /// in preparation for adding a new set of rows.
   ///</summary>
   successMessage.style.display = "none";
   totalAccountCount = 0;
   for (var i = accountsGrid.rows.length - 1; i >= 0; i--) {
    accountsGrid.deleteRow(i);
   }
  }
  function setElementText(element, text) {
   ///<summary>
   /// This function mitigates the fact that IE uses innerText and other browsers use textContent.
   ///</summary>
   if (typeof (element.innerText) != "undefined")
   { element.innerText = text; }
   else
   { element.textContent = text; }
  }
 </script>
</head>
<body>
 <table id="tableHeadings" summary="This table provides the headings for the list of accounts displayed in a grid.">
  <thead>
   <tr>
    <th class="leftColumn">
     Account Name
    </th>
    <th class="rightColumn">
     Main Phone
    </th>
   </tr>
  </thead>
 </table>


 <div id="tableContainer">
  <table id="accountsTable" rules="groups" summary="This table displays the accounts retrieved.">
   <tbody id="accountsGrid" />
  </table>


 </div>
 <div id="controlsContainer">
  <div>
   <span>Maximum Number of Accounts to Retrieve:
    <select id="numberOfAccountsToRetrieve">
     <option value="10" selected="selected">10</option>
     <option value="100" selected="selected">100</option>
     <option value="300">300</option>
     <option value="600">600</option>
     <option value="900">900</option>
    </select>
    <button id="btnRetrieveAccounts">
     Retrieve Accounts</button>
   </span>
  </div>
  <div id="successMessage" style="display: none;">
   Total Number of Accounts Retrieved : <span id="accountsRetrieved"></span>
  </div>
 </div>
</body>
</html>

sample_/Scripts/SDK.REST.js


if (typeof (SDK) == "undefined")
{ SDK = { __namespace: true }; }
SDK.REST = {
 _context: function () {
  ///<summary>
  /// Private function to the context object.
  ///</summary>
  ///<returns>Context</returns>
  if (typeof GetGlobalContext != "undefined")
  { return GetGlobalContext(); }
  else {
   if (typeof Xrm != "undefined") {
    return Xrm.Page.context;
   }
   else
   { throw new Error("Context is not available."); }
  }
 },
 _getClientUrl: function () {
  ///<summary>
  /// Private function to return the server URL from the context
  ///</summary>
  ///<returns>String</returns>
  var clientUrl = this._context().getClientUrl()

  return clientUrl;
 },
 _ODataPath: function () {
  ///<summary>
  /// Private function to return the path to the REST endpoint.
  ///</summary>
  ///<returns>String</returns>
  return this._getClientUrl() + "/XRMServices/2011/OrganizationData.svc/";
 },
 _errorHandler: function (req) {
  ///<summary>
  /// Private function return an Error object to the errorCallback
  ///</summary>
  ///<param name="req" type="XMLHttpRequest">
  /// The XMLHttpRequest response that returned an error.
  ///</param>
  ///<returns>Error</returns>
  //Error descriptions come from https://support.microsoft.com/kb/193625
  if (req.status == 12029)
  { return new Error("The attempt to connect to the server failed."); }
  if (req.status == 12007)
  { return new Error("The server name could not be resolved."); }
  var errorText;
  try
        { errorText = JSON.parse(req.responseText).error.message.value; }
  catch (e)
        { errorText = req.responseText }

  return new Error("Error : " +
        req.status + ": " +
        req.statusText + ": " + errorText);
 },
 _dateReviver: function (key, value) {
  ///<summary>
  /// Private function to convert matching string values to Date objects.
  ///</summary>
  ///<param name="key" type="String">
  /// The key used to identify the object property
  ///</param>
  ///<param name="value" type="String">
  /// The string value representing a date
  ///</param>
  var a;
  if (typeof value === 'string') {
   a = /Date\(([-+]?\d+)\)/.exec(value);
   if (a) {
    return new Date(parseInt(value.replace("/Date(", "").replace(")/", ""), 10));
   }
  }
  return value;
 },
 _parameterCheck: function (parameter, message) {
  ///<summary>
  /// Private function used to check whether required parameters are null or undefined
  ///</summary>
  ///<param name="parameter" type="Object">
  /// The parameter to check;
  ///</param>
  ///<param name="message" type="String">
  /// The error message text to include when the error is thrown.
  ///</param>
  if ((typeof parameter === "undefined") || parameter === null) {
   throw new Error(message);
  }
 },
 _stringParameterCheck: function (parameter, message) {
  ///<summary>
  /// Private function used to check whether required parameters are null or undefined
  ///</summary>
  ///<param name="parameter" type="String">
  /// The string parameter to check;
  ///</param>
  ///<param name="message" type="String">
  /// The error message text to include when the error is thrown.
  ///</param>
  if (typeof parameter != "string") {
   throw new Error(message);
  }
 },
 _callbackParameterCheck: function (callbackParameter, message) {
  ///<summary>
  /// Private function used to check whether required callback parameters are functions
  ///</summary>
  ///<param name="callbackParameter" type="Function">
  /// The callback parameter to check;
  ///</param>
  ///<param name="message" type="String">
  /// The error message text to include when the error is thrown.
  ///</param>
  if (typeof callbackParameter != "function") {
   throw new Error(message);
  }
 },
 createRecord: function (object, type, successCallback, errorCallback) {
  ///<summary>
  /// Sends an asynchronous request to create a new record.
  ///</summary>
  ///<param name="object" type="Object">
  /// A JavaScript object with properties corresponding to the Schema name of
  /// entity attributes that are valid for create operations.
  ///</param>
  ///<param name="type" type="String">
  /// The Schema Name of the Entity type record to create.
  /// For an Account record, use "Account"
  ///</param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// This function can accept the returned record as a parameter.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._parameterCheck(object, "SDK.REST.createRecord requires the object parameter.");
  this._stringParameterCheck(type, "SDK.REST.createRecord requires the type parameter is a string.");
  this._callbackParameterCheck(successCallback, "SDK.REST.createRecord requires the successCallback is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.createRecord requires the errorCallback is a function.");
  var req = new XMLHttpRequest();
  req.open("POST", encodeURI(this._ODataPath() + type + "Set"), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 201) {
     successCallback(JSON.parse(this.responseText, SDK.REST._dateReviver).d);
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send(JSON.stringify(object));
 },
 retrieveRecord: function (id, type, select, expand, successCallback, errorCallback) {
  ///<summary>
  /// Sends an asynchronous request to retrieve a record.
  ///</summary>
  ///<param name="id" type="String">
  /// A String representing the GUID value for the record to retrieve.
  ///</param>
  ///<param name="type" type="String">
  /// The Schema Name of the Entity type record to retrieve.
  /// For an Account record, use "Account"
  ///</param>
  ///<param name="select" type="String">
  /// A String representing the $select OData System Query Option to control which
  /// attributes will be returned. This is a comma separated list of Attribute names that are valid for retrieve.
  /// If null all properties for the record will be returned
  ///</param>
  ///<param name="expand" type="String">
  /// A String representing the $expand OData System Query Option value to control which
  /// related records are also returned. This is a comma separated list of of up to 6 entity relationship names
  /// If null no expanded related records will be returned.
  ///</param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// This function must accept the returned record as a parameter.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._stringParameterCheck(id, "SDK.REST.retrieveRecord requires the id parameter is a string.");
  this._stringParameterCheck(type, "SDK.REST.retrieveRecord requires the type parameter is a string.");
  if (select != null)
   this._stringParameterCheck(select, "SDK.REST.retrieveRecord requires the select parameter is a string.");
  if (expand != null)
   this._stringParameterCheck(expand, "SDK.REST.retrieveRecord requires the expand parameter is a string.");
  this._callbackParameterCheck(successCallback, "SDK.REST.retrieveRecord requires the successCallback parameter is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.retrieveRecord requires the errorCallback parameter is a function.");

  var systemQueryOptions = "";

  if (select != null || expand != null) {
   systemQueryOptions = "?";
   if (select != null) {
    var selectString = "$select=" + select;
    if (expand != null) {
     selectString = selectString + "," + expand;
    }
    systemQueryOptions = systemQueryOptions + selectString;
   }
   if (expand != null) {
    systemQueryOptions = systemQueryOptions + "&amp;$expand=" + expand;
   }
  }


  var req = new XMLHttpRequest();
  req.open("GET", encodeURI(this._ODataPath() + type + "Set(guid'" + id + "')" + systemQueryOptions), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 200) {
     successCallback(JSON.parse(this.responseText, SDK.REST._dateReviver).d);
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send();
 },
 updateRecord: function (id, object, type, successCallback, errorCallback) {
  ///<summary>
  /// Sends an asynchronous request to update a record.
  ///</summary>
  ///<param name="id" type="String">
  /// A String representing the GUID value for the record to retrieve.
  ///</param>
  ///<param name="object" type="Object">
  /// A JavaScript object with properties corresponding to the Schema Names for
  /// entity attributes that are valid for update operations.
  ///</param>
  ///<param name="type" type="String">
  /// The Schema Name of the Entity type record to retrieve.
  /// For an Account record, use "Account"
  ///</param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// Nothing will be returned to this function.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._stringParameterCheck(id, "SDK.REST.updateRecord requires the id parameter.");
  this._parameterCheck(object, "SDK.REST.updateRecord requires the object parameter.");
  this._stringParameterCheck(type, "SDK.REST.updateRecord requires the type parameter.");
  this._callbackParameterCheck(successCallback, "SDK.REST.updateRecord requires the successCallback is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.updateRecord requires the errorCallback is a function.");
  var req = new XMLHttpRequest();

  req.open("POST", encodeURI(this._ODataPath() + type + "Set(guid'" + id + "')"), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.setRequestHeader("X-HTTP-Method", "MERGE");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 204 || this.status == 1223) {
     successCallback();
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send(JSON.stringify(object));
 },
 deleteRecord: function (id, type, successCallback, errorCallback) {
  ///<summary>
  /// Sends an asynchronous request to delete a record.
  ///</summary>
  ///<param name="id" type="String">
  /// A String representing the GUID value for the record to delete.
  ///</param>
  ///<param name="type" type="String">
  /// The Schema Name of the Entity type record to delete.
  /// For an Account record, use "Account"
  ///</param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// Nothing will be returned to this function.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._stringParameterCheck(id, "SDK.REST.deleteRecord requires the id parameter.");
  this._stringParameterCheck(type, "SDK.REST.deleteRecord requires the type parameter.");
  this._callbackParameterCheck(successCallback, "SDK.REST.deleteRecord requires the successCallback is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.deleteRecord requires the errorCallback is a function.");
  var req = new XMLHttpRequest();
  req.open("POST", encodeURI(this._ODataPath() + type + "Set(guid'" + id + "')"), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.setRequestHeader("X-HTTP-Method", "DELETE");
  req.onreadystatechange = function () {

   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 204 || this.status == 1223) {
     successCallback();
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send();

 },
 retrieveMultipleRecords: function (type, options, successCallback, errorCallback, OnComplete) {
  ///<summary>
  /// Sends an asynchronous request to retrieve records.
  ///</summary>
  ///<param name="type" type="String">
  /// The Schema Name of the Entity type record to retrieve.
  /// For an Account record, use "Account"
  ///</param>
  ///<param name="options" type="String">
  /// A String representing the OData System Query Options to control the data returned
  ///</param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called for each page of records returned.
  /// Each page is 50 records. If you expect that more than one page of records will be returned,
  /// this function should loop through the results and push the records into an array outside of the function.
  /// Use the OnComplete event handler to know when all the records have been processed.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  ///<param name="OnComplete" type="Function">
  /// The function that will be called when all the requested records have been returned.
  /// No parameters are passed to this function.
  /// </param>
  this._stringParameterCheck(type, "SDK.REST.retrieveMultipleRecords requires the type parameter is a string.");
  if (options != null)
   this._stringParameterCheck(options, "SDK.REST.retrieveMultipleRecords requires the options parameter is a string.");
  this._callbackParameterCheck(successCallback, "SDK.REST.retrieveMultipleRecords requires the successCallback parameter is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.retrieveMultipleRecords requires the errorCallback parameter is a function.");
  this._callbackParameterCheck(OnComplete, "SDK.REST.retrieveMultipleRecords requires the OnComplete parameter is a function.");

  var optionsString;
  if (options != null) {
   if (options.charAt(0) != "?") {
    optionsString = "?" + options;
   }
   else
   { optionsString = options; }
  }
  var req = new XMLHttpRequest();
  req.open("GET", this._ODataPath() + type + "Set" + optionsString, true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 200) {
     var returned = JSON.parse(this.responseText, SDK.REST._dateReviver).d;
     successCallback(returned.results);
     if (returned.__next != null) {
      var queryOptions = returned.__next.substring((SDK.REST._ODataPath() + type + "Set").length);
      SDK.REST.retrieveMultipleRecords(type, queryOptions, successCallback, errorCallback, OnComplete);
     }
     else
     { OnComplete(); }
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send();
 },
 associateRecords: function (parentId, parentType, relationshipName, childId, childType, successCallback, errorCallback) {
  this._stringParameterCheck(parentId, "SDK.REST.associateRecords requires the parentId parameter is a string.");
  ///<param name="parentId" type="String">
  /// The Id of the record to be the parent record in the relationship
  /// </param>
  ///<param name="parentType" type="String">
  /// The Schema Name of the Entity type for the parent record.
  /// For an Account record, use "Account"
  /// </param>
  ///<param name="relationshipName" type="String">
  /// The Schema Name of the Entity Relationship to use to associate the records.
  /// To associate account records as a Parent account, use "Referencedaccount_parent_account"
  /// </param>
  ///<param name="childId" type="String">
  /// The Id of the record to be the child record in the relationship
  /// </param>
  ///<param name="childType" type="String">
  /// The Schema Name of the Entity type for the child record.
  /// For an Account record, use "Account"
  /// </param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// Nothing will be returned to this function.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._stringParameterCheck(parentType, "SDK.REST.associateRecords requires the parentType parameter is a string.");
  this._stringParameterCheck(relationshipName, "SDK.REST.associateRecords requires the relationshipName parameter is a string.");
  this._stringParameterCheck(childId, "SDK.REST.associateRecords requires the childId parameter is a string.");
  this._stringParameterCheck(childType, "SDK.REST.associateRecords requires the childType parameter is a string.");
  this._callbackParameterCheck(successCallback, "SDK.REST.associateRecords requires the successCallback parameter is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.associateRecords requires the errorCallback parameter is a function.");

  var req = new XMLHttpRequest();
  req.open("POST", encodeURI(this._ODataPath() + parentType + "Set(guid'" + parentId + "')/$links/" + relationshipName), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 204 || this.status == 1223) {
     successCallback();
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  var childEntityReference = {}
  childEntityReference.uri = this._ODataPath() + "/" + childType + "Set(guid'" + childId + "')";
  req.send(JSON.stringify(childEntityReference));
 },
 disassociateRecords: function (parentId, parentType, relationshipName, childId, successCallback, errorCallback) {
  this._stringParameterCheck(parentId, "SDK.REST.disassociateRecords requires the parentId parameter is a string.");
  ///<param name="parentId" type="String">
  /// The Id of the record to be the parent record in the relationship
  /// </param>
  ///<param name="parentType" type="String">
  /// The Schema Name of the Entity type for the parent record.
  /// For an Account record, use "Account"
  /// </param>
  ///<param name="relationshipName" type="String">
  /// The Schema Name of the Entity Relationship to use to disassociate the records.
  /// To disassociate account records as a Parent account, use "Referencedaccount_parent_account"
  /// </param>
  ///<param name="childId" type="String">
  /// The Id of the record to be disassociated as the child record in the relationship
  /// </param>
  ///<param name="successCallback" type="Function">
  /// The function that will be passed through and be called by a successful response. 
  /// Nothing will be returned to this function.
  /// </param>
  ///<param name="errorCallback" type="Function">
  /// The function that will be passed through and be called by a failed response. 
  /// This function must accept an Error object as a parameter.
  /// </param>
  this._stringParameterCheck(parentType, "SDK.REST.disassociateRecords requires the parentType parameter is a string.");
  this._stringParameterCheck(relationshipName, "SDK.REST.disassociateRecords requires the relationshipName parameter is a string.");
  this._stringParameterCheck(childId, "SDK.REST.disassociateRecords requires the childId parameter is a string.");
  this._callbackParameterCheck(successCallback, "SDK.REST.disassociateRecords requires the successCallback parameter is a function.");
  this._callbackParameterCheck(errorCallback, "SDK.REST.disassociateRecords requires the errorCallback parameter is a function.");

  var req = new XMLHttpRequest();
  req.open("POST", encodeURI(this._ODataPath() + parentType + "Set(guid'" + parentId + "')/$links/" + relationshipName + "(guid'" + childId + "')"), true);
  req.setRequestHeader("Accept", "application/json");
  req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  req.setRequestHeader("X-HTTP-Method", "DELETE");
  req.onreadystatechange = function () {
   if (this.readyState == 4 /* complete */) {
    req.onreadystatechange = null;
    if (this.status == 204 || this.status == 1223) {
     successCallback();
    }
    else {
     errorCallback(SDK.REST._errorHandler(this));
    }
   }
  };
  req.send();
 },
 __namespace: true
};

sample_/Styles/JavaScriptRESTRetrieveMultiple.css

Vedere anche

Eseguire una query sui dati di Microsoft Dynamics CRM 2015 tramite l'endpoint OData
Limitazioni del numero di record restituiti
Utilizzare l'endpoint OData con risorse Web Ajax e JScript
Esempio: associare e annullare l'associazione dei record utilizzando l'endpoint OData con JavaScript
Utilizzare l'endpoint OData con risorse Web
Articolo tecnico: Utilizzo delle opzioni Set di opzioni con l'endpoint REST - JScript

Condividi tramite