Eksempel: Hent flere poster ved hjælp af OData-slutpunktet med JavaScript

Artikel
07/06/2017

Udgivet: november 2016

Gælder for: Dynamics CRM 2015

Denne eksempelkode er for Microsoft Dynamics CRM 2015 og opdatering til Microsoft Dynamics CRM Online 2015. Hent SDK-pakken til Microsoft Dynamics CRM. Den findes på følgende placering i downloadpakken:

SDK/SampleCode/JS/RESTEndpoint/JavaScriptRESTRetrieveMultiple

Hvis du blot vil se, hvordan dette eksempel fungerer, kan du installere (importere) den JavaScriptRESTRetrieveMultiple_1_0_0_0_managed.zip-administrerede løsning, der er indeholdt i downloadfilerne. Hvis du installerer denne administrerede løsning, og du vil oprette webressourcer, der bruger navnene nedenfor, kan løsningsudgiverens tilpasningspræfiks ikke være "sample", medmindre du fjerner (sletter) den administrerede løsning.

Krav

Du kan se dette eksempel på konfigurationssiden for løsningen, når du har installeret det.

Eksempel på brugergrænseflade

I dette eksempel bruges følgende fire webressourcer:

sample_/JavaScriptRESTRetrieveMultiple.htm
En HTML-side, der giver en brugergrænseflade og funktioner til kald af SDK.REST.retrieveMultipleRecords-funktionen, der henter data. Denne side er angivet som konfigurationssiden for eksempelløsningen.
sample_/Scripts/SDK.REST.js
Dette JavaScript-bibliotek indeholder SDK.REST.retrieveMultipleRecords-funktionen samt andre funktioner for brug af REST-slutpunktet til webressourcer.
sample_/Styles/JavaScriptRESTRetrieveMultiple.css
Denne CSS-fil med overlappende typografiark indeholder typografier til sample_/JavaScriptRESTRetrieveMultiple.htm.

Bemærk

Tilpasningspræfikset " sample_" bruges ikke i kode. Disse eksempler kan fungere ved hjælp af tilpasningspræfikset fra enhver udgiver. Men den relative sti til den simulerede Scripts and Styles-mappe, der skal medtages i navnet på webressourcerne.

Demonstrerer

Antallet af poster, der returneres af slutpunktet REST, er som standard begrænset til 50 poster. I dette eksempel vises, hvordan du kan hente flere poster uden hensyntagen til denne begrænsning.

Dette eksempel bruger følgende fremgangsmåde:

Hændelseshandleren document.onreadystatechange indeholder kode til at angive forskellige elementer i brugergrænsefladen til globale variabler, angive retrieveAccounts-funktionen som klikhændelseshandler for knappen Hent konti (btnRetrieveAccounts) og derefter kalde metoden click for btnRetrieveAccounts-knappen.
Funktionen retrieveAccounts rydder accountGrid og henter antallet af poster, der skal hentes fra numberOfAccountsToRetrieve-valgkontrolelementet. Denne værdi føjes til OData System-forespørgselsindstillingerne, der skal overføres til SDK.REST.retrieveMultipleRecords-indstillingsparameteren.
Metoden SDK.REST.retrieveMultipleRecords accepterer følgende parametre:
- type: Skemanavnet på den objekttypepost, der skal hentes. I dette eksempel bruges "Firma", så firmaposter hentes.
- options: En streng, der repræsenterer indstillingerne for OData System-forespørgslen til at styre de returnerede data. I dette eksempel er firmaet Name og Telephone1-attributterne angivet, og en $top-forespørgselsindstilling er indstillet til en værdi over 50 postgrænsen, der er standard.
- successCallback: Den funktion, der overføres og kaldes for hver side af returnerede poster. I dette eksempel bruges retrieveAccountsCallBack-funktionen.
- errorCallback: Den funktion, der overføres og kaldes af et mislykket svar. I dette eksempel bruges en anonym funktion, der viser meddelelsen af eventuelle fejl ved hjælp af alert-funktionen.
- OnComplete: Den funktion, der kaldes, når alle de ønskede poster er returneret. I dette eksempel bruges accountsRetrieveComplete-funktionen.
Funktionen SDK.REST.retrieveMultipleRecords forbereder en XMLHttpRequest til at hente de ønskede firmaposter og sender anmodningen.
- I anmodningens onreadystatechange-hændelseshandler bliver de første 50 resultater sendt tilbage til funktionen retrieveAccountsCallBack som successCallback. Denne funktion genererer HTML-rækkerne for hver enkelt post og føjer dem til accountsGrid-tabellen.
- Hvis det det samlede antal ønskede poster ved hjælp af $top-forespørgselsindstillingen endnu ikke er blevet hentet, vil __next-objektet indeholde en URL til hentning af det næste sæt af 50 poster. URL-adressen er blevet manipuleret til kun at udtrække forespørgselsindstillingerne og derefter overføre dem til SDK.REST.retrieveMultipleRecords-funktionen. Dette funktionskald, der refererer til sig selv, gentages, indtil det ønskede antal poster er returneret, eller der ikke er flere poster, der skal returneres.
- Når __next-objektet ikke længere returneres med resultaterne, bliver accountsRetrieveComplete-funktionen udført som OnComplete-funktionen. Denne funktion angiver det samlede antal poster, der er returneret, og viser en succesmeddelelse.
Når siden er indlæst med standardværdierne, kan du anmode om et andet antal poster ved hjælp af valgkontrolelementet Maksimalt antal konti, der skal hentes (numberOfAccountsToRetrieve) og sende en anden anmodning ved hjælp af knappen Hent konti (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

Se også

Forespørge på Microsoft Dynamics CRM 2015-data ved hjælp af OData-slutpunkt
Begrænsninger på antallet af returnerede poster
Brug OData-slutpunktet med Ajax og JScript-webressourcer
Eksempel: Tilknyt og ophæv tilknytningen af poster ved hjælp af OData-slutpunktet med JavaScript
Brug OData-slutpunktet med webressourcer
Teknisk artikel: Brug af grupperede indstillinger sammen med slutpunktet REST – JScript

Del via