Venho neste post fazer um registro de um conjunto de informações para você que busca sobre Javascript para Dynamics CRM.
Esta estrutura é direcionada ao Dynamics CRM WebApi, portanto, CRM 2016 (> = v8.0) é necessário.
Navegador
Apesar de usar Promises, alguns navegadores legados ainda são suportados, já que o bluebird é usado como polyfill Promise. O Bluebird é incluído automaticamente na versão empacotada, nenhuma etapa adicional necessária. Para obter uma lista de navegadores suportados, verifique o suporte da plataforma bluebird .
Como obtê-lo
NPM
Este framework está no npm como UMD, graças à opção autônoma do browserify.
O nome do pacote é xrm-webapi-client, verifique:
Ao usá-lo no TypeScript, importe-o usando esta linha: import * as WebApiClient from "xrm-webapi-client";
Em seu tsconfig.json, moduledeve es6e moduleResolutiondeve ser node.
Lançamento GitHub
Você sempre pode baixar a versão com navegador dessa estrutura baixando o arquivo release.zip da versão mais recente .
Como construir
Você terá que instalar o npm em sua máquina.
Para inicialização, simplesmente execute npm installuma vez inicialmente. Para cada construção, você pode apenas chamar npm run build. Você encontrará a saída do build no diretório Publish.
Importar
Você pode importar essa biblioteca dentro do seu código desta forma:
import * como WebApiClient de "xrm-webapi-client" ;Operações
Síncrono vs Assíncrono
Por padrão, todas as solicitações são enviadas de forma assíncrona. Essa é a forma sugerida de envio de solicitações, porém, às vezes há a necessidade de utilizar solicitações síncronas.
Certifique-se de evitar solicitações síncronas, se possível, e use solicitações assíncronas.
Para enviar solicitações de forma síncrona, você pode definir WebApiClient.Asynccomo falso, o que configurará o WebApiClient para enviar todas as solicitações de forma síncrona, ou passar uma asyncpropriedade em sua solicitação, assim:
var request = {
entityName : "account" ,
entity : { name : "Adventure Works" } ,
assíncrono : false
} ;
tente {
var response = WebApiClient . Criar ( solicitar ) ;
// Resposta do processo
}
catch ( erro ) {
// Manipular erro
}Crio
O cliente suporta a criação de registros. Você deve passar o nome lógico da entidade e um objeto de dados:
var request = {
entityName : "account" ,
entity : { name : "Adventure Works" }
} ;
WebApiClient . Criar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Retornar registro criado em criar resposta
Este recurso está disponível a partir do Dynamics365 v8.2. Para retornar o registro completo que foi criado a partir de sua solicitação, defina um cabeçalho Prefer apropriado da seguinte maneira:
var request = {
entityName : "account" ,
entity : { name : "Adventure Works" } ,
cabeçalhos : [ { key : "Prefer" , value : "return = representação" } ]
} ;
WebApiClient . Criar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Recuperar
O cliente suporta a recuperação de registros por Id, por chave alternativa, fetchXml e expressões de consulta. Para recuperar por chave alternativa, passe um array de objetos, cada um com uma propriedade e uma propriedade de valor. Você deve passar pelo menos o nome lógico da entidade. Você sempre pode passar parâmetros de consulta que serão anexados às suas solicitações de recuperação.
Recuperar registros únicos
Recuperar por ID
solicitação de var = {
entityName : "account" ,
entityId : "00000000-0000-0000-0000-000000000001"
} ;
WebApiClient . Recuperar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Recuperar por chave alternativa
var request = {
entityName : "contact" ,
alternateKey :
[
{ property : "firstname" , value : "Joe" } ,
{ property : "emailaddress1" , value : "abc@example.com" }
]
} ;
WebApiClient . Recuperar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Recupere vários registros
A recuperação de vários registros usa paginação. Por padrão, você pode definir um tamanho de página em suas solicitações , no entanto, isso é limitado a 5.000 registros. Se você realmente deseja recuperar todos os registros, defina WebApiClient.ReturnAllPages como verdadeiro, pois é por padrão falso, assim:
WebApiClient . ReturnAllPages = true ;Ao definir isso como verdadeiro, cada solicitação de recuperação múltipla verificará se há uma propriedade @ odata.nextLink dentro da resposta, chamará a próxima página e concatenará os resultados, até que todos os registros tenham sido recuperados.
Você também pode passar essa opção por solicitação, como esta:
var request = {
entityName : "account" ,
queryParams : "? $ select = name , recipe , & $ orderby = receita asc, nome desc & $ filter = receita ne null" ,
returnAllPages : true
} ;Recuperar por expressão de consulta
var request = {
entityName : "account" ,
queryParams : "? $ select = name
, recipe , & $ orderby = receita asc, nome desc & $ filter = receita ne null" } ;
WebApiClient . Recuperar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Recuperar por FetchXml
As solicitações FetchXml têm algum comportamento especial implementado. FetchXml curto será enviado como uma solicitação GET usando um parâmetro de consulta de URL fetchXml. No entanto, há um limite de comprimento de URL de 2.048 caracteres, portanto, solicitações fetchXml grandes falhariam, pois excedem esse limite. Desde a versão v3.1.0, a solicitação será enviada automaticamente como uma solicitação em lote POST, de forma que fetchXml grande também possa ser executado. Você não precisa fazer nada para que isso aconteça, o comprimento da URL é verificado automaticamente antes de enviar a solicitação.
var request = {
entityName : "account" ,
fetchXml : "<fetch mapping = 'logical'>" +
"<entity name = 'account'>" +
"<attribute name = 'accountid' />" +
"<attribute name = 'nome' /> " +
" </entity> " +
" </fetch> "
} ;
WebApiClient . Recuperar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Expansão automática de propriedades de navegação com valor de coleção
Ao recuperar propriedades de navegação com valor de coleção, a expansão está sendo adiada, ou seja, você não recupera resultados imediatos, mas uma propriedade que termina em "@ odata.nextLink" que contém um URL para os resultados dessa expansão. Você pode ler mais sobre isso aqui . Para facilitar a recuperação, podemos usar a WebApiClient.Expandfunção. Ele pega uma matriz de registros e expande todas as propriedades, que terminam em "@ odata.nextLink". Além disso, você pode passar cabeçalhos para a solicitação, que serão anexados a cada solicitação de recuperação de propriedades.
WebApiClient . Recuperar ( {
entityName : "account" ,
queryParams : "? $
Expand = contact_customer_accounts" } )
. então ( função ( resposta ) {
retornar WebApiClient . Expand ( {
registros : resposta . valor
} ) ;
} )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Atualizar
Solicitações de atualização são suportadas. Você deve passar o nome lógico da entidade, o ID do registro a ser atualizado e um objeto de atualização:
var request = {
entityName : "account" ,
entityId : "00000000-0000-0000-0000-000000000001" ,
entity : { name : "Contoso" }
} ;
WebApiClient . Atualizar ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Atualizar por chave alternativa
var request = {
entityName : "contact" ,
alternateKey :
[
{ property : "firstname" , value : "Joe" } ,
{ property : "emailaddress1" , value : "abc@example.com" }
] ,
entity : { lastname : "Doe" }
} ;
WebApiClient . Atualizar ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Retornar registro atualizado na resposta de atualização
Este recurso está disponível a partir do Dynamics365 v8.2. Para retornar o registro completo após aplicar as atualizações de sua solicitação, defina um cabeçalho Prefer apropriado da seguinte maneira:
var request = {
entityName : "account" ,
entityId : "00000000-0000-0000-0000-000000000001" ,
entidade : { name : "Contoso" } ,
cabeçalhos : [ { key : "Prefer" , value : "return = representação " } ]
} ;
WebApiClient . Atualizar ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Limpar valor de pesquisa
Se você está tentando limpar um valor de pesquisa usando uma atualização com um valor nulo, pode muito bem ser que ele simplesmente não faz nada ou falha com um erro como Property _pub_field_value cannot be updated to null. The reference property can only be deleted. Nesse caso, você não pode usar uma solicitação de atualização para limpar a pesquisa.
Dê uma olhada na seção delete single property .
Excluir
Pedidos de exclusão são suportados. Você deve passar o nome lógico da entidade e o ID do registro a ser excluído:
solicitação de var = {
entityName : "account" ,
entityId : "00000000-0000-0000-0000-000000000001"
} ;
WebApiClient . Excluir ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Apagar por chave alternativa
var request = {
entityName : "contact" ,
alternateKey :
[
{ property : "firstname" , value : "Joe" } ,
{ property : "emailaddress1" , value : "abc@example.com" }
]
} ;
WebApiClient . Excluir ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Excluir uma única propriedade
Você pode excluir propriedades únicas passando o campo para limpar como queryParams com uma barra anterior, como "/ telefone1". Se for uma pesquisa, você terá que acrescentar antes "/ $ ref", como "/ primarycontactid / $ ref".
var request = {
entityName : "account" ,
entityId : "00000000-0000-0000-0000-000000000001" ,
queryParams : "/ primarycontactid / $ ref"
} ;
WebApiClient . Excluir ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Associado
Pedidos de associados são suportados. Você tem que passar o nome do relacionamento, uma fonte e uma entidade de destino. Este exemplo associa uma oportunidade a uma conta:
var request = {
relationshipShip : "opportunity_customer_accounts" ,
fonte :
{
entityName : "opportunity" ,
entityId : "00000000-0000-0000-0000-0000-000000000001"
} ,
destino :
{
entityName : "account" ,
entityId : "00000000-0000- 0000-0000-000000000002 "
}
} ;
WebApiClient . Associar ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Desassociar
Pedidos de desassociação são suportados. Você tem que passar o nome do relacionamento, uma fonte e uma entidade de destino. Este exemplo desassocia uma oportunidade de uma conta:
var request = {
relationshipShip : "opportunity_customer_accounts" ,
fonte :
{
entityName : "opportunity" ,
entityId : "00000000-0000-0000-0000-0000-000000000001"
} ,
destino :
{
entityName : "account" ,
entityId : "00000000-0000- 0000-0000-000000000002 "
}
} ;
WebApiClient . Desassociar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Executar
Há suporte para a execução de ações / funções sem a necessidade de usar SendRequest. O WebApiClient possui uma função WebApiClient.Execute, que recebe uma solicitação como parâmetro. As solicitações são objetos baseados na solicitação de base WebApiClient.Requests.Request. Quando quiser enviar uma requisição já implementada usando Execute, você pode usar a requisição em branco (como o WhoAmIRequest, que não precisa de nenhum parâmetro), ou caso precise de parâmetros, estender uma requisição existente.
Solicitações de ações ausentes ou personalizadas podem ser implementadas conforme descrito aqui .
Verifique o wiki para obter uma lista de solicitações que são implementadas na versão atual e exemplos de como enviá-las!
Sem solicitação de parâmetro
A solicitação WhoAmI não precisa de nenhum parâmetro, portanto, podemos apenas passar a solicitação em branco:
var request = WebApiClient . Pedidos . WhoAmIRequest ;
WebApiClient . Execute ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Pedido parametrizado
A maioria das solicitações precisa de mais parâmetros para ser enviada. Quando precisar enviar essas solicitações, comece com a solicitação em branco e chame a função "com" nela, passando os parâmetros necessários como objeto para ela. Seus parâmetros passados substituem parâmetros possivelmente existentes com o mesmo nome.
Os seguintes parâmetros são suportados:
- método - método HTTP para solicitação (obrigatório, mas definido por solicitação)
- name - nome da solicitação conforme usado para o URL (obrigatório, mas definido pela solicitação)
- bound - Passe verdadeiro se a solicitação estiver vinculada a um registro, falso se não estiver. Tem consequências para a construção automática de URL. Por padrão, falso e definido por solicitação.
- entityName - nome da entidade de destino da solicitação. Definido por solicitação se sempre o mesmo.
- entityId - ID do registro de destino da solicitação
- carga útil - objeto que é enviado como carga útil para a solicitação
- headers - cabeçalhos que devem ser definidos na solicitação
- urlParams - todos os parâmetros que precisam ser incorporados ao URL da solicitação, conforme descrito aqui . Passe um objeto com nomes de parâmetros como chaves e os valores correspondentes.
Solicitação de amostra para AddToQueue:
var request = WebApiClient . Pedidos . AddToQueueRequest
. com ( {
entityId : "56ae8258-4878-e511-80d4-00155d2a68d1" ,
carga útil : {
Destino : {
activityid : "59ae8258-4878-e511-80d4-00155d2a68d1" ,
"@ odata.type" : "Microsoft.Dynamics.CRM .letter "
}
}
} ) ;
WebApiClient . Execute ( solicitação )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Enviar lote
Há suporte para o envio de várias solicitações em lote. As solicitações em lote podem conter solicitações de recuperação e conjuntos de mudanças. Os conjuntos de mudanças podem conter as próprias solicitações, mas não devem conter outros conjuntos de mudanças.
As solicitações diretamente anexadas às solicitações em lote devem ser solicitações GET, não devem ser adicionadas aos conjuntos de mudanças, uma vez que devem conter solicitações, que alteram os dados. As solicitações em lote fornecem funcionalidade transacional, de modo que todas as operações contidas em um conjunto de mudanças serão revertidas, se alguma delas falhar. Você pode ler mais sobre solicitações em lote em geral aqui . Há também uma Referência OData útil que cobre esse tópico (embora v3.0).
Como criar solicitações em lote
Para criar solicitações de uso dentro de lotes, você pode criar um WebApiClient.BatchRequestobjeto usando seu construtor ou, mais facilmente, chamar uma das funções WebApiClient e passar asBatch: truecomo parâmetro.
Todas as funções, como CRUD, Execute e assim por diante, suportam este parâmetro. A única exceção é a função Expandir.
Abaixo está um exemplo de criação de duas tarefas anexadas a uma conta em um conjunto de mudanças, enquanto retorna os registros criados. Posteriormente, a conta à qual estavam vinculados é devolvida:
WebApiClient . Crie ( { entityName : "account" , entity : { name : "Test" } } )
. then ( function ( account ) {
var accountId = account . substring ( account . indexOf ( "(" ) ) . replace ( "(" , "" ) . replace ( ")" ,"" ) ;
var batch = new WebApiClient . Lote ( {
changeSets : [
new WebApiClient . ChangeSet ( {
requests : [
WebApiClient . Create ( {
entityName : "task" ,
entity : {
subject : "Task 1 in batch" ,
"relatedobjectid_account_task@odata.bind" : "/ accounts ( " + accountId + ") "
} ,
cabeçalhos: [ { chave : "Prefere" , valor : "return = representação" } ] ,
asBatch : true
} ) ,
WebApiClient . Criar ( {
entityName : "task" ,
entity : {
subject : "Task 2 in batch" ,
" relatedobjectid_account_task@odata.bind " : "/ accounts (" + accountId + ")"
} ,
cabeçalhos :chave : "Prefere" , valor : "return = representação" } ] ,
asBatch : true
} )
]
} ) ] ,
solicitações : [
WebApiClient . Retrieve ( {
entityName : "account" ,
entityId : accountId ,
asBatch : true
} )
]
} ) ;
retornar WebApiClient . SendBatch ( lote ) ;
} )
. then ( função ( resultado ) {
if ( resultado . isFaulted ) {
console . log ( resultado . erros ) ;
}
// Registra BatchResponse com nome, array batchResponses e
console de array changeSetResponses . log ( resultado ) ;
} )
. catch ( function ( error ) {
// Manipular erro de rede ou similar
} ) ;Nota: o código acima é apenas um exemplo, você também pode criar seu lote e conjuntos de mudanças separadamente e incluir os conjuntos de mudanças em batch.changeSets, solicitações dentro dos conjuntos de mudanças para changeSet.requestse solicitações em lote simples para batch.requests, que são todos arrays.
Respostas em lote
As chamadas para WebApiClient.SendBatchretornarão um BatchResponse. Uma resposta em lote consiste em uma matriz batchResponses, que contém todas as respostas para solicitações GET, que foram diretamente anexadas ao lote, e uma matriz changeSetResponses, que contém uma resposta de conjunto de alterações para cada conjunto de alterações enviado. Cada resposta do conjunto de mudanças contém sua própria responsesmatriz, com respostas para cada solicitação dentro do conjunto de mudanças.
No nível superior, cada resposta em lote também possui um name, uma isFaultedpropriedade que avalia como verdadeira, se alguma das solicitações falhar e uma errorsmatriz que contém todas as respostas para as solicitações com falha.
Todas as respostas de nível mais baixo contêm um headersobjeto, para que você possa acessar os cabeçalhos mais facilmente (por exemplo, headers ["OData-EntityId"]), um payloadobjeto, a status(como "200") e a contentId, se as solicitações dentro do conjunto de mudanças tivessem um conjunto.
Esquema de uma resposta em lote:
- batchResponses (array)
- Resposta (WebApiClient.Response)
- contentId (string)
- cabeçalhos (matriz de string * string)
- carga útil (objeto)
- status (string)
- ...
- Resposta (WebApiClient.Response)
- changeSetResponses (array)
- changeSetResponse (objeto)
- nome (string)
- respostas (matriz)
- Resposta (WebApiClient.Response)
- contentId (string)
- cabeçalhos (matriz de string * string)
- carga útil (objeto)
- status (string)
- ...
- Resposta (WebApiClient.Response)
- changeSetResponse (objeto)
- erros (matriz de WebApiClient.Response)
- isFaulted (bool)
- nome (string)
Falha de solicitação
Se uma solicitação dentro das solicitações em lote ou um conjunto de mudanças falhar, a propriedade de resposta em lote isFaultedterá o valor true. Você pode obter uma coleção de todos os erros usando a propriedade response errors.
Isso está tudo dentro do thenmanipulador, lembre-se de que você ainda deve configurar um catchmanipulador, pois ele será necessário se uma solicitação falhar devido a erros de rede ou similares.
Configuração
Ao definir várias definições de configuração para o WebApiClient, você pode usar a Configurefunção, que obtém um objeto transmitido com chaves e valores, que são projetados no WebApiClient:
WebApiClient . Configure ( {
ApiVersion : "8.2" ,
ReturnAllPages : true ,
PrettifyErrors : false
} ) ;Erros
Se ocorrerem erros durante o processamento de solicitações, o cliente WebAPI por padrão emite um erro com o texto que segue este formato: xhr.statusText: xhr.response.message, ou seja, "Erro interno do servidor: O parâmetro de função 'EntityMoniker' não pode ser encontrado. Nome do parâmetro: parameterName ".
Para retornar a resposta JSON stringificada inteira, incluindo uma propriedade xhrStatusText personalizada, defina
WebApiClient . PrettifyErrors = false ;Definir nomes
Os nomes de conjuntos são gerados automaticamente de acordo com as regras WebApi e com base no parâmetro entityName em sua solicitação. No entanto, existem alguns nomes de conjuntos, que não são gerados de acordo com as regras de nomenclatura, por exemplo, ContactLeads torna-se contactleadscollection. Para lidar com esses casos extremos, cada solicitação permite passar um overriddenSetName em vez do nome da entidade, para que você possa passar diretamente os nomes de conjuntos que quebram as regras de nomenclatura. Isso deve acontecer muito raramente. Exemplo de passagem overriddenSetName:
var request = {
overriddenSetName : "contactleadscollection" ,
entidade : { name : "Contoso" }
} ;
WebApiClient . Criar ( solicitar )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Solicitações ainda não implementadas
Se você precisar usar solicitações, que ainda não foram implementadas (como ações personalizadas), pode criar um executor para a solicitação ausente e anexá-lo ao objeto WebApiClient.Requests (se desejar reutilizá-lo). Certifique-se de criar sua solicitação ausente chamando Object.create no objeto de solicitação base. Isso pode ser parecido com isto:
WebApiClient . Pedidos . AddToQueueRequest = WebApiClient . Pedidos . Solicite . protótipo . com ( {
método : "POST" ,
nome : "AddToQueue" ,
bound : true ,
entityName : "queue"
} ) ;Para maiores esclarecimentos sobre essas solicitações, clique aqui . Todas as solicitações devem ser implementadas basicamente agora, em caso de erros nas implementações, você pode substituir qualquer propriedade usando a withfunção conforme descrito aqui .
Alternativamente, você pode usar a WebApiClient.SendRequestfunção. Em combinação com WebApiClient.GetApiUrle WebApiClient.GetSetNamevocê pode facilmente construir seu url de solicitação, definir seu método HTTP e anexar carga útil ou cabeçalhos adicionais.
Um exemplo de implementação personalizada da solicitação WinOpportunity:
var url = WebApiClient . GetApiUrl ( ) + "WinOpportunity" ;
var opportunityId = "00000000-0000-0000-0000-000000000001" ;
var payload = {
"Status" : 3 ,
"OpportunityClose" : {
"subject" : "Won Opportunity" ,
"opportunityid@odata.bind" : "/" + WebApiClient . GetSetName ( "opportunity" ) + "(" + ")"
}
} ;
WebApiClient . SendRequest ( "POST" , url , carga útil )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Promessas
Este cliente usa o bluebird internamente para lidar com promessas de forma compatível com vários navegadores. Portanto, as promessas retornadas por todas as solicitações assíncronas também são promessas do bluebird. O Bluebird em si não é mais exportado globalmente a partir da v3.0.0, mas pode ser acessado usando WebApiClient.Promise. Essa decisão foi tomada para não causar problemas com outros scripts.
Usando promessas, você também pode fazer algo assim:
solicitações de var = [ ] ;
para ( var i = 0 ; i < 5 ; i ++ ) {
solicitação de var = { entityName : "account" , entity : { name : "Adventure Works Nr." + i } } ; pedidos . push ( WebApiClient . Criar ( solicitação ) ) ; }
WebApiClient . Promessa . todos ( solicitações )
. então ( função ( resposta ) {
// Resposta do processo
} )
. catch ( function ( error ) {
// Manipular erro
} ) ;Acesso Externo
O acesso externo ao CRM, isto é, acessar o CRM sem estar em um formulário de CRM ou ter um ClientGlobalContext.aspx, é suportado. Como o OAuth é necessário para autenticação, apenas CRM online e CRM On-Premises com IFD e Azure AD têm suporte.
Você terá que registrar o WebApiClient como Aplicativo no Azure AD, que é descrito no MSDN .
Aplicação de página única
Há suporte para usar o cliente em aplicativos externos de página única.
Há um exemplo de trabalho mínimo na pasta de amostra .
Cabeçalhos
Há um conjunto definido de cabeçalhos padrão, que são enviados em cada solicitação, bem como cabeçalhos por solicitação. Os cabeçalhos por solicitação substituem os cabeçalhos padrão possivelmente existentes com o mesmo valor de chave.
Formato de cabeçalho
Os cabeçalhos são representados como objetos contendo uma chave e uma propriedade de valor:
var header = { key : "headerKey" , value : "headerValue" } ;Cabeçalhos padrão
Por padrão, há um conjunto definido de cabeçalhos padrão, que serão enviados com cada solicitação. Os cabeçalhos padrão podem ser recuperados usando a função WebApiClient.GetDefaultHeaders. No entanto, você pode adicionar seus próprios cabeçalhos padrão usando a função WebApiClient.AppendToDefaultHeaders, que aceita tantos cabeçalhos e argumentos dinâmicos quanto desejar.
Exemplo:
var header = { key : "newHeader" , value : "newValue" } ;
WebApiClient . AppendToDefaultHeaders ( cabeçalho ) ;Solicitar cabeçalhos
Você também pode anexar cabeçalhos por solicitação, todos os parâmetros de solicitação têm uma propriedade headers, que pode ser usada para passar cabeçalhos por solicitação.
Isso pode ser parecido com isto:
// Parâmetros para criar solicitação
var request = {
entityName : "account" ,
entity : { name : "Adventure Works" } ,
headers : [ { key : "headerKey" , value : "headerValue" } ]
} ;Tamanho da página
Se você deseja definir um tamanho máximo de página para sua solicitação (são suportados até 5.000 registros por página), você pode passar o seguinte cabeçalho:
cabeçalhos: [ { chave : "Prefere" , valor : "odata.maxpagesize = 5000" } ]Versão API
A versão padrão da API é 8.0. No entanto, você pode alterá-lo para 8.1, se necessário, usando
WebApiClient . ApiVersion = "8,1" ;Observações
App CRM
Para usar WebApiClient com o aplicativo CRM, você terá que usar a versão normal (= não uglificada). Ao usar o JS feio no aplicativo CRM, você pode receber erros de caracteres inválidos. Isso não é válido apenas para o WebApiClient, mas também para algum outro código feio.
Perguntas frequentes
Cargas úteis
Ao enviar dados para registros de entidades, muitas vezes surgem dúvidas sobre como passar valores específicos. Alguns atributos podem ser definidos diretamente, alguns precisam de um formato especial para que a API da Web os reconheça.
Atributos simples (basta usar valores nativos na carga útil):
- Linha Única de Texto
- Múltiplas Linhas de Texto
- Número
- Decimal
- Flutuador
- boleano
- OptionSet (basta usar o valor do conjunto de opções)
- Data hora
Atributos complexos:
- Pesquisas: ao definir pesquisas, você usa o nome lógico do atributo, seguido por "@ odata.bind". Como valor, você precisa passar um formato especial do id, que é "/ entityListName (id)". Portanto, para definir a conta pai de uma conta, a carga útil seria assim:
var update = {
"parentaccountid@odata.bind" : "/ accounts (4acc8857-fbb8-42d1-a5c5-24d83c9d1380)"
} ;Para obter o nome da lista de entidades, você pode usar WebApiClient.GetSetName.
Caso especial: um caso especial são as pesquisas, que têm como alvo várias entidades, como pesquisas de clientes ou IDs de objeto. Elas aplicam as mesmas regras das pesquisas simples, mas, além disso, o nome lógico da entidade da entidade de destino relacionada é anexado ao nome do campo, precedido por um sublinhado. Por exemplo, para definir o objeto relacionado de um compromisso para nossa conta pai anterior, teríamos que usar a seguinte carga útil:
var update = {
" relatedobjectid_account@odata.bind
" : "/ accounts (4acc8857-fbb8-42d1-a5c5-24d83c9d1380)" } ;Nomes Lógicos
Às vezes, as solicitações falham porque a API da Web não encontra os atributos incluídos em sua carga útil na definição da entidade. Na maioria das vezes, isso ocorre porque você errou o nome. Para encontrar os nomes próprios, você pode acessar Configurações> Personalizações> Recursos do desenvolvedor e clicar no link "Baixar metadados OData". Você receberá um arquivo XML, que contém todas as entidades expostas na API da Web, com seus nomes de conjunto e todos os seus atributos.
Fonte: GitHub
Nenhum comentário:
Postar um comentário