Apostila DEV 365FO

Introdução ao desenvolvimento e personalização.
1
Índice
Conceitual............................................................................................................................................... 3
Diferenciando nuvem de arquitetura local................................................................................4
Ferramentas de desenvolvimento no Visual Studio..............................................................5
Elementos, modelos e pacotes........................................................................................................9
Formulários do tipo Dialogs.........................................................................................................16
Gerenciamento de Dados.(Entidade de dados, EDT, Enum, Tables)...........................25
Interface do Usuário (Menus, MenuItem, Forms, Label)..................................................46
Segurança..............................................................................................................................................69
2
Conceitual
O Microsoft Dynamics AX é uma solução de Enterprise Resource Planning (ERP) ou
Planejamento de Recursos Empresariais para organizações de porte médio e grande
que ajuda as pessoas a trabalharem efetivamente, gerenciar alterações e competir
no mundo inteiro. O Microsoft Dynamics AX funciona de maneira semelhante e
integrada ao software da Microsoft e é uma solução que automatiza e simplifica
processos financeiros, de business intelligence e de cadeia de suprimentos de uma
forma que ajude você em seus negócios.
O Dynamics AX agora é Dynamics 365 for Finance and Operations.
Planejamento de Recursos Empresariais ou planeamento de recurso corporativo é

um sistema de informação que integra todos os dados e processos de uma
organização em um único sistema. A integração pode ser vista sob a perspectiva
funcional e sob a perspectiva sistêmica.
3
Diferenciando nuvem de arquitetura local
Um entendimento da arquitetura subjacente do Dynamics 365 for Finance and

Operations ajudará você a apreciar a rica funcionalidade da interface do
usuário. Alguns componentes de arquitetura podem variar entre implantações na
nuvem e locais.
As implantações em nuvem oferecem um serviço totalmente gerenciado pela

Microsoft, enquanto as implantações locais são implantadas localmente no data
center de um cliente. Metodologias diferem entre implantações hospedadas em
nuvem e locais. A implementação que uma empresa usa será baseada em quem é o
trustee de dados desejado e quem gerenciará o ciclo de vida do aplicativo.
Implantação na nuvem
Uma implantação em nuvem oferece vários benefícios, incluindo tempo de

implementação reduzido, custos mais baixos de hardware e infraestrutura e
desenvolvimento menos invasivo. Um dos principais benefícios de escolher uma
implantação na nuvem é que o serviço de ERP é totalmente gerenciado pela
Microsoft. Portanto, as implantações na nuvem são uma oferta de software como
serviço (SaaS). Isso permite que as organizações aumentem ou diminuam
facilmente, dependendo das necessidades da empresa. Implantações em nuvem
também permitem que os clientes permaneçam atualizados de maneira consistente,
previsível e transparente. Essa cadência, que permite atualizações contínuas do
aplicativo, visa reduzir os custos de atualização, fornecer acesso a todos os recursos
mais recentes, melhorar o desempenho e oferecer uma melhor experiência de
suporte.
Implantação no local
Ao decidir qual tipo de implantação sua organização deve usar, você deve considerar
a abordagem geral da implementação e o gerenciamento da
infraestrutura. Considerações adicionais incluem as preferências organizacionais
para atender às necessidades normativas e de conformidade dos negócios. Nesses
tipos de situações, uma implantação local pode ser escolhida.
As organizações que optam por implantar Finanças e Operações no local também

precisam assumir a propriedade de várias tarefas que, de outra forma, teriam sido
executadas pela Microsoft. Essas tarefas incluem a configuração de soluções de alta
disponibilidade, soluções de recuperação de desastre e ambientes de
sandbox. Tenha em mente que existem diferenças de funcionalidade entre
implantações locais e implantações na nuvem.
4
Ferramentas de desenvolvimento no Visual Studio
Quais são as ferramentas de desenvolvimento?
Uma alteração notável do Microsoft Dynamics AX 2012 é que o Microsoft Dynamics

365 for Finance and Operations não inclui um aplicativo rich-client (ax32.exe). De
uma perspectiva de desenvolvimento, isso significa que o ambiente de
desenvolvimento do Microsoft Dynamics AX 2012, MorphX, não é mais usado. Em
seu lugar, o desenvolvimento de aplicativos é realizado exclusivamente no Visual
Studio. As ferramentas de desenvolvimento suportam todas as tarefas de
desenvolvimento, incluindo depuração e cenários de testes locais. Um objetivo
principal da experiência de desenvolvimento é manter os conceitos familiares do
Microsoft Dynamics AX 2012 e adaptá-los perfeitamente à estrutura e aos
paradigmas do Visual Studio.
O Visual Studio 2015 é o exclusivo ambiente de desenvolvimento integrado (IDE)

para desenvolvimento. Todo o seu trabalho de desenvolvimento de aplicativos será
executado com ele. Esta seção é uma visão geral dos principais recursos adicionados
ao Visual Studio quando as ferramentas de desenvolvimento são instaladas.
Explorador de Aplicações
No Visual Studio, o armazenamento de modelo é representado pelo Explorador de

Aplicativos. No menu Exibir, clique em Explorador de aplicativos para abri-lo. O
Explorador de Aplicativos corresponde à Árvore de Objetos de Aplicativos (AOT)
com a qual você pode estar familiarizado no Microsoft Dynamics AX 2012. Use o
Explorador de Aplicativos para procurar e interagir com os elementos no
armazenamento de modelos que definem os aplicativos.
A ilustração a seguir mostra o Explorador de Aplicativos.
5
6
O modelo de projeto
Até mesmo um aplicativo simples pode ter um grande número de elementos em seu
modelo. O modelo do Projeto de Operações foi adicionado ao Visual Studio para
ajudá-lo a organizar e gerenciar os elementos com os quais você está trabalhando
para um modelo. Você usará o projeto para projetar, construir e testar elementos de
modelo. É comum ter vários projetos em uma única solução do Visual Studio. A
ilustração a seguir mostra três projetos em uma solução do Visual Studio.
Designers de elementos
As ferramentas do Visual Studio contêm designers para cada tipo de elemento no

aplicativo. Você usará esses designers quando criar ou modificar elementos. A
ilustração a seguir mostra o designer de elemento para um elemento de formulário.
7
Editor de código
O código do X ++ é escrito no editor de código do Visual Studio. Os recursos padrão

que um desenvolvedor espera do editor de código são suportados. Por exemplo,
seções de código são redimensionáveis. O IntelliSense fornece orientação à medida
que você escreve ou modifica o código.
Menu do Dynamics 365
As ferramentas adicionam o menu do Dynamics 365 ao Visual Studio. Várias

ferramentas que você usará durante o processo de desenvolvimento são
encontradas aqui. Por exemplo, as ferramentas para gerenciar modelos são
acessadas no menu.
8
Elementos, modelos e pacotes
Elementos, modelos e pacotes representam a hierarquia estrutural no Visual Studio

for Finance and Operations. Elementos ou existem fora da caixa no explorador de
aplicativos no Visual Studio, ou eles podem ser criados. Elementos são metadados e
arquivos de origem, como enumerações de base e tabelas. Um projeto de Unified
Operations é usado para organizar e gerenciar elementos dentro de um
modelo. Modelos contêm zero ou mais elementos. Por exemplo, o modelo de
gerenciamento de depósito é um grupo de elementos que compõem a solução de
gerenciamento de depósito.
Todos os modelos pertencem a pacotes, que podem ser empacotados juntos para
criar um pacote implementável e, em seguida, implementados usando o LCS. Um
pacote implementável contém um ou vários pacotes que são usados para ambientes
de tempo de execução. Os assistentes no Visual Studio são usados para criar modelos
e projetos, e a janela do designer é usada para personalizar elementos dentro de
projetos e modelos.
Pacotes implantáveis são implantados em ambientes de finanças e operações. Esses
pacotes contêm modelos que, em muitos casos, representam os módulos visíveis na
interface do usuário Finanças e Operações, como Contas a pagar. Os modelos contêm
os elementos que representam todos os campos, menus e formulários encontrados
na interface do usuário. Esses elementos são criados e gerenciados no Visual Studio.
Portanto, o controle de origem é necessário para o desenvolvimento de finanças e
operações.
9
Conectando o Visual Studio ao Visual Studio Team Services
Cada desenvolvedor tem sua própria VM de desenvolvimento, hospedada no Azure

ou localmente. Isso é por projeto e faz parte do processo de ciclo de vida do
aplicativo. Cada desenvolvedor receberia as últimas código do controle de origem e,
em seguida, verifique suas alterações de acordo com as metodologias de
desenvolvimento. Como parte desse check-in, eles podem vincular os check-ins. Isso
permite uma construção para ser criada, e ganhamos um nível de rastreabilidade
desde que cada item de trabalho (usuário história, recurso, bug e assim por diante.)
está vinculado aos check-ins nessa compilação. Isso também permite teste projetos
a serem executados automaticamente quando a compilação é gerada.
Depois que a máquina virtual for iniciada, verifique se ela tem acesso à Internet e se
você utilizou a ferramenta de aprovisionamento de usuários admin para associar
sua conta do Dynamics 365 FO à conta de administrador de Operações. Antes de
começar, especialmente ao trabalhar em equipe, devemos renomear a VM para fazer
são únicos em toda a nossa equipe, veja a seção há mais ... para detalhes sobre isso.
Para conectar o Visual Studio ao VSTS, siga estas etapas:
1. Crie uma pasta para seus projetos e, abaixo de uma subpasta com suas
iniciais, ou outros que tornam a pasta única, dentro de sua equipe; no meu
exemplo, utilizaremos C: ProjectsTFS.
2. Inicie o Visual Studio.
3. Você será presenteado com a página de licenciamento. Use a página para
fazer login na conta usada para criar o projeto dentro do VSTS. Qual poderia
ser o seu Conta da Microsoft ou conta de trabalho (D365FO).
4. Na barra de ferramentas superior, selecione Equipe e, em seguida, Gerenciar
conexões.
5. O Team Explorer será aberto, no layout padrão, no lado direito. Em neste
painel, selecione Gerenciar Conexões | Conecte-se ao Team Project:
6. Isso abrirá a caixa de diálogo conectar-se ao Team Foundation Server, no

campo Selecione um Servidor Na lista suspensa Team Foundation Server e
selecione o site do VSTS.
10
7. Selecione seu projeto na parte inferior da caixa de diálogo, conforme
mostrado a seguir na captura de tela:
8. Depois de pressionar Connect, o Visual Studio está conectado ao seu projeto.

9. Temos um último passo antes de continuarmos; temos que configurar nosso
espaço de trabalho assim Visual Studio sabe quais pastas estão sob controle
de origem e como eles mapeie para VSTS. No Team Explorer, clique em
Configurar espaço de trabalho sob o Seção do projeto. Isso mostrará a seção
Configure Workspace no topo da Team Explorer.
10. Não pressione Map & Get.
11. Pressione Avançado ....
12. A caixa de diálogo Editar Área de Trabalho será semelhante à seguinte
captura de tela:
Para o desenvolvimento no D365FO, precisaremos mapear uma pasta de

projetos e pasta de pacotes locais de operações (o código-fonte do aplicativo ou
metadados muitas vezes é referido) para duas pastas diferentes no VSTS. A pasta
Projects é o que criamos anteriormente, que foi C: ProjectsSB no meu caso. A
pasta de pacotes locais de operações é C: AOSServicePackagesLocalDirectory.
11
13. Pressione OK.
14. Você será informado que o espaço de trabalho foi modificado e, se desejar
obtenha o código mais recente. Qualquer opção não tem efeito se formos o
primeiro desenvolvedor, mas é um bom hábito sempre pressionar Sim.
O controle de origem nas D365FO já percorreu um longo caminho neste lançamento,

principalmente porque ferramenta de desenvolvimento é agora Visual Studio e que
os arquivos de origem são agora arquivos reais no sistema de arquivo. Operações
não precisam mais de código especial para integrar com um Team Foundation
Server. A razão pela qual temos duas pastas é que nossos projetos não contêm os
arquivos que criamos ao escrever código. Quando criamos um arquivo, como uma
nova classe, ele é criado dentro da local pasta de pacotes e referenciada no projeto.
Isso também significa que não podemos simplesmente fechar um projeto e enviá-lo
por e-mail para um colega de trabalho. Isso é feito conectando-se ao mesmo projeto
VSTS ou usando um recurso de exportação de projeto.
Criando um novo projeto, pacote e modelo

Elementos no Dynamics 365 para Finanças e Operações representam cada elemento
individual de AOT, como classe, tabela, formulário e assim por diante.
Elementos no Dynamics 365 for Finance and Operations são armazenadas no disco
como arquivos XML, esses arquivos contêm os metadados e o código-fonte para o
elemento. Os arquivos XML são a unidade de controle de origem.
Projetos funciona da mesma forma que AX2012, mas no D365 um elemento pode
ser personalizado apenas uma vez eles são adicionados a um projeto específico do
Visual Studio. O projeto só pode pertencer a um modelo.
Um modelo do Dynamics 365 for Finance and Operations é um grupo de elementos.
Padrão elementos fazem parte de um modelo padrão; você pode adicioná-los ao seu
modelo e fazer customização. Um modelo é um conceito de tempo de design. Um
exemplo de modelos: armazém modelo de gestão, um modelo de contabilidade de
projeto e muito mais. Modelos podem ter um ou mais projetos. Modelos só podem
pertencer a um pacote.
Um pacote do Dynamics 365 for Finance and Operations é uma implantação e uma
compilação unidade de um ou mais modelos. Inclui metadados de modelos, binários,
cubos e outros recursos associados. Um ou mais pacotes D365 podem ser
empacotados em uma implantação pacote, que é o veículo usado para implantação
em ambientes de produção e UAT.
Os pacotes são empacotados em um arquivo de pacote implementável para
implantação no Sandbox ou ambientes de produção. Um pacote pode ter um ou mais
modelos. Pacotes podem ter referências a outros pacotes, assim como os assemblies
.NET, podem referenciar-se uns aos outros.
12
Para criar um novo projeto, siga estas etapas:
1. Abra o Visual Studio como administrador.

2. No menu Ficheiro, aponte para Novo e clique em Project.
3. Na lista de tipos de modelo, expanda o nó Instalado.
4. Expanda o nó Modelos.
5. Selecione a categoria do Microsoft Dynamics 365 for Operations.
6. Selecione o modelo do projeto D365.
7. Digite o nome e a localização do novo projeto.
8. Selecione Criar diretório para solução se você quiser criar uma nova solução para
este projeto, desmarque se quiser adicionar sua solução atual.
Para criar um novo modelo, siga estas etapas:

1. Abra o Visual Studio como administrador.
2. No menu Dynamics 365, aponte para Gerenciamento de modelos e selecione Criar
modelo.
3. Dê um modelo, nome do editor e outros valores:
13
4. Agora você pode criar um novo pacote ou selecionar qualquer pacote existente.
Poderíamos crie um novo pacote e selecione o pacote necessário como pacotes
referenciados:
5. Verifique novamente o resumo com detalhes. Selecione Criar novo projeto se

você quiser crie um novo projeto neste modelo, uma vez criado. Você pode marcar
este modelo para todos seus novos projetos, selecionando opções:
14
Como você viu, houve mais uma etapa ao criar um modelo, selecionar pacotes
referenciados. Quando você cria seu próprio pacote, você pode selecionar um pacote
existente para adicioná-lo como referências em seu novo pacote. Você pode precisar
adicionar alguma referência de pacote padrão se você deseja adicioná-los à sua
personalização.
15
Formulários do tipo Dialogs
Neste tópico, vamos cobrir as seguintes personalizações:
 Criando diálogos usando o framework RunBase

 Manipulando o evento de diálogo
Introdução
Formulários no Dynamics 365 for Finance and Operations representam a interface

do usuário e são usado principalmente para inserir ou modificar dados. Eles também
são usados para executar relatórios, executar usuário comandos, validar dados e
assim por diante.
Normalmente, os formulários são criados usando o AOT produzindo um objeto de

formulário e adicionando um formulário controles, como guias, guias, grades,
grupos, campos de dados e imagens. O comportamento do formulário é controlado
por suas propriedades ou pelo código em seus métodos membros. O
comportamento e layout de controles de formulário também são controlados por
suas propriedades e o código em seus membros métodos. Embora seja muito raro,
formulários também podem ser criados dinamicamente a partir do código.
Neste tópico, abordaremos vários aspectos do uso do Dynamics 365 for Finance e
Formulários de operações. Começamos criando diálogos do Dynamics 365 for
Finance and Operations, que são formas dinâmicas e depois explicam como lidar
com seus eventos. Também será mostrado como criar formulários dinâmicos, como
adicionar controles dinâmicos aos formulários existentes e como fazer formulários
modais.
Criando diálogos usando o RunBase framework:
Diálogos são uma maneira de apresentar aos usuários um formulário de entrada

simples. Eles são comumente usados para pequenas tarefas do usuário, como
preencher valores de relatório, executar trabalhos em lote e apresentar apenas
campos mais importantes para o usuário ao criar um registro. Diálogos são
normalmente criados do código X ++ sem armazenar o layout real no AOT.
A classe de aplicativo chamada Dialog é usada para construir diálogos. Outras

classes de aplicativos, como DialogField, DialogGroup ou DialogTabPage, são
usados para criar controles de diálogo. Esta é a maneira mais fácil de criar diálogos
é usar o framework RunBase. Isso é porque o framework fornece um conjunto de
métodos pré-definidos, que fazem a criação e manuseio de o diálogo bem
estruturado, em oposição a ter todo o código em um único lugar.
Neste exemplo, demonstraremos como construir um diálogo a partir do código

usando a classe RunBase de estrutura. O diálogo conterá os campos da tabela de
16
clientes mostrados em diferentes grupos e guias para criar um novo registro. Haverá
duas páginas (Tab Page), Geral e Detalhes. A primeira página terá os controles de
entrada de conta de cliente e nome a segunda página será dividida em dois grupos,
Configuração e Pagamento, com campos relevantes dentro de cada grupo. O
registro real não será criado, pois está além do escopo deste exemplo. No entanto,
para fins de demonstração, as informações especificadas pelo usuário serão exibidas
no Janela de um infolog.
Siga os seguintes passos para completar esta atividade:
1. Adicione um novo projeto Create Dialog

2. Adicione uma nova classe Runnable e renomeie-a para MyDialog . Agora, adicione
o seguinte trecho de código:
Declare todos os seus objetos na classe, como mostrado a seguir:
class MyDialog extends RunBase

{
DialogField fieldAccount;
DialogField fieldName;
DialogField fieldGroup;
DialogField fieldCurrency;
DialogField fieldPaymTermId;
DialogField fieldPaymMode;
CustAccount custAccount;
CustName custName;
CustGroupId custGroupId;
CurrencyCode currencyCode;
CustPaymTermId paymTermId;
CustPaymMode paymMode;
public container pack()

{
return connull();
}
public boolean unpack(container packedClass)

{
return true;
}
 Crie um método de diálogo para capturar entradas do usuário de tempo de

execução para detalhes do cliente:
Object dialog()
{
Dialog dialog;
DialogGroup groupCustomer;
DialogGroup groupPayment;
dialog = super();
dialog.caption("Informações do Cliente");
fieldAccount = dialog.addField(extendedTypeStr(CustAccount),"Conta do Cliente");

fieldName = dialog.addField(extendedTypeStr(CustName),"Nome do Cliente");
17
dialog.addTabPage("Detalhes");
groupCustomer = dialog.addGroup("Configuração");
fieldGroup = dialog.addField(extendedTypeStr(CustGroupId),"Grupo do Cliente");
fieldCurrency =dialog.addField(extendedTypeStr(CurrencyCode),"Moeda
Corrente");
groupPayment = dialog.addGroup("Pagamento");
fieldPaymTermId= dialog.addField(extendedTypeStr(CustPaymTermId),"Condição de
Pagamento");
fieldPaymMode = dialog.addField(extendedTypeStr(CustPaymMode),"Método de
Pagamento");
return dialog;
}
Agora, quando os usuários selecionam seus valores desejados, precisamos ler todos
eles para mostrar no infolog. Use getFromDialog para ler o valor de um campo de
diálogo:
public boolean getFromDialog()

{
custAccount = fieldAccount.value();
custName = fieldName.value();
custGroupId = fieldGroup.value();
currencyCode = fieldCurrency.value();
paymTermId = fieldPaymTermId.value();
paymMode = fieldPaymMode.value();
return super();
}
Use o método run para fazer instruções Infolog, como no código a seguir:
public void run()

{
info("Você inseriu os seguintes dados de cliente:");
info(strFmt("Conta: %1", custAccount));
info(strFmt("Nome: %1", custName));
info(strFmt("Grupo: %1", custGroupId));
info(strFmt("Moeda Corrente: %1",currencyCode));
info(strFmt("Condição de Pagamento: %1", paymTermId));
info(strFmt("Método de Pagamento: %1", paymMode));
}
public static void main(Args _args)

{
MyDialog myDialog = new MyDialog();
if (myDialog.prompt())
{
myDialog.run();
}
}
18
3. Para testar a caixa de diálogo, clique com o botão direito do mouse nessa classe e
defina como projeto de inicialização.
4. Construa seu projeto. Agora, execute o projeto. O seguinte formulário aparecerá
no navegador de internet:
4. Clique na ficha de registro Detalhes; você verá uma tela semelhante à seguinte
captura de tela:
5. Digite as informações em todos os campos e clique em OK. Os resultados serão

exibidos na guia Infolog na parte superior da janela do navegador.
19
Entendendo nosso desenvolvimento:
Primeiro criamos uma nova classe chamada MyDialog. Ao estendê-lo de RunBase,

utilizamos uma abordagem padrão para desenvolver funções de manipulação de
dados no Dynamics 365 for Operations. O RunBase Framework definirá uma
estrutura comum e adicionará automaticamente controles, como os botões OK e
Cancelar, na caixa de diálogo. Em seguida, declaramos as variáveis dos membros da
classe, que serão usadas posteriormente. A variável do tipo DialogField são campos
entrada do usuário. O restante das variáveis é usado para armazenar os valores que
retornaram da entrada do usuário.
Os métodos pack() e unpack() são normalmente usados para converter um objeto

em um contêiner e converter o contêiner de volta em um objeto, respectivamente.
Um contêiner é um formato comum usado para armazenar objetos no cache do
usuário (SysLastValue) ou para transferir o objeto entre camadas de servidor e
cliente. O RunBase Framework precisa que esses dois métodos sejam
implementados em todas as suas subclasses. Neste exemplo, não estamos usando os
recursos do pack() ou unpack(), mas porque esses métodos são obrigatórios,
retornamos um container vazio do pack() e retornamos true do unpack().
O layout da caixa de diálogo real é construído no método dialog(). Aqui nós

definimos as variáveis locais para as páginas e grupos da própria guia de diálogo.
Essas variáveis, ao contrário para os campos de diálogo, não armazenem nenhum
valor para processamento adicional. O método super() cria o objeto de diálogo
inicial para nós e adiciona automaticamente os controles relevantes, incluindo os
botões OK e Cancelar.
Controles de diálogo adicionais são adicionados ao diálogo usando os métodos

addField(), addGroup() e addTabPage(). Existem mais métodos, como o
addText(), addImage() e addMenuItemButton() aos quais são usados para
adicionar diferentes tipos de controles. Todos controles devem ser adicionados ao
objeto de diálogo diretamente. Adicionando um controle de entrada a grupos ou
guias é feito chamando addField() logo após addGroup() ou addTabPage(). No
exemplo anterior, incluímos guias, grupos e campos em uma sequência lógica de
cima para baixo. Note que é suficiente apenas adicionar uma segunda página de
tabulação; a primeira ficha de registro, chamada Geral a qual é adicionada
automaticamente pelo framework.
Valores dos controles de diálogo são atribuídos às variáveis chamando o método

value() este membro de DialogField. Se um diálogo é usado dentro do RunBase
framework, como é usado neste exemplo, o melhor lugar para atribuir valores de
controle de diálogo a variáveis é o método getFromDialog(). O RunBase
framework invoca este método logo após o usuário clicar em OK.
O processamento principal é feito no método run(). Para fins de demonstração, esta

classe mostra apenas a entrada do usuário na guia Infolog na parte superior da
janela do navegador.
Para tornar esta classe executável, o método main() estático deve ser criado. Aqui
nós criamos um novo objeto do tipo CustCreate invoca o diálogo de usuário
20
chamando o método prompt() Depois que o usuário terminar de inserir os detalhes
do cliente, clicando em OK, o método run() é invocado para processar os dados.
Manipulando eventos de diálogo
Às vezes, na interface do usuário, é necessário alterar o status de um campo,

dependendo sobre o status de outro campo. Por exemplo, se o usuário marcar a caixa
de seleção Filtrar, outro campo, Filtrar, aparece ou fica ativado. Nos formulários
AOT, isso pode ser feito usando o evento modified() de controle de entrada. No
entanto, se esse recurso for necessário em diálogos de tempo de execução, lidar com
eventos não é tão simples.
Muitas vezes, os diálogos existentes precisam ser modificados para suportar

eventos. A maneira mais fácil é converter um diálogo em um formulário AOT. No
entanto, quando os o diálogo é bastante complexo, uma solução mais econômica
provavelmente seria implementar manipulação de eventos de diálogo em vez de
converter em um formulário AOT. A manipulação de eventos em diálogos é não
flexível, como no caso de formulários AOT que na maioria dos casos faz o trabalho.
Nesta atividade, vamos criar uma caixa de diálogo semelhante ao anterior, mas em
vez de entrar o número do cliente, poderemos selecionar o número de uma lista
semelhando a um combobox. Quando o cliente estiver selecionado, o restante dos
campos será preenchido automaticamente pelo sistema a partir do cliente registro.
1. Adicione uma nova classe Runnable e renomeie-a para MyDialogSelect.
Agora, adicione o seguinte trecho de código:

class MyDialogSelect extends RunBase
{
DialogField fieldAccount;
DialogField fieldName;
DialogField fieldGroup;
DialogField fieldCurrency;
DialogField fieldPaymTermId;
DialogField fieldPaymMode;
public container pack()

{
return connull();
}
public boolean unpack(container packedClass)

{
return true;
}
21
2. Crie um método de diálogo para capturar entradas do usuário de tempo de
execução para detalhes do cliente:
Object dialog()
{
Dialog dialog;
DialogGroup groupCustomer;
DialogGroup groupPayment;
dialog = super();
dialog.caption("Informações do Cliente")
dialog.allowUpdateOnSelectCtrl(true);
fieldAccount = dialog.addField(extendedTypeStr(CustAccount),"Conta do Cliente");

fieldName = dialog.addField(extendedTypeStr(CustName),"Nome do Cliente");
fieldName.enabled(false);
dialog.addTabPage("Detalhes");
groupCustomer = dialog.addGroup("Configuração");
fieldGroup = dialog.addField(extendedTypeStr(CustGroupId),"Grupo do Cliente");
fieldCurrency =dialog.addField(extendedTypeStr(CurrencyCode),"Moeda
Corrente");
fieldGroup.enabled(false);
fieldCurrency.enabled(false);
groupPayment = dialog.addGroup("Pagamento");
fieldPaymeTermId= dialog.addField(extendedTypeStr(CustPaymTermId),"Condição de
Pagamento");
fieldPaymMode = dialog.addField(extendedTypeStr(CustPaymMode),"Método de
Pagamento");
fieldPaymeTermId.enabled(false);
fieldPaymMode.enabled(false);
return dialog;
}
public void dialogSelectCtrl()

{
CustTable custTable;
custTable = CustTable::find(fieldAccount.value());
fieldName.value(custTable.name());
fieldGroup.value(custTable.CustGroup);
fieldCurrency.value(custTable.Currency);
fieldPaymTermId.value(custTable.PaymTermId);
fieldPamMode.value(custTable.PaymMode);
}
public stati void main(Args _args)

{
MyDialogSelect myDialogSelect = new MyDialogSelect();
if (myDialogSelect.prompt())
{
myDialogSelect.run();
}
}
22
3. Defina esta classe como Set as Startup Object (Objeto de início)
4. Salve todas as suas alterações e construa seu projeto. Agora execute o projeto. Os
seguintes formulários serão exibidos no browser.
5. Execute o projeto, selecione qualquer cliente da lista e mova o cursor para o
próximo controle. Observe como o restante dos campos serão preenchidos
automaticamente com as informações do cliente, conforme mostrado na captura
de tela a seguir:
23
6. Ao clicar na página da guia Detalhes, você verá mais informações sobre o cliente,
conforme mostrado na captura de tela a seguir:
A nova classe chamada MyDialogSelect é na verdade uma cópia da classe MyDialog

da atividade anterior, com algumas mudanças. Em sua declaração de classe,
deixamos todos os DialogField declarações e removendo o resto das variáveis.
Os métodos pack() e unpack() permaneceram os mesmos, já que não estamos

usando nenhum de seus recursos.
No método dialog() invocamos o método allowUpdateOnSelectCtrl() com o

argumento true para ativar o tratamento de eventos de controle de entrada. Nós
também desabilitamos todos os controles, além da conta do Cliente, inovamos o
método enblaed() com o parâmetro false para cada controle.
O método dialogSelectCtrl() membro da classe RunBase e é invocado toda vez que

o usuário modifica qualquer controle de entrada na caixa de diálogo. É o lugar onde
temos que adicionar todo o código necessário para garantir que, no nosso caso,
todos os controles sejam preenchidos com os dados corretos a partir do registro do
cliente, uma vez que a conta do cliente é selecionada.
O método main() garante que a classe seja executável.
24
Gerenciamento de Dados
Introdução
O recurso de gerenciamento de dados no Dynamics 365 for Finance and Operations

permite que você gerenciar e auditar seus dados eficientemente em sistemas. O
excelente recurso fornecendo muitas ferramentas como importar, exportar, excluir
dados em massa e detectar dados duplicados e assim por diante. Você pode também
desenvolver entidades de dados personalizadas. A integração através da plataforma
de gerenciamento de dados fornece mais recursos e maior taxa de transferência
para inserir / extrair dados por meio de entidades. Normalmente, os dados passam
por três fases neste cenário de integração:
 Fonte (Source) - Esses são arquivos de dados de entrada ou mensagens na fila.

Dados típicos os formatos incluem CSV, XML e delimitado por tabulações.
 Cenário (Staging) - Estas são tabelas geradas automaticamente que mapeiam
muito de perto entidade de dados. Quando o gerenciamento de dados ativado é
verdadeiro, as tabelas de migração são geradas para fornecer armazenamento
intermediário. Isso permite que a estrutura faça grandes volumes análise de
arquivos, transformação e algumas validações.
 Alvo (Target) - Esta é a entidade de dados onde os dados serão importados.
Entidades de dados
Na versão anterior do Dynamics 365 for Finance and Operations, há várias opções
como DIXF, Excel Add-ins e AIF para gerenciamento de dados. Entidades de dados
são introduzidos como parte do gerenciamento de dados para ser usado como uma
camada de abstração para facilmente entender usando conceitos de negócios. O
conceito de entidades de dados combina esses conceitos diferentes em um. Você
pode reutilizar dados entidades para um Excel Suplementos, Integração ou
Importação / Exportação. A tabela a seguir mostra os principais cenários de
gerenciamento de dados:
Data Migration Migrar dados de referência, mestre e documento de legado ou

sistemas externos
Setup and copy Copiar configuração entre empresa / ambientes.
configuration Configurar processos ou módulos usando o Lifecycle Services
Ambiente (LCS).
Integration Integração baseada em serviços em tempo real.
Integração assíncrona.
O gerenciamento de dados usa entidades de dados sob uma camada abstrata de

lógica de negócios implementação. Os dados são inseridos nas tabelas de preparação
usando o SSIS (SQL Server Integration Services), que é validado e transformada para
mapear para a entidade de destino.
25
Criando uma entidade de dados
1. Crie um projeto do Dynamics 365 for Operations no Visual Studio.

2. Vamos criar uma tabela de demonstração com alguns campos como segue, para
usar neste Entidade de Dados:
26
3. Adicione uma nova entidade de dados no projeto clicando com o botão direito do
mouse no menu da seguinte maneira:
4. Em seguida, você receberá uma tela do assistente, selecione PacktVendTable

como a principal fonte de dados. Categoria da entidade como mestre e clique em
Avançar:
27
5. Na próxima etapa, você deve escolher todos os campos obrigatórios, para esta
atividade vamos manter apenas alguns campos e marcá-los como é obrigatório
também. Uma vez feito, clique em Finish:
6. Salve seu projeto e construa-o. O projeto deve ter a seguinte aparência:
7. Agora precisamos adicionar essa entidade no espaço de trabalho de

gerenciamento de dados. Navegar para Espaço de trabalho | Gerenciamento de
dados | Entidades de dados.
28
Adicione um novo registro da seguinte maneira e salve-o. Agora clique em Validar:
8. Vamos tentar importar dados para o PacktVendTable usando essa nova entidade
de dados. Agora vá de volta ao espaço de trabalho de gerenciamento de dados.
Clique em Importar tile. Preencha os detalhes do seguinte modo:
Carregue o arquivo do Excel que contém dados. Agora clique no botão Importar.
Você vai ter uma notificação assim que esta importação é feita. Para verificar,
navegue na tabela e verifique os dados inseridos.
29
Estruturas de dados
Neste tópico, vamos cobrir os seguintes quesitos:
 Tipos enumeradores
 EDT (Extended Data Type)
 Tabelas de configuração
 Tabela de parâmetros
 Tabelas de dados principais
Abordaremos as tarefas necessárias para gravar os elementos do dicionário de

dados utilizados no desenvolvimento das customizações.
As estruturas de dados em Operações não são apenas tabelas e visualizações, mas

também incluem a capacidade de defina um dicionário de dados. Isso agora é
chamado de modelo de dados nas operações. O modelo de dados não mudou muito
na estrutura desde o AX 2012, mas é muito mais refinado com muito mais recursos
para auxiliar o desenvolvimento e minimizar a pegada ao estender as tabelas padrão
e tipos.
Este tópico não cobre a criação de extensões de tipos padrão, mas cobre como criar
tipos que permitam que suas estruturas sejam extensíveis.
A maioria dos desenvolvimentos em Dynamics 365 FO é baseada em padrões,

mesmo que não tenhamos conhecimento disso. Por exemplo, as listas de
fornecedores e clientes são muito semelhantes e são chamadas de tabelas principais.
Ordens de compra e ordens de venda também são muito semelhantes.
Tabelas em Dynamics 365 FO têm uma propriedade que define o tipo de tabela e
cada tipo é associado a um estilo particular de formulário para a interface do
usuário. Poderíamos, portanto, considerar esses tipos como padrões. Se pensarmos
neles como padrões, é muito mais fácil aplicar as receitas para nosso próprio
desenvolvimento.
A lista a seguir é dos tipos de tabelas comuns, listados com o design de formulário
usual e suas uso típico:
Grupo de Tabelas Design de Form Utilização

Miscellaneous Isso é essencialmente "indefinido" e
não deve ser usado, diferente de tabelas
temporárias.
Parameter Índice Isso é usado para formulários de
parâmetro de registro único.
Group Lista simples Lista Isso é usado para a tabela de apoio para
simples e Detalhes - drop-down
grade da lista listas. O padrão de design de lista
simples é adequado para
quando apenas alguns campos são
necessários; de outra forma, os padrões
30
de lista simples e detalhes devem ser
usado para que os campos sejam
apresentados de uma maneira útil para
o usuário.
Main Mestre Detalhe Isso é usado para tabelas principais,
como clientes, fornecedores e itens.
Transaction Lista simples e Isso é usado para conjuntos de dados,
Header Detalhes com Guias como a fatura formulário de diário, que
Transaction Line padrão contém informações transacionais
dados com cabeçalho e linhas.
Transaction Lista simples e Isso é usado para tabelas, como o
Detalhes com Formulário de transação de Inventário,
padrão guias que contém dados transacionais, mas
em um único nível.
Worksheet header Detalhes Transação Isso é usado para conjuntos de dados de
Worksheet line entrada de dados, como a ordem de
compra, em que o conjunto de dados é
composto tabelas de cabeçalho e linha.
O padrão tem dois visualizações, uma
exibição de lista de registros de
cabeçalho e um detalhe veja onde o foco
são as linhas.
Worksheet Mestre Detalhe Este é um conjunto de dados de entrada
de dados de nível único, que são
raramente usados no Dynamics 365 FO.
Tipos de enumeradores (Base ENUM)
Tipos enumeradores são semelhantes aos tipos de enumeradores em C#. Eles são
comumente referidos como Enums. É um inteiro referenciado como símbolo, que
pode ser usado no código para controlar a lógica. Também pode ser usado como um
campo em uma mesa que fornece uma lista suspensa fixa ao usuário. Quando usado
como um campo, ele tem a capacidade de fornecer etiquetas fáceis de usar para cada
símbolo.
Todos os Enums devem ser definidos no modelo de dados antes de usá-los e não
podem ser definidos dentro de uma classe ou método.
Existem centenas de tipos enumeráveis que são construídos no aplicativo padrão.

Por exemplo o Enum NoYes tem dois literais associados, onde No tem o valor 0 e
Yes tem o valor 1.
31
Adicionar valores a enums por meio de extensão:
Para adicionar novos valores a um enum, você deve estender o enum. Qualquer
enum que esteja marcado como Extensible ( IsExtensible = true ) pode ser estendido.
Você pode encontrar as informações de extensibilidade na janela Propriedades no
Microsoft Visual Studio, conforme mostrado na ilustração a seguir:
Quando valores enum extensíveis são sincronizados, os valores inteiros de um enum

da linha de base são determinantes, enquanto os valores inteiros dos valores enum
da extensão não são determinantes. Os valores são gerados durante a sincronização.
Portanto, você não pode ter lógica que depende do valor inteiro dos valores enum.
aqui estão alguns exemplos:
 Comparações alcance, tais como <, > e..

 Intervalos modelados em visualizações e consultas
 Intervalos de consulta criados a partir do código
Normalmente, um enum extendido deve ter sua própria implementação onde quer
que seja usado. Procure todos os usos do enum e aproveite a implementação onde
for necessário.
Estendendo um enum
Existem duas maneiras de estender um enum:
 Crie um projeto que tenha uma referência de modelo onde você deseja a nova
extensão de enumeração. Clique com o botão direito do mouse no enum para
estender e selecione Criar extensão.
32
 Clique com o botão direito do mouse no enum para estender e selecione Criar
extensão em novo projeto. Você é solicitado a selecionar o modelo no qual o enum
de extensão deve ser criado.
Usando Enums para comparação e status
É muito comum usar um Enum para definir o status de um registro, e cobriremos o

estado máquinas no Capítulo 15, Máquinas do Estado. Ao definir um Enum para
status, vamos requisitar os elementos para que possamos compará-los no código.
No caso do Enum SalesStatus, os elementos são os seguintes:
Symbol Value
None 0
Backorder 1
Delivered 2
Invoiced 3
Canceled 4
33
Dessa forma, podemos selecionar todos os pedidos de vendas, que ainda não foram
faturados, usando os seguintes linhas de código:
select SalesId, SalesName from salesTable

where salesTable.SalesStatus < SalesStatus::Invoiced
select sum(Qty), ItemId from inventTrans

where inventTrans.StatusIssue <= StatusIssue::Sold
&& inventTrans.StatusReceipt <= StatusReceipt::Purchased
EDT (Extended Data Type)
As pesquisas de tipo de relação EDT (Extended Data Type) e de tabela são as

pesquisas mais simples em Dynamics 365 for Finance and Operations e pode ser
criado em segundos sem qualquer conhecimento de programação. Eles são
baseados em relações de tabelas e aparecem automaticamente. Não modificações
adicionais são necessárias. Esta receita mostrará como criar uma pesquisa
automática básica usando as relações de tabela. Para demonstrar isso, vamos
adicionar uma nova coluna TO ao existente Formulário de grupo de clientes.
Os EDTs típicos que usamos para isso são mostrados na seguinte tabela:
EDT Tipo Tam Utilização

SysGroup String 10 Campos de chave primária para tabelas de
grupos. Grupo tabelas são aquelas usadas para
tabelas de apoio para listas suspensas. Eles
podem fornecer mais definições para um registro,
ou apenas ser usado para relatórios. Exemplos
incluem o seguinte:
• grupo de itens
• grupo de clientes
• grupo de modelos de item
Num String 20 Chaves primárias em tabelas de planilha, como
tabela de pedidos de vendas (SalesTable). Esses
campos são geralmente numerados com base em
uma sequência numérica, que deve ter um
tamanho da string de 20 caracteres.
Exemplos incluem o seguinte:
• número do pedido de venda
• Número do pedido
AccountNum String 20 Campos de chave primária para tabelas
principais, como Tabela do cliente. Essas tabelas
também são, geralmente, baseadas em sequência
numérica.
34
Exemplos incluem o seguinte:
• Conta de cliente
• conta do fornecedor
Name String 60 Todos os campos de nome devem ser baseados
neste EDT, como nome, nome do cliente e assim
por diante. Este EDT pode ser usado como é, a
menos que desejemos especificar um rótulo e um
texto de ajuda.
Description String 30 Isso é usado como o campo de descrição nas
tabelas de grupos. Este EDT é geralmente usado
como está e geralmente não é estendido.
AmountMST Real Todos os EDTs de valor monetário que
armazenam a quantia em moeda local moeda
deve basear-se neste EDT. MST significa Norma
Monetária.
AmountCur Real Todos os EDTs de valor monetário que
armazenam o valor no A moeda da transação
deve ser baseada neste EDT.
Qty Real Todos os campos que armazenam uma
quantidade devem ser baseados neste EDT.
Para criar um EDT, siga estas etapas:
1. A criação de um EDT é iniciada da mesma forma que todos os novos artefatos do

Dynamics 365 FO: por pressionando Ctrl + Shift + A ou clicando com o botão
direito em uma pasta no gerenciador de soluções e escolhendo Adicionar | Novo
item.
2. Selecione Tipos de dados na lista à esquerda e selecione EDT String.
3. No campo Nome, insira ConWHSVehicleId e pressione incluir.
4. Em seguida, precisaremos preencher a folha de propriedades; as principais
propriedades são descritas na seguinte tabela:
Propriedade Valor Descrição

Label Vehicle ID Este é o rótulo que será apresentado ao
usuário na interface do usuário quando
adicionado como um campo a uma
tabela.
Help Text The vehicle number Este é o texto de ajuda mostrado ao
usuário quando este campo é
selecionado ou o mouse passa sobre os
controles com base nste EDT.
Extends AccountNum Isso é completado para a maioria dos
campos, já que normalmente seguindo
um padrão, como ID, Nome e
agrupamento Campos.
Size Isso será somente leitura, já que
baseamos este EDT em outro EDT. Isso
35
está sob a seção Aparência, mas ele
controla o tamanho dos campos
associados no base de dados.
Reference Table Para tipos usados como um campo de
chave primária em uma tabela,
propriedade deve ser preenchida.
Juntamente com as referências da
tabela, pode ser usado para criar a
relação de chave estrangeira em tabelas
filhas.
Como sempre, lembre-se de criar etiquetas para o rótulo e o texto de ajuda

propriedades para cada um dos seus idiomas suportados.
Criando uma pesquisa automática (Lookup) através de extensão
Para criar uma pesquisa automática, podemos seguir os seguintes passos:
1. Crie uma solução denominada CreatingAutomaticLookup e atribua um pacote

apropriado para ele.
2. Encontre a tabela CustGroup na AOT no explorador de aplicativos, clique com o
botão direito na tabela, e selecione a opção CreateExtension para adicioná-lo ao
projeto e criar uma string digite campo na tabela com as seguintes propriedades:
Property Value
Name PaymMode
ExtendedDataType CustPaymMode
3. Adicione o campo recém-criado ao final do grupo de campos of da tabela.

4. Salve seu (s) objeto (s) e construa a solução.
5. Para verificar os resultados, vá em Contas a receber | Configuração | Clientes |
Grupos de clientes e observe a recém-criada coluna Método de pagamento com
a pesquisa:
36
O campo recém-criado é baseado no tipo de dados estendidos e portanto, herda
automaticamente sua relação. Para seguir as melhores práticas, todas as relações
devem estarem presentes.
Nota: EDT não deve ser utilizado para aplicar regra de negócio em customizações.
Criando tabelas de configuração
Nesta seção, criaremos uma tabela de grupos. Uma tabela de grupo é usada como
uma chave estrangeira na principal tabelas, como o grupo de clientes na tabela de
clientes e o grupo de fornecedores na tabela de fornecedores; as tabelas de clientes
e fornecedores são exemplos de tabelas principais. Tabelas de grupo tem pelo
menos dois campos, um ID e um campo Descrição, mas pode conter mais conforme
necessário. Nesse caso, para ajudar o fluxo, criaremos a tabela de grupos primeiro.
Nós só precisamos de um projeto de Dynamics 365 FO aberto no Visual Studio.
Vamos criar uma tabela de grupos de veículos. Nós não temos muita escolha sobre
o nome neste tem que começar com nosso prefixo e terminar com Group portanto
fica a sugestão ConWHSVehicleGroup. Para criar essa tabela, siga estas etapas:
1. Iniciaremos criando os EDTs, crie um grupo de veículos EDT usando os

parâmetros seguintes:
Propriedade Valor
Name ConWHSVehicleGroupId
Label Vehicle group
Help Text Id do grupo de veículos
Extends SysGroup
2. Salve o EDT, mas não feche o designer.

3. De dentro do projeto, escolha criar um item.
4. Escolha Data Model na lista à esquerda e selecione Tabela à direita.
5. Digite ConWHSVehicleGroup no campo Nome e pressione Incluir.
6. Abra o designer de tabela em uma nova guia. Do projeto, arraste o
ConWHSVehicleGroupId EDT na parte superior do nó Fields em nossa tabela,
conforme mostrado em a seguinte captura de tela:
37
7. Isso cria o campo com o mesmo nome que o EDT. Como esta é a nossa mesa,
devemos remover o prefixo e nomeá-lo como VehicleGroupId.
8. Agora podemos concluir nosso EDT, abrir o ConWHSVehicleGroupId EDT ou
selecione a guia se ela ainda estiver aberta) e insira ConWHSVehicleGroup na
Referência Propriedade da tabela.
9. Clique com o botão direito do mouse no nó Referências da Tabela e selecione Novo
| Referência de tabela.
10. Na folha de propriedades, selecione a propriedade Campo Relacionado e
selecione VehicleGroupId na lista suspensa.
11. Salve o EDT e feche seu designer. Isso deve tornar a guia ativa Designer de tabela
ConWHSVehicleGroup; se não, selecione novamente.
12. No Explorador de Aplicativos, que é aberto no menu Visualizar, expanda Tipos
de Dados e, em seguida, expanda Tipos de dados estendidos.
13. Localize o campo Descrição e arraste-o para o nó Campos de nossa tabela.
Criando uma tabela de parâmetros
Uma tabela de parâmetros contém apenas um registro por empresa. A tabela contém
uma lista de campos, que podem ser padrões ou opções específicas da empresa
usadas no código para determinar o que deve acontecer. A tabela de parâmetros
geralmente é criada primeiro e os vários campos que atuam como parâmetros são
adicionados à medida que criamos a solução.
Isso segue diretamente do roteiro Criar tabelas de configuração.
38
Para criar a tabela de parâmetros, siga estas etapas:
1. Crie uma tabela denominada ConWHSVehiclePararameters, novamente, o

prefixo e o sufixo são baseados nas boas práticas. Normalmente, o nome só será
<Prefixo> + <Módulo> + Parâmetros.
2. Defina os parâmetros da tabela da seguinte forma:
Propriedade Valor
Label Parâmetros de gerenciamento de veículos
Cache lookup Encontrado
Table Group Parameter
Created By Yes
Created Date Time
Modified By
Modified Date Time
Developer A tabela ConWHSVehicleParameters armazena os
Documentation parâmetros para a solução de gerenciamento de
veículos
3. Arraste o EDT ConWHSVehicleGroupId para o nó Campos e renomeie para

DefaultVehicleGroupId.
4. Arraste o EDT ParametersKey do Application Explorer para o nó Fields.
5. Renomeie para Key e altere a propriedade Visible para No.
6. Crie um grupo de campos chamado Padrões e defina a propriedade Rótulo. Use a
pesquisa para localizar um rótulo adequado.
7. Arraste o campo DefaultVehicleGroupId para o novo grupo de campos Padrões.
8. Clique com o botão direito do mouse no nó Realtions e selecione Novo | Relação
Chave Estrangeira.
9. Preencha os parâmetros da seguinte maneira:
Propriedade Valor Comentário

Name ConWHSVehicleGroup O nome da relação é geralmente o
nome da a tabela, a menos que
tenhamos duas chaves estrangeiras
para a mesma mesa.
Related Table ConWHSVehicleGroup A tabela à qual nossa chave
estrangeira se refere.
Cardinality ZeroOne Haverá um ou nenhum registro de
parâmetro relativo ao registo do
grupo de veículos. Um relacionamento
um-para-muitos usaria ZeroMore ou
OneMore.
Related Table ZeroOne O valor não é obrigatório, então
Cardinality podemos, portanto, referem-se a zero
39
registros de grupos de veículos, ou
um.
Relationship Association O registro de parâmetro está
Type associado a um registro do veículo. A
composição seria usada em conjuntos
de dados de cabeçalho / linhas, em
que Cabeçalho deve excluir os
registros de linhas.
On Delete Restricted Isso impedirá que um registro de
grupo de veículos seja excluído, se for
especificado nesta tabela.
Role Este é o papel da relação, e deve ser
único dentro desta tabela. Se
UseUniqueRoleNames for Sim,
somente precisa especificar isso se
tivermos dois chave estrangeira
relações com a mesma tabela.
10. Clique com o botão direito em Relation e selecione New | Normal.

11. Na propriedade Field, especifique a chave estrangeira (o campo nesta tabela),
DefaultVehicleGroupId.
12. Na propriedade Campo Relacionado, especifique a chave na tabela pai:
VehicleGroupId.
13. Crie um índice chamado KeyIdx e inclua o campo Key nele. É único por por
padrão, ele age como um índice de restrição.
14. Agora podemos criar o método Find and Exist. Há uma diferença para tabelas de
parâmetros, em que o método Find cria um registro de uma maneira particular.
Crie o método Find, conforme mostrado no seguinte trecho de código:
public static ConWHSVehicleParameters Find(boolean _forupdate = false)
{
ConWHSVehicleParameters parameter;
parameter.selectForUpdate(_forupdate);
select firstonly parameter index Key
where parameter.Key == 0;
if (!parameter && !parameter.isTmp())
{
// Create the parameter
Company::createParameter(parameter);
}
return parameter;
}
40
15. Vamos usar uma declaração select ligeiramente diferente, onde podemos escrever o
select declaração na linha, o que significa que não temos que declarar o tipo como uma
variável, escreva o método Exist da seguinte forma:
public static boolean Exist()
{
return (select firstonly RecId
from ConWHSVehicleParameters).RecId != 0;
}
16. Queremos garantir que o registro não possa ser excluído. Então, vamos
substituir o Excluir o método. Pressione Return no início do método Find para criar
um espaço em branco linha no topo. Clique com o botão direito do mouse nessa linha
em branco e escolha Inserir Método de Substituição | Excluir. Altere o método para
que ele leia da seguinte maneira:
public void delete()
{
throw error("@SYS23721");
}
17. Nós definimos a propriedade Table Cache como EntireTable. Sempre que esta
tabela é atualizado, precisaremos liberar o cache para que o sistema use a
atualização valores. Substitua o método de atualização da seguinte maneira:
public void update()
{
super();
flush ConWHSVehicleParameters;
}
Fato relevante:
A operação de compilação validará e compilará o pacote em uma DLL. Isso deve ser
feito antes de sincronizarmos o banco de dados. Isso pode falhar, e nesta fase, é
normalmente devido a referências ausentes. No Explorador de Aplicativos, cada
elemento mostra o pacote para qual pertence. Devemos garantir que nossas
referências de modelo para todos os tipos que usamos dentro nosso projeto. Se não
o fizermos, obteremos erros de construção como este:
41
Para adicionar as referências necessárias, podemos seguir estas etapas:
1. Localize o tipo com o erro no Explorador de Aplicativos.
2. Observe o pacote em que está, entre colchetes.
3. Navegue para o Dynamics 365 | Gestão de Modelos | Atualize os parâmetros do
modelo ....
4. Selecione o modelo ConWHSVehicleManagement.
5. Clique em Next.
6. Verifique se o pacote necessário está marcado e, em seguida, pressione Avançar.
7. Pressione Concluir.
8. Navegue para o Dynamics 365 | Modelo de gerenciamento e selecione Atualizar
modelos.
9. Tente a operação de construção novamente; você pode precisar repetir isso como
um erro pode mascarar outro.
Criando tabelas de dados principais

Nesta seção, criaremos uma tabela principal, semelhante à tabela de clientes. Os
passos são semelhantes ao grupo de veículos, e vamos abreviar alguns dos passos
que já temos feito. O padrão descrito nesta receita pode ser aplicado a qualquer
tabela principal usando seu próprio tipos de dados. A tabela neste exemplo será para
armazenar detalhes do veículo.
O design da tabela será o seguinte:
Campo Tipo Tam EDT ( : indica extensão)
VehicleId String 20 ConWHSVehicleId : Num
VehicleGroupId String 10 ConWHSVehicleGroupId
RegNum String 10 ConWHSVehRegNum
AcquiredDate Date ConWHSAcquiredDate : TransDate
Para seguir essas etapas, os elementos criados anteriormente neste capítulo devem
ser criados.
Para criar a tabela de veículos, siga estes passos:
1. Crie o EDT ConWHSVehicleId com as seguintes propriedades:
Propriedade Valor
Name ConWHSVehicleId
Extends Num
Label Vehicle Id
Help Text Id do Veículo
42
2. Crie o EDT ConWHSVehRegNum com as seguintes propriedades:
Propriedade Valor
Name ConWHSVehRegNum
Size 10
Label Número de registro do veículo
Help Text Número de registro do veículo
Change case UpperCase
3. Crie EDT ConWHSAcquiredDate EDT, lembrando que precisaremos cria-lo como

uma data EDT. Use as seguintes propriedades:
Propriedade Valor
Name ConWHSAcquiredDate
Extends TransDate
Label Data de Aquisição
Help Text A data em que o veículo foi adquirido
4. Crie a tabela ConWHSVehicleTable. O nome da tabela deve iniciar com o nosso

prefixo, seguido pelo nome da entidade como substantivo singular e sufixado com a
tabela.
5. Arraste os EDTs para a tabela nesta ordem:
 ConWHSVehicleId
 Description
 ConWHSVehicleGroupId
 ConWHSVehicleType
 ConWHSVehRegNum
 ConWHSAcquiredDate
6. Remova o prefixo ConWHS dos campos como eles estão em nossa tabela.
7. No campo VehRegNum, altere a propriedade AliasFor para VehicleId.
8. Salve a tabela e abra o EDT ConWHSVehicleId. Complete Propriedade Reference
Table no nó Referências da Tabela.
9. Feche a tabela do designer para o EDT e volte para o designer de tabelas.
10. Altere as propriedades dos campos VehicleId como um campo de ID da seguinte
forma:
Propriedade Valor
Allow Edit No
Allow Edit On Create Yes
Mandatory Yes
43
11. O campo GroupId de uma tabela principal geralmente tem um impacto na lógica,
e é geralmente obrigatório. Mesmo que isso não aconteça, ainda devemos criar o
campo VehicleGroupId obrigatório.
12. Não torne obrigatório o campo VehicleType.
13. Crie um índice exclusivo chamado VehicleIdx com o campo VehicleId.
14. Os campos de grupo são frequentemente usados para consultas de agregação ou
de pesquisa, portanto, devemos criar um índice chamado VehicleGroupIdx e
adicione o campo VehicleGroupId a ele, o índice não deve ser exclusivo.
15. Preencha as propriedades da tabela da seguinte forma:
Propriedade Valor
Label Vehicles
Title Field 1 VehicleId
Title Field 2 Description
Cache lookup Found
Clustered Index VehicleIdx
Primary Index VehicleIdx
Table Group Main
Created By Yes
Created Date Time
Modified By
Modified Date Time
Developer ConWHSVehicleTable contains vehicle records
Documentation
Form Ref This is blank until we have created the form
16. Crie uma Visão geral do grupo de campos, identificada apropriadamente e

arraste nos campos deseja mostrar na grade da lista principal no formulário.
17. Crie um grupo de campos, Detalhes e encontre um rótulo apropriado. Arraste
nos campos que deve aparecer no cabeçalho do formulário ao visualizar os detalhes
do veículo.
18. As tabelas principais são geralmente referenciadas nas tabelas da planilha e as
Operações crie uma pesquisa para nós com base na relação na tabela estrangeira.
Para controlar os campos na pesquisa automática, arraste os campos que deseja ver
na Grupo de campos AutoLookup verifique se VehicleId é o primeiro.
19. Crie uma relação de chave estrangeira para o campo VehicleGroupId usando as
seguintes propriedades:
Parâmetro Valor
Name ConWHSVehicleGroup
Related Table ConWHSVehicleGroup
Cardinality OneMore The field is mandatory
Related Table Cardinality ZeroOne
44
Relationship Type Association
On Delete Restricted
20. Adicione uma relação de campo normal à relação, conectando os campos

GroupId.
21. É comum inicializar tabelas principais a partir de padrões, mantidos em
parâmetros. O método initValue é chamado quando o usuário cria um registro.
Clique com o botão direito do mouse o nó Métodos e selecione Substituir | initValue.
22. No editor de código, ajuste o código para que ele leia o seguinte:
public void initValue()
{
ConWHSVehicleParameters parm;
parm = ConWHSVehicleParameters::Find();
super();
this.VehicleGroupId = parm.DefaultVehicleGroupId;
}
23. Em seguida, adicione os métodos Find e Exist usando o campo de chave primária
da tabela como habitual.
24. Finalmente, adicionaremos um método de validação de campo para garantir que
a data de aquisição não é antes de hoje. Substitua o método validateField e adicione
o seguinte código entre o código o ret = super (); linha e retorno ret ;:
switch (ret)
{
case fieldNum(ConWHSVehicleTable, AcquiredDate):
Timezone clientTimeZone = DateTimeUtil::getClientMachineTimeZone();
TransDate today =DateTimeUtil::getSystemDate(clientTimeZone);
if(this.AcquiredDate < today)
{
// The acquisition date must be today or later
ret = checkFailed("@ConWHS:ConWHS29");
}
break;
}
25. Crie um rótulo para a mensagem de erro retornada por checkFailed e substitua
o literal com o ID da etiqueta.
26. Depois de concluído, salve e feche o editor de código de tabela e as páginas da
guia designer.
Nota:
A instrução switch deve sempre ser usada no método validateField, mesmo se nós
só pretendo lidar com um caso. Uma declaração if pode parecer mais fácil, mas fará
o código menos passível de manutenção. Isso vale para qualquer cheque como este,
onde os casos têm a possibilidade de aumentar.
45
Interface do usuário
 Estrutura do menu
 Formulário de parâmetro
 Itens de menu
 Formulários de configuração
 Formulário mestre (tabela principal)
 Formulário de transação de detalhes (entrada de pedido)
 Etiquetas (Label)
Ao criar formulários, devemos fornecer consistência aos usuários, e para ajudar com
isso, nós usaremos padrões de design de formulário. O padrão de design do
formulário é determinado pelo grupo de tabelas, Estruturas de Dados. Existem casos
especiais em que podemos ter variações, mas, para a parte principal, devemos nos
ater aos padrões sugeridos neste capítulo.
Criando a estrutura do menu
A estrutura do menu é transferida dos conceitos de interface do usuário no AX 2012.

No Dynamics 365 FO, os menus têm a mesma estrutura, mas são abertos a partir do
menu 'burger' onde o botão logo abaixo do logotipo do Office 365 na parte superior
esquerda da página, conforme mostrado captura de tela:
46
Cada menu aparece na opção Módulos, conforme mostrado na captura de tela a
seguir:
Todos os itens de menu para formulários, relatórios e processos devem ser

colocados na estrutura do menu, mesmo se depois criarmos um espaço de trabalho.
A estrutura do menu pode parecer ter sido relaxada um pouco da estrutura rígida
recomendado no Dynamics AX 2012. No Dynamics AX 2012, sempre temos os
seguintes cabeçalhos principais em um menu: Comum, Consultas, Relatórios,
Periódico e Configuração. Se nós olharmos o menu AccountsPayable no Explorador
de Aplicativos, podemos ver que a estrutura antiga foi aplainada, conforme
mostrado na seguinte captura de tela:
47
A estrutura atual agora está organizada da seguinte maneira:
 Workspaces: VendInvoiceWorkspace, VendPaymentWorkspaceTile.

 Details Master (Main) tables: Vendors
 Details Transaction (Worksheets): PurchaseOrders, VendorInvoices
 Journals: Payments
 Inquiries and Reports: VendPackingSlipJournal, VendTransList,
 VendAccountStatementInt
 Periodic tasks: PeriodicTasks
 Set up and configuration: Setup, PolicySetup, and so on
O menu ainda precisa de uma estrutura comum para facilitar a localização dos
usuários opções mais facilmente, mas não estamos limitados a uma estrutura rígida.
Você pode argumentar que o menu não tem um nó de espaço de trabalho, isso é
porque isso foi adicionado através de um menu extensão, conforme mostrado na
captura de tela a seguir:
48
Vamos apenas precisar do nosso projeto aberto no Visual Studio:
Para criar a estrutura de menus, siga estas etapas:

1. Adicione um novo item ao projeto (selecione um nó de pasta e pressione Ctrl +
Shift + A).
2. Selecione Interface do usuário na lista à esquerda e depois Menu à direita.
3. Digite ConWHSVehicleManagement no campo Nome e pressione OK.
4. No designer, crie um rótulo para Gerenciamento de veículos e insira isso como
a propriedade Label do menu.
5. Clique com o botão direito do mouse no novo menu do designer e escolha Novo |
Submenu
6. Preencha da seguinte maneira para os seguintes submenus:
Name Label
Workspaces @SYS:Platform_Menu_ColHeading_Workspaces
Vehicles Vehicles (new label)
ServiceOrders Service orders (new label)
PeriodicTasks @SYS76406
InquiriesAndReports @SYS3850
Setup @SYS333869
7. Podemos adicionar mais submenus para ajudar a organizar a estrutura, se esta for
requeridos.
8. Salve e feche o designer de menu.
9. Agora precisaremos estender o menu principal para que possamos navegar para
o nosso menu.
10. No Explorador de Aplicativos, navegue até AOT | Interface do usuário | Menus
11. Clique com o botão direito do mouse em MainMenu e escolha Criar extensão.
12. Renomeie o novo item em nosso projeto de MainMenu.Extension para
MainMenu.ConWHSVehicleManagement.
13. Abra MainMenu.ConWHSVehicleManagement.
14. Clique com o botão direito do mouse no nó raiz e escolha Novo | Referência de
menu.
15. Defina as propriedades Name e Menu Name como ConWHSVehicleManagement.
16. Salve e feche o designer.
49
Criando um formulário de parâmetro
Os formulários de parâmetros mostram as configurações em grupos de campos e
guias usando um índice forma de estilo. Eles também são usados para mostrar as
sequências numéricas configuradas para esse módulo. Estamos seguindo nossa
solução de amostra de gerenciamento de veículos, mas esse padrão pode ser
aplicado a qualquer tabela de parâmetros.
Para criar o formulário de parâmetro, siga estas etapas:

1. Arraste a tabela ConWHSVehicleParameters do projeto para o nó de Data
Source no painel superior esquerdo do designer de formulários.
2. Nomeie o formulário de acordo com o nome da tabela, nesse caso,
ConWHSVehicleParameters.
3. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito
painel.
4. Escolha adicionar um novo item ao projeto.
5. As fontes de dados fornecem opções adicionais de como essa tabela deve se
comportar Formato. Não queremos que o usuário possa excluir e criar registros,
portanto, altere as seguintes propriedades para Não:
o Permitir criar
o Permitir exclusão
o Inserir no final
o Inserir se vazio
5. O designer de formulários está dividido em três áreas: O painel Formulário, o
painel Design e Painel de conformidade de visualização / padrão, conforme
mostrado na captura de tela a seguir:
7. Vamos aplicar algumas propriedades básicas para o formulário, que são mantidas
contra o Design nó, como mostrado aqui:
50
Propriedade Valor Comentário
Caption Parâmetros de gerenciamento Isso é mostrado no título do
de veículos formulário e geralmente é o
nome da mesa.
Data Source ConWHSVehicleParameters Os nós filhos no formulário
usarão isso como a
propriedade padrão Data
Source.
Title Data Source ConWHSVehicleParameters Este formulário usará o
campo de título propriedades
da tabela e exibição no
formulário.
8. O nó Design indica que um padrão não está especificado, o que devemos fazer.
Para aplique o padrão de formulário principal, clique com o botão direito do mouse
no nó Design e escolha Aplicar Padrão | Índice.
9. O painel inferior muda para a guia Padrão e mostra o padrão requerido estrutura,
como mostrado na captura de tela a seguir:
Vamos nos referir a cada nó na estrutura padrão como um elemento padrão e, para
facilitar o design, nomeie os controles com base no nome do elemento padrão.
10. Isso nos permite adicionar um controle Tab, então clique com o botão direito do
mouse no nó Design e escolha Novo | Aba.
11. O erro é removido do painel Padrão, mas mostra que não temos páginas de guias
dentro do elemento padrão TOC Tabs (Tab).
12. Primeiro, renomeie o novo controle para ParameterTab e adicione uma nova
Página de guia por Clique com o botão direito do mouse sobre ele no painel Design
e selecione Nova página de guia.
13. A primeira guia geralmente é uma guia de configurações gerais, portanto, nomeie
esse novo controle GeneralTabPage.
14. Encontre um rótulo adequado para Geral e insira-o na propriedade Rótulo.
15. À medida que alteramos o design, o designer verificará continuamente se somos
em conformidade com o padrão. Encontrou os seguintes problemas com a ficha de
registro ao controle:
51
16. Devemos adicionar dois controles de Grupo, um para campos de título que
fornecem ajuda ao usuário, e o outro para os campos que desejamos mostrar nesta
página.
17. Clique com o botão direito do mouse no controle GeneralTabPage e selecione
New | Grupo.
18. Renomeie o novo controle de grupo para GeneralTitleGroup.
19. O painel de conformidade de padrão mostra que devemos ter um controle
StaticText para o título principal e 0 ou 1 controles StaticText para um título
secundário. Clique com o botão direito do mouse GeneralTitleGroup e escolha Novo
| Texto estático.
20. Mude o nome do novo controlo StaticText para GeneralTitleText.
21. Crie um novo rótulo para o texto Parâmetros gerais e insira o ID no Propriedade
de texto.
22. Selecione novamente o controle GeneralTitleGroup e verifique se os erros de
padrão desapareceram.
23. Selecione novamente o GeneralTabPage, pois agora temos um erro de padrão
para um grupo ausente. Adicione um novo controle de grupo.
24. O novo grupo de controle sabe que também deve ter um padrão aplicado,
indicado pelo padrão: texto <não especificado> após o nome do controle. Clique com
o botão direito do mouse controle e escolha Aplicar padrão | Campos e Grupos de
Campo.
25. Mude o nome do controlo para GeneralFields.
26. No painel de formulário, expanda Data Sources, ConWHSVehicleParameters e,
em seguida, Grupos de campo.
27. Arraste o grupo de campos Padrões para o controle GeneralFields no painel de
desenho, conforme mostrado na captura de tela a seguir:
52
28. Verifique cada nó quanto a erros de conformidade de padrão.
29. Finalmente, teremos uma tarefa especial para formulários de parâmetros; para
garantir que pelo menos existe um registro, clique no nó Métodos e escolha Override|
init.
30. Crie uma linha em branco antes da chamada para super() e digite a seguinte linha
de código:
ConWHSVehicleParameters::Find();
31. Salve e feche o editor de códigos e os designers de formulários.
Nota:
Quando especificamos o padrão principal do design do formulário, somos guiados
para os controles que deve adicionar e onde. Isso nos ajuda a garantir que os
formulários que criamos sigam uma prática recomendada design de interface do
usuário, que, por sua vez, torna nossos formulários mais fáceis de usar, mais rápidos
de treinar e menos propenso a erro do usuário. Ainda podemos desativar o padrão
usando o padrão Personalizado; isso nos permite adicionar qualquer controle em
qualquer ordem. Isso deve ser evitado, e o design do formulário deve ser
redesenhado que ele usa padrões padrão.
O formulário é baseado na classe FormRun. Podemos ver isso abrindo (clique duas
vezes) classDeclaration para o formulário CustGroup:
public class ConWHSVehicleParameters extends FormRun
Este é na verdade um arquivo de definição que o FormRun instancia para construir

e executar a forma. Uma vez que o sistema construiu o design do formulário usando
SysSetupFormRun, ele executará as tarefas de inicialização e execute o formulário.
Os principais métodos são Init e Run. Estes podem ser substituído no formulário
para executar tarefas adicionais de inicialização. Uma das principais tarefas do
método FormRunInit é construir as fontes de dados do formulário, estes não são
referências de tabela, mas objetos FormDataSource construídos a partir das
tabelas listadas sob o Nó Origens de dados. No caso do formulário
ConWHSVehicleParameters, o sistema cria o seguinte objeto da fonte de dados
ConWHSVehicleParameters para nós:
o ConWHSVehicleParameters as type ConWHSVehicleParameters(table)
o ConWHSVehicleParameters_DS as type FormDataSource
o ConWHSVehicleParameters_Q as type Query
o ConWHSVehicleParameters_QR as type QueryRun
Normalmente não estamos preocupados com os objetos Query e QueryRun, pois
podemos acessá-los através do objeto FormDataSource de qualquer maneira.
53
As fontes de dados são declaradas como variáveis globais para o formulário e
fornecem uma camada de funcionalidade entre o formulário e a tabela. Isso nos
permite controlar a interação entre os controles de formulário vinculados e a tabela.
Vamos sobrescrever o método init na fonte de dados e, em seguida, substituir o
modifiedField evento em um campo; o editor de código apresentará a alteração da
seguinte maneira:
[Form]
public class ConWHSVehicleParameters extends FormRun
{
public void init()
{
ConWHSVehicleParameters::Find();
super();
}
[DataSource]
class ConWHSVehicleParameters
{
public void init()
{
super();
}
[DataField]
class DefaultVehicleGroupId
{
public void modified()
{
super();
}
}
}
}
Ele adiciona a fonte de dados como uma classe na declaração de classe do formulário
e, em seguida, adiciona o campo como uma classe dentro da classe de fonte de dados.
Este é o único local em Operações onde este ocorre. Se a classe de fonte de dados
fosse uma classe, ela teria que estender FormDataSource. O Os atributos Form,
DataSource e DataField são uma pista do que está acontecendo aqui. Como tudo
código executável compila para os tipos CLR, o compilador usa esses atributos para
criar os tipos reais. A estrutura é escrita como tal para nossa conveniência como uma
apresentação de código.
Vamos pegar o método modifiedField. Este é um evento que ocorre após o O evento
validateField retorna true. A chamada super() chama o método modifiedField da
tabela. método. Podemos nos perguntar por que a chamada para super () não tem
parâmetro. Isso acontece por trás as cenas, e é útil que isso seja tratado por nós. Esse
padrão é seguido pelos seguintes métodos:
54
DataSource method Calls table method
validateWrite validateWrite
write write (in turn, insert or update)
initValue initValue
validateDelete validateDelete
delete delete
DataField.validateField validateField(FieldId)
DataField.modifiedField modifedField(FieldId)
O initValue, validateField, modifiedField, validateWrite e os métodos

validateDelete são chamados apenas de eventos de formulário, o método de
gravação não chama validateWrite. A partir disso, podemos escolher onde colocar
nosso código, e essa decisão é muito importante. A regra a seguir é fazer as
alterações os mais altas possíveis: tabela, fonte de dados, e controle de formulário.
Tipos de link do Data Source de formulário:
O tipo de link da fonte de dados de formulário é uma propriedade da fonte de dados

do formulário. Podemos adicionar mais de uma tabela como fonte de dados ao
formulário. Essas fontes de dados devem ter a relação de nível de tabela, então, o
desenvolvedor não precisa trabalhar na parte de codificação para encontrar os
registros de relação. A tabela abaixo descreve cada tipo de relacionamento (Join):
Tipo de Join Relacionamento

Active O tipo de link ativo atualiza as origens de dados filho sem
qualquer atraso quando você seleciona o registro da tabela
pai. Quando você lida com mais registros, isso afetará o
desempenho do aplicativo.
Delay O tipo de link de origem de dados de formulário de atraso
também é o mesmo que o método ativo. O método de atraso
diferente não será atualizado imediatamente quando você
selecionar o registro pai. Ele atualizará a fonte de dados filha
quando você selecionar a tabela pai, a instrução de uso de pausa
do D365FO, antes de atualizar a fonte de dados filha.
Passive O tipo de link da fonte de dados de formulário passivo não
atualiza a fonte de dados filha automaticamente.
Inner Join O tipo de link da origem de dados do formulário de junção
interna exibe as linhas que correspondem à tabela pai e à tabela
filha. Por exemplo, se o pedido não tiver detalhes do pedido, o
pedido não será exibido.
Outer join O tipo de link da origem de dados do formulário de associação
externa retornará todos os registros pai e registros filhos
correspondentes. Ele retornará todas as linhas na tabela
pai. Aqui, o Pedido 4 não tem os registros filhos (detalhes do
pedido), mas está sendo preenchido na grade do pedido. É a
diferença entre junção interna e junção externa.
55
As linhas de correspondência de tipo de link de origem de dados
Exist join de formulário existentes correspondem à tabela pai. Ele se
comporta como inner join, mas o diferente é uma vez que a linha
pai é correspondida com os registros filhos, em seguida, para o
processo e atualiza na grade, o D365FO não considera quantos
registros na tabela filha para a linha pai.
Não existe o tipo de link da fonte de dados do formulário de
Not exist join junção é um método totalmente oposto a existir. Ele retornará
os registros pai não correspondentes com registros filhos.
Criando itens de menu (menuitem)

Itens de menu são uma referência a um objeto que desejamos adicionar a um menu.
Nós temos três tipos de itens de menu: exibição, saída e ação. A exibição é usada para
adicionar formulários. A saída é usada para relatórios, e Action é usado para classes.
Itens de menu também são adicionados como privilégios ao sistema de segurança.
Usuários que não são o administrador não poderão ver os itens de menu, a menos
que tenham uma função, dever ou privilégio que lhes dá acesso ao nível de acesso
necessário do item de menu.
Só precisaremos de um formulário, relatório ou classe para a qual precisamos criar
o item de menu.
1. Escolha para adicionar um novo item ao projeto.
2. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito painel.
3. Nomeie o item de menu como o mesmo formulário; nesse caso,
ConWHSVehicleParameters.
4. Digite o rótulo @ SYS7764 como a propriedade Label; este é o menor rótulo @SYS
que não tem contexto específico descrito.
5. Crie um rótulo de texto de ajuda para manter as configurações de gerenciamento
do veículo e seqüências numéricas. Atribuir o ID à propriedade HelpText.
6. Digite ConWHSVehicleParameters na propriedade Object.
7. A propriedade ObjectType é Form por padrão, portanto, isso está correto.
8. Salve o item de menu e abra a tabela ConWHSVehicleParameters e, em seguida,
insira ConWHSVehicleParameters na propriedade Form Ref.
9. Por fim, abra o menu ConWHSVehicleManagement e arraste
oConWHSVehicleParameters, item de menu na parte superior do nó Configuração.
10. Salve e feche as guias abertas.
56
Embora esta atividade esteja listada isoladamente, ela deve sempre ser feita como
parte do processo.
Por exemplo, o processo de criação de uma tabela de parâmetros envolve quatro
etapas principais:
1. Crie a tabela
2. Crie o formulário
3. Crie o item de menu
4. Adicione o item de menu ao menu
Quase todas as tabelas que criamos em Operações terão um formulário usado para
mantê-lo. Então, a última parte do design da tabela é dizer ao design da tabela qual
formulário é utilizado para esse fim. É assim que a opção visualizar detalhes
funciona no cliente. A chave estrangeira é usada para determinar a tabela, e a
propriedade Form Ref da tabela é usada para determinar o formulário a ser usado.
Os detalhes da chave estrangeira são usados para filtrar o formulário. Todos isso
acontece automaticamente com base nos metadados. Itens de menu para
formulários e relatórios acionam o sistema para criar e executar o formulário ou
relatório definição. O formulário é renderizado no navegador usando um JavaScript
muito inteligente que interfaces com o servidor, e os relatórios são essencialmente
renderizados usando o SSRS. As classes devem tem um método de ponto de entrada
estático para ser chamado.
Criando formulários de configuração

Seguiremos o mesmo padrão do formulário de Parâmetros. Usando tabelas,
Estrutura de Dados Estruturas. Padrões de grade. Nossa tabela tem dois campos,
então usaremos o design do formulário de lista Simples padrão. Isso segue o padrão
de criação de uma tabela do tipo Group.
Siga os passos abaixo:
2. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito painel.
3. Nomeie o formulário conforme o nome da tabela; nesse caso,
ConWHSVehicleGroup.
4. Arraste a tabela ConWHSVehicleGroup do projeto para as origens de dados
nó do designer de formulários.
5. Use o mesmo rótulo como a tabela para a propriedade Caption do nó Design.
6. Defina as propriedades Source Data Source e Data Sources para o nome da tabela,
ConWHSVehicleGroup.
57
7. Aplique o padrão Simple List ao Design (clique com o botão direito e escolha Apply
Pattern | Lista Simples).
8. Adicione um controle ActionPane; renomear para FormActionPaneControl como
haverá apenas seja um neste formulário.
9. Selecione novamente o nó Design. O padrão destaca que precisamos de um filtro
personalizado Grupo, que é um controle de grupo. Então, adicione um novo controle
do tipo Group.
10. Renomeie o controle para CustomFilterGroup, para facilitar a referência.
11. Podemos ver que o novo controle de grupo precisa de um padrão; atribuir
personalizado e rápido Filtros
12. Agora teremos mais a fazer para esse controle. O padrão destaca que nós
devemos ter um QuickFilterControl. Clique com o botão direito no
CustomFilterGroup controle e escolha Novo | QuickFilterControl.
13. Clique com o botão direito do mouse no nó Design e selecione Novo | Grade.
14. Podemos renomear o controle para FormGridControl, pois haverá apenas uma
grade controle com este padrão.
15. A propriedade Data Source não herda do nó pai, e devemos especifique isso como
ConWHSVehicleGroup.
16. Criamos um grupo de campos Visão Geral para esta tabela, portanto, defina o
Grupo de Dados propriedade para Visão geral.
17. Volte para o controle QuickFilter e defina Target Control para o controle de grade
nome e Coluna Padrão para o controle padrão desejado do controle de destino.
18. Verifique novamente se há erros no painel de padrões e salve o formulário.
19. Em seguida, crie um item de menu usando o mesmo nome do formulário e o
mesmo rótulo nós usamos na propriedade Caption.
20. Preencha a propriedade Form Ref da tabela com o nome do item de menu.
21. Por fim, adicione o item de menu ao menu de configuração para que ele fique sob
os Parâmetros item do menu.
Nota:
As etapas foram semelhantes à forma de parâmetro, embora houvesse apenas mais
algumas para completo. Podemos ver que o padrão é na verdade uma lista de tarefas,
embora erros de padrão impedir que o projeto seja construído.
58
Se você quiser realmente testar o formulário, você pode fazer isso seguindo estas
etapas:
1. Crie o pacote usando o Dynamics 365 FO | Construa Modelos, selecione o
pacote de a lista.
2. Se adicionarmos tabelas ou campos desde a última sincronização do banco
de dados, sincronize os bancos de dados clicando com o botão direito do
mouse no projeto e escolhendo sincronizar <seu nome do projeto> com
banco de dados.
3. Abra as propriedades do projeto.
4. Defina a opção Tipo de objeto de inicialização como MenuItemDisplay.
5. Defina a opção Startup Object para o item de menu a ser aberto, por exemplo,
ConWHSVehicleGroup.
6. Especifique a empresa inicial; A USMF é uma empresa útil para quando
estamos usando a VM de desenvolvedor que usam os dados de demonstração
da Microsoft.
7. Feche o formulário de propriedades e pressione F5.
Também é assim que depuramos o código, e se um ponto de interrupção for
encontrado, o Visual Studio interromperá o processamento nos permitindo
analisar o ponto a ponto.
Criando detalhes mestre (tabela principal)

Para aqueles que estão acostumados ao Dynamics AX 2012, esse estilo de
formulário substitui a página Lista e separa o formulário Detalhes usado para
tabelas principais, como Produtos e Clientes. Lista as páginas são efetivamente
obsoletas para essa finalidade. Pode parecer um pouco confuso no início, como
Estamos desenvolvendo duas visões de um formulário ao mesmo tempo. No
entanto, uma vez que tenhamos feito isso algumas vezes, torna-se mais
automático.
O painel de padrões será o nosso guia nesta receita, ajudando-nos a simplificar o
processo e lembrando-nos quando nos esquecemos de um passo fundamental.
Estamos continuando o design do formulário para a tabela principal,
ConWHSVehicleTable. No entanto, esta receita pode ser usada como um padrão
para qualquer tabela principal.
Para criar o formulário principal de detalhes, siga estas etapas:

2. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito
painel.
59
3. Nomeie o formulário conforme o nome da tabela; nesse caso,
ConWHSVehicleTable.
4. Arraste a tabela ConWHSVehicleTable do projeto para as origens de dados
nó do designer de formulários.
5. Selecione o Data Source ConWHSVehicleServiceTable e defina a
propriedades Insert If Empty e Insert At End para No.
6. Use o mesmo rótulo como a tabela para a propriedade Caption do nó Design.
7. Defina as propriedades Source Data Source e Data Sources para o nome da
tabela, ConWHSVehicleTable.
8. Aplique o padrão Details Master ao Design.
9. Conforme exigido pelo padrão, adicione um controle do Painel de Ação
chamado FormActionPane.
10. Adicione um controle de grupo chamado NavigationListGroup. Esta seção é
usada na visualização de detalhes para que o usuário possa alterar os
registros sem voltar para a lista Visão.
11. Sob o controle NavigationListGroup, crie um controle de Filtro Rápido e
nomeie-o como NavgationQuickFilter.
12. Em seguida, crie um controle de grade chamado NavigationGrid.
13. Defina a propriedade Data Source do controle de grade como
ConWHSVehicleTable e adicione os campos VehicleId e Description
arrastando-os dos campos nó da fonte de dados.
14. Complete o controle de filtro rápido com Target Control como controle de
grade e coluna Padrão conforme desejado.
15. Verificando os nós no e sob o nó Design, agora precisaremos criar um
Controle de tabulação para a guia Painel. Crie um controle de tabulação da
seguinte maneira:
Propriedade Valor
Name PanelTab
Arrange Method Vertical
16. Adicione uma ficha de registro chamada DetailsPanelTabPage primeiro e

depois ListPanelTabPage.
17. Vamos concluir o controle ListPanelTabPage primeiro. Conforme exigido
pelo padrão, sob esse controle, adicione um controle de grupo chamado
ListQuickFilterGroup e um Controle de grade chamado ListGrid.
18. Preencha a propriedade Data Source do controle de grade e use o campo
Visão geral grupo para a propriedade Grupo de Dados.
19. Vamos completar ListQuickFilterGroup da mesma forma que fizemos para o
padrão de lista simples. Aplique o padrão Personalizado e Filtros rápidos ao
ao controle. Em seguida, adicione um controle de Filtro rápido e nomeie-o
como ListQuickFilter. Complete o controle referenciando-o ao controle de
grade chamado de ListGrid.
60
20. O padrão agora afirma que precisaremos da Ação Padrão da Rede Principal,
que é um Controle de botão de comando. Adicionar botão de comando ao
ListPanelTabPage, definindo as propriedades, conforme mostrado na tabela
a seguir:
Propriedade Valor
Name ListGridDefaultButton
Command DetailsView
21. No controle ListGrid, insira ListGridDefaultButton como Default Action

property.
22. Passando para o elemento padrão Details Panel, selecione novamente
DetailsPanelTabControle de página e adicione um controle de grupo
chamado DetailsTitleGroup.
23. Adicione um controle de seqüência de caracteres para os títulos de
cabeçalho, conforme mostrado aqui:
Propriedade Valor
Name DetailsHeaderTitle
Data Source ConWHSVehicleTable
Data Method TitleFields
View Edit Mode View
Skip Yes
24. Verificando nosso progresso no painel padrão, veremos que precisamos

adicionar o elemento padrão da guia Detalhes (TAB). Adicione um novo
controle Tab ao Controle da página da guia DetailPanelTabPage, definindo as
propriedades da seguinte maneira:
Propriedade Valor
Name DetailsTab
25. Adicione um novo nome de página de aba DetailsTabGeneral e aplique os

campos e campo Padrão de grupos.
A primeira ficha de registro é geralmente uma ficha de registro rotulada como

Geral.
26. Nesse caso, podemos simplesmente arrastar o grupo de campos Detalhes da

Fonte de dados ConWHSVehicleTable, mas sinta-se à vontade para
reorganizar os campos grupos mais apropriados.
27. Vamos precisar criar o item de menu usando o mesmo rótulo da tabela, mas
nós precisaremos usar a opção de visualização de formulário como Grade
para que possamos obter a visualização de lista quando o formulário é
aberto.
61
28. Em seguida, preencha a propriedade FormRef da tabela
ConWHVehicleTable.
29. Finalmente, adicione o item de menu ao nosso menu.
O conceito é o mesmo de qualquer forma, só temos mais recursos. A parte

peculiar de esta forma é que temos duas visões - uma para a visualização de lista
e outra para editar ou visualizar detalhes do formulário.
Criando uma transação de detalhes (formato de entrada de pedido)
Esses formulários de planilhas ou GRID são os mais complicados em termos das

etapas necessárias, como agora tem três estados para projetar: exibições de lista,
cabeçalho e linhas. Para se familiarizar com o resultado, abra e use o formulário
Todas as ordens de compra de Contas a Pagar | Compra encomendas | Todos os
pedidos de compra.
A primeira parte do padrão é muito semelhante ao padrão mestre de detalhes,
então vamos resumir um pouco. Continuaremos a tabela de pedidos de serviço
do veículo, mas, novamente, a atividade é escrita para que possa ser aplicado a
qualquer tabela de planilha ou GRID.
Para criar o formulário, siga estas etapas:

2. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito do
painel.
3. Nomeie o formulário conforme o nome da tabela, nesse caso,
ConWHSVehicleServiceTable.
4. Arraste a tabela ConWHSVehicleServiceTable do projeto para o Data Nó de
origens do designer de formulário.
5. Selecione a fonte de dados ConWHSVehicleServiceTable e defina as
propriedades Insert e Insert if Empty para NO.
6. Arraste a tabela ConWHSVehicleServiceLine para o nó Origens de dados.
7. Selecione a fonte de dados ConWHSVehicleServiceLine e defina a Origem da
associação. propriedade para ConWHSVehicleServiceTable.
8. Substitua o método initValue no ConWHSVehicleServiceLine para que pode
definir o campo ServiceId, pois isso não está definido para nós. Use o seguinte
código:
public void initValue()

{
super();
ConWHSVehicleServiceLine.ServiceId =
ConWHSVehicleServiceTable.ServiceId;
}
9. Feche o editor de código e volte para a guia design criada.
10. Defina as propriedades da seguinte forma:
62
Propriedade Valor
Caption Use the label from the table
Data Source ConWHSVehicleServiceTable
Title Data Source ConWHSVehicleServiceTable
11. Aplique o padrão Transação de Detalhes ao nó Design.
12. Adicione um controle de painel de ação chamado HeaderActionPane e, em
seguida, um grupo controle chamado NavigationListGroup sob o nó Design.
13. Adicione um controle de Filtro Rápido ao controle NavigationListGroup
chamado NavgationQuickFilter.
14. Em seguida, crie um controle de grade chamado NavigationGrid.
15. Defina a propriedade Data Source do controle de grade para
ConWHSVehicleServiceTable e adicione o ServiceId e Descrição campos da
fonte de dados ConWHSVehicleServiceTable.
16. Complete o controle de filtro rápido com Target Control como controle de
grade e Coluna Padrão conforme desejado.
17. Sob o nó Design, crie um controle Tab para a guia Painel. Crie uma nova guia
controle e nomeie-o MainTab. Defina Organizar Propriedade como vertical.
18. Adicione uma ficha de registro chamada DetailsPanelTabPage primeiro e
depois GridPanelTabPage.
19. Nós completaremos o controle GridPanelTabPage primeiro. Sob esse
controle, adicione um Controle de grupo chamado
GridPanelQuickFilterGroup e um controle de grade chamado ListGrid.
20. Preencha a propriedade Data Source do controle de grade e use o campo
Visão geral grupo para a propriedade Grupo de Dados.
21. Para GridPanelQuickFilterGroup, aplique os Filtros Personalizados e Rápidos
padrão para o controle. Em seguida, adicione um controle de Filtro rápido e
nomeie-o ListQuickFilter. Complete o controle referenciando-o ao controle
de grade que nós chamado ListGrid.
22. O padrão agora afirma que precisamos da ação padrão da grade principal,
que é um comando Controle de botão. Adicionar botão de comando ao
GridPanelTabPage chamado MainGridDefaultAction.
23. Defina a propriedade Command como DetailsView.
24. No controle MainGrid, insira MainGridDefaultAction para a ação padrão
propriedade.
25. Para concluir o elemento padrão do Painel de Detalhes (TabPage), selecione
novamente o DetailsPanelTabControle de página e adicione um controle de
grupo chamado DetailsPanelTitleGroup.
26. Adicione um controle String, definindo as propriedades da seguinte maneira:
Propriedade Valor
Name DetailsPanelHeaderTitle
Data Source ConWHSVehicleServiceLine
Data Method titleFields
View Edit Mode View
Skip Yes
27. Agora precisaremos completar o padrão Header and Line Panels (Tab)
elemento. Adicione um novo controle Tab ao DetailPanelTabPage, da
seguinte maneira:
63
Propriedade Valor
Name HeaderAndLinePanelTab
Arrange Method Vertial
28. Adicione uma nova aba para o Painel de Linhas usando as seguintes
propriedades:
Propriedade Valor
Name LinesPanelTabPage
Style DetailsFormDetails
29. Adicione um segundo controle de página de guia, mostrado da seguinte

maneira: HeaderPanelTabPage.
Propriedade Valor
Name HeaderPanelTabPage
Style DetailsFormDetails
30. Adicione um novo controle Tab ao controle LinePanelTabPage chamado

LineViewTab.
31. Vamos agora adicionar três fichas de registro a este controle.
32. Adicione o elemento de padrão Line View Header Details (TabPage) usando
as seguintes propriedades:
Propriedade Valor
Name LineViewHeaderTabPage
Label Vehicle service order header
Pattern Apply the Field and Field Groups
pattern
33. Adicione o elemento padrão Line View Lines (TabPage) usando as seguintes
propriedades:
Propriedade Valor
Name LineViewLines
Label SYS9664
34. Adicione o elemento de padrão Line View Line Details (TabPage) usando as
Propriedade Valor
Name LineViewLineDetailsTabPage
Label Vehicle Service order lines
35. Adicione um controle de painel de ação ao controle LineViewLinesTabPage

chamado LinesActionPane e, abaixo disso, um controle da guia Painel de
Ações chamado LineActionRecordActions.
64
36. Clique com o botão direito do mouse no novo controle
LineActionRecordActions e selecione o Controle de grupo de botões sob este
chamado LineActionRecordActionsGroup.
37. Sob o grupo de botões LineActionRecordActionsGroup, adicione um
comando botão chamado LineActionAddLine.
38. Isso é para permitir que o usuário adicione linhas à grade de linhas. Defina as

Normal Image Delete Adiciona um símbolo de lixeira
Label @SYS135131 Remove
Command New Dispara a nova tarefa de registro para o
Data Source
39. Em seguida, adicione um segundo botão de comando chamado

LineActionRemove, definindo propriedades da seguinte forma:

Normal Image Add This adds a simple plus symbol
Label @SYS319116 Add line
Command DeleteRecord Dispara a tarefa de registro de exclusão
Save Record NO Permitir que registros que ainda não
foram salvos sejam deletado
40. Sob este grupo de botões, precisaremos de uma grade para as linhas.
Adicionar uma nova grade controle, definindo as seguintes propriedades:
Propriedade Valor
Name LinesGrid
Data Source @ConWHSVehicleServiceLine
Data Group Overview
41. Crie um controle de tabulação em LineViewLineDetailsTabPage e defina

Propriedade Valor
Name LineViewDetailsTab
Label @SYS23823
42. Adicionaríamos uma ou mais fichas, mas, no nosso caso, precisaríamos

apenas de uma.
43. Adicione um controle de página de guia chamado LineViewDetailsTabDetails
e defina a propriedade Label para @ConWHS: Details.
44. Arraste Identificação e Detalhes do Data Source
ConWHSVehicleServiceLines.
65
45. Agora, precisaremos concluir a visualização do cabeçalho do formulário, que
é regido por o elemento padrão do painel de cabeçalho. Clique com o botão
direito em HeaderPanelTabPage e escolha Novo | Tab e complete da seguinte
forma:
Propriedade Valor
Name HeaderDetailsTab
Data Source ConWHSVehicleServiceTable
46. Normalmente teríamos muitos grupos de campo para adicionar, mas, neste
caso, apenas preciso de um. Crie um novo controle de página de guia
chamado HeaderDetailsTabDetails. Defina a propriedade Caption como
@ConWHS: Details.
47. Arraste os grupos de campos Details e ServiceDates do campo Fonte de dados
ConWHSVehicleServiceTable, mas renomeie-os, prefixados com
HeaderDetailsTabDetails.
48. Vamos precisar criar o item de menu usando o mesmo rótulo da tabela, mas
nós precisaremos usar a opção de visualização de formulário como Grade
para que possamos obter a visualização de lista quando o formulário é
aberto.
49. Em seguida, preencha a propriedade FormRef do
ConWHVehicleServiceTable mesa.
50. Finalmente, adicione o item de menu ao nosso menu.
O processo, embora estendido, é o mesmo que o padrão Mestre de Detalhes. Há

algumas propriedades adicionais para definir nesse caso para ajudar com o
comportamento do formulário. Há muitos passos, e é fácil se perder e
potencialmente definir a propriedade errada. É por isso que nomeamos os
controles após o nome do elemento padrão. Este padrão de forma foi
deliberadamente tão simples quanto possível, e uma vez que estamos
confortáveis com o processo, deve ser simples expandir isso para dados mais
complicados estruturas.
66
Criando um arquivo de etiqueta (Label)
A maioria dos projetos tem algum tipo de interface de usuário e, portanto,

precisamos exibir o texto no usuário diferente dos nomes de campo. O método
de melhor prática para fazer isso é usar um arquivo de rótulo. O arquivo de
etiqueta contém um dicionário específico de idioma de IDs de rótulo e a
tradução. Os elementos padrão tendem a ter os IDs de legenda herdados de um
símbolo @, seguido por um trio de caracteres ID da etiqueta e um número. Este
formato funcionou bem nos últimos 15 anos, mas o prefixo foi potencialmente
limitante, especialmente para ajudar ISVs. Os rótulos não estão mais restritos a
três dígitos, o que ajuda a Microsoft a atingir um de seus objetivos de tornar os
complementos de ISV mais fáceis de escrever, manter e adotar.
A escolha de quantos e quais pacotes precisam de um arquivo de rótulo depende
de a solução desenhar.
Não é uma ideia terrível para uma solução de cliente usuário final ter um pacote
apenas para rótulos que são reutilizados por cada pacote. Isso significa que
corremos o risco de usar um rótulo contexto. Você pode optar por usar um rótulo
padrão para Nome no registro pessoal, somente para o rótulo a ser alterado pelo
desenvolvedor original para algo específico ao contexto original, por exemplo,
nome do produto.
Nós tendemos a criar um arquivo de etiqueta para cada pacote, pois isso garante
que o pacote possa corrigir e altere os rótulos sem se preocupar com a regressão
em outros Modelos.
Para começar, abra o Visual Studio e o projeto em questão. No nosso caso,

continuaremos com o projeto ConWHSGeneralExtensions.
Para criar o arquivo de etiqueta, siga estas etapas:
1. Clique com o botão direito do mouse no projeto e selecione Adicionar | Novo

item ... ou use o teclado atalho, Ctrl + Shift + A.
2. Escolha Rótulos e Recursos na lista de Artefatos de Operações.
3. Na lista à esquerda, selecione Arquivo de Rótulo.
4. No campo Nome, insira um nome de rótulo curto, mas único, no nosso caso
ConWHS. Queremos que seja o mais curto possível, mas esteja
completamente certo de que será globalmente único, independentemente de
qualquer futuro add-on, podemos optar por instalar.
5. Pressione Adicionar.
6. No assistente de arquivo Label, deixe o ID do arquivo Label como padrão.
7. Pressione Próximo.
8. Na seleção de idioma, mova os idiomas da lista à esquerda para a lista à
direita usando os botões. Apenas deixe os idiomas selecionados que você irá
manter. Isso envolve a criação de um rótulo em cada arquivo de idioma.
9. Pressione Próximo.
10. Verifique se a página Resumo está correta e pressione Concluir.
67
A criação é direta. O processo cria um arquivo de texto no disco que contém um
lista separada por tabulações de IDs e traduções de rótulos.
Quando um rótulo é selecionado em relação a um controle, ele receberá um ID
de arquivo de rótulo que garante que ele seja único. Em nosso exemplo, o ID do
arquivo de etiqueta era ConWHS. Quando criamos um rótulo, ele será dado os
IDs na sequência @ConWHS: ConWHS1, @ConWHS: ConWHS2 e assim por
diante.
Em nosso exemplo, os IDs de rótulo fornecidos ao controle serão @ConWHS:
ConWHS1. Isto parece desnecessariamente longo. Como, na verdade, podemos
especificar o ID do rótulo manualmente, podemos optar por inserir um ID menor
por rótulo, gerando um rótulo como @ConWHS: L001, ou digite um memorável
nome como um ID, onde o ID se tornaria @ConWHS: ItemNotExists.
Nota:
Para projetos em andamento deve-se seguir a mesma regra de extensibilidade

do D365FO.
68
Segurança
 Criar privilégios
 Criar deveres
 Criar funções de segurança
 Criar Políticas
Ao projetar o modelo de segurança, existem três métodos, dependendo da solução.

Para Soluções ISV, a segurança deve ser projetada no pacote principal e enviados
juntos.
Isso também vale para soluções de parceiros para novas implementações de clientes
quando o pacote é um pacote discreto de funcionalidade. Às vezes, os clientes
precisam de papéis personalizados para suas próprias necessidades, e essas funções
podem abranger privilégios tanto para os novos como para as funcionalidades.
Neste caso, um novo pacote deve ser desenvolvido. Ter um pacote separado também
ajuda na eficiência do planejamento de trabalho.
Se o cliente usuário final desenvolver seu próprio modelo de segurança, isso deve
sempre novo pacote; embora, a mesma funcionalidade possa ser obtida dentro do
aplicativo.
O modelo de segurança no D365FO é dividido na seguinte estrutura:

 Papéis (Roles)
 Deveres (Duties)
 Privilégios (Privileges)
 Políticas (Polices)
A estrutura principal do modelo de segurança inclui Ciclos de processo, Funções,

Tarefas e Privilégios Vamos explorá-las primeiro antes de dar uma olhada em
Políticas e Permissões de Código.
Os pontos de entrada definem o nível de acesso concedido aos métodos de entrada
nas funcionalidades D365FO, como itens de menu e serviços.
As permissões definem o acesso a tabelas e campos, métodos de servidor (como uma
chamada de serviço o código não será executado no contexto de segurança do
usuário) e controles de formulário (botões, campos ou outros controles colocados
em um formulário).
Como parte da definição dos requisitos funcionais, os processos de negócios são
analisados, junto com os papéis que os executam. Os processos de negócios serão
então mapeados para o Processos do sistema de operações. Isso é usado para muitos
propósitos, incluindo o nível de ajuste de lacuna, planos de treinamento, planos de
teste e assim por diante. Este método de analisar papéis e processos também se
encaixa perfeitamente no modelo de segurança de Operações, permitindo que o
modelo de segurança seja projetado com base nisso.
O modelo de segurança que projetamos e implementamos deve ser sempre simples
de usar, seguindo o padrão das funções padrão fornecidas pela Microsoft. Um
projeto importante princípio é pensar nos papéis do usuário, e não pensar em
usuários específicos.
69
Com isso se deve resultar nos seguintes resultados:
 Número reduzido de papéis

 Atribuição menos complicada de usuários a funções
 Os papéis são mais fáceis de manter, com risco reduzido de erros, como o uso
não intencional
 atribuição de um privilégio a um usuário
Criando privilégios (Privileges)
Privilégios normalmente são criados para cada item de menu (exibição, saída ou
ação) para um acesso nível. Cada item de menu deve estar em um privilégio, mas
você pode adicionar mais de um item de menu a um privilégio se nunca devem
receber permissões diferentes, como itens de menu que aponte para o mesmo
formulário. Este é o nível mais granular, e será agrupado em deveres e papéis mais
tarde.
Como o privilégio atribui o nível de acesso, normalmente temos dois - para fornecer
apenas a visualização, e manter direitos de acesso (completos).
Vamos apenas precisar de um projeto D365FO aberto no Visual Studio.
Para criar um privilégio para fornecer acesso de exibição ao formulário do veículo,

siga estas etapas:

2. Na caixa de diálogo Adicionar novo item, selecione Segurança na lista à esquerda
e Segurança Privilégio da direita.
3. Digite ConWHSVehicleTableView no campo Nome e clique em Adicionar.
4. Preencha a propriedade Descrição; isso deve descrever para a segurança
administrador a que este privilégio concede acesso.
5. Preencha a propriedade Rótulo dando uma breve descrição para a segurança
administrador, como Exibir registros do veículo.
6. No designer, arraste o item de menu ConWHSVehicleTable para os Pontos de
Entrada do nó.
7. Altere propriedade de nível de acesso do ponto de entrada para leitura.
8. Para criar o privilégio para manter a tabela de veículos, crie um novo privilégio
chamado ConWHSVehicleTableMaintain.
9. Preencha a propriedade Descrição.
10. Preencha a propriedade Label. Por exemplo, mantenha registros do veículo.
11. No designer, arraste o item de menu ConWHSVehicleTable para os pontos de
entrada do nó.
12. Altere a propriedade Nível de Acesso do ponto de entrada para Excluir.
13. O formulário deve ter quaisquer entidades de dados associadas, como aquelas
que nos permitem editar os dados do formulário no Excel, eles também devem
ser adicionados ao privilégio sob o Nó Permissões de Entidade de Dados com o
nível de acesso apropriado.
Os privilégios são simplesmente uma forma de conceder permissões a um ponto de
entrada, que pode ser serviços, para um dever, função ou mesmo diretamente para
70
um usuário. Normalmente, adicionamos apenas pontos de entrada a um privilégio,
como itens de menu. Para conceder acesso ao usuário, o sistema aplica o nível de
acesso para formar controles e fontes de dados. Quando definimos a permissão
necessária propriedade em controles de formulário, pode ter o efeito de ocultar o
controle se o privilégio não conceder a permissão necessária.
Como não podemos estender os privilégios de segurança, sempre criamos um
privilégio. Isto é não é uma restrição real e ajuda a impor boas práticas; nós não
podemos ficar mais granular do que um privilégio, em termos de atribuir
permissões a um usuário. Nunca devemos sobrepor (personalizar) um privilégio de
segurança existente, já que não há necessidade de tarefas e funções extensível.
Criando deveres (Duties)
Um dever é uma coleção de um ou mais privilégios. O paradigma é que estamos

criando uma lista funções que a função desempenhará e, portanto, adicionar o
privilégio necessário para que o papel de ser capaz de executar esse dever.
É comum ter apenas um privilégio em um dever, mas mais pode ser adicionado, por
exemplo, os formulários configurados podem ser adicionados a um dever.
Os nomes de serviço são sufixados com um verbo para denotar a ação que o dever
permitirá ao papel executar; sufixos comuns são Manter, Consultar e Aprovar. Para
determinar o corrija o sufixo, observe os deveres padrão e sufixe seus deveres
usando a mesma nomenclatura convenção.
Para criar um dever, siga estes passos:

2. Na caixa de diálogo Adicionar novo item, selecione Segurança na lista à esquerda e
Segurança Dever da direita.
3. Digite ConWHSVehicleTableInquire no campo Nome e clique em Adicionar.
administrador o que este dever faz, como "Responde a perguntas no veículo
registros ".
5. Preencha a propriedade Rótulo, fornecendo uma breve descrição da segurança
1. administrador, como Informe-se nos registros do veículo.
6. No designer, arraste o privilégio de segurança ConWHSVehicleTableView para o
Nó de privilégios.
7. Repita isto para todas as tarefas exigidas, por exemplo,
ConWHSVehicleTableMaintain duty que terá o ConWHSVehicleTableMaintain
privilégio.
Você pode considerar que um dever é uma coleção de privilégios de segurança, o

que é, contudo, ao projetar o modelo de segurança, faríamos isso ao contrário -
projetamos o com os deveres requeridos e, em seguida, adicione o privilégio de
segurança necessário para dever.
71
Criando funções de segurança (Roles)
Um papel é uma coleção de deveres e privilégios. O papel é o que associamos a um

usuário, que pode ser feito automaticamente com base nas informações do
funcionário, como posição na empresa. As funções de segurança devem ser pensadas
em termos das pessoas que apareceu pela primeira vez com o Dynamics AX 2012. A
mudança destina-se a mover o pensamento longe de criar grupos de funcionalidade
para projetar os papéis com base em como a organização é estruturada. Por
exemplo, um gerente de vendas estaria em uma função de gerente de vendas, que
terá deveres atribuídos. As funções têm privilégios, que por sua vez dão acesso ao
gerente de vendas para desempenhar esse papel.
No nosso caso, poderíamos considerar que eles têm três funções: supervisor de
gerenciamento de veículos, supervisor de serviço de veículo e funcionário de
entrada de serviço de veículo. Ao definir as funções, fazemos assim, definindo os
deveres que cada papel terá. A convenção de nomenclatura é semelhante a outra
objetos e sufixados com o tipo de função. Estes tipos incluem Supervisor, Gerente,
Clerk, ou outros, caso não se encaixem no papel requerido; por exemplo,
ConWHSVehicleManager teria os deveres de manutenção dos dados mestre do
veículo.
Podemos adicionar privilégios diretamente a uma função, mas devemos ser rígidos
e apenas adicionar tarefas diretamente para um papel. Isso ajuda na manutenção e,
além disso, é uma boa prática verificar se todos os privilégios em um ou mais
deveres, e todos os deveres devem estar em um ou mais papéis. Também podemos
adicionar funções como sub-função. Isso pode ajudar em casos raros, mas,
novamente, tente evitar isso. Isso torna a manutenção um pouco mais restritiva para
o gerente de segurança. Eles podem querer conceder ou restringir o acesso à sub-
função sem alterar os direitos da função pai.
Para criar uma função, siga estas etapas:

2. Na caixa de diálogo Adicionar novo item, selecione Segurança na lista à esquerda
e Segurança Papel da direita.
3. Digite ConWHSVehicleManager no campo Nome e clique em Adicionar.
Administrador o que esse dever faz, como dados mestre do veículo dos
Gerentes.
5. Preencha a propriedade Rótulo dando uma breve descrição para a segurança
administrador, como Responsável pela manutenção do veículo registros e dados
de configuração associados.
6. No designer, arraste as tarefas que fornecem direitos completos para o veículo
e configure itens de menu no nó Tarefas.
7. Repita isso para todas as funções necessárias.
Tecnicamente, isso é simples. A parte complicada é projetar o modelo de segurança

com o cliente, a fim de ter uma visão comum de segurança de um recurso humano
perspectiva. Quando as funções de segurança são sincronizadas com a hierarquia
organizacional, a segurança se torna mais um processo de gerenciamento de
recursos humanos do que um administrador de TI.
72
Criando Políticas (Policies)
O termo "Políticas de segurança" é um ligeiro erro. Também é conhecido sob um

mais preciso prazo da Extensible Data Security (XDS). É uma evolução da segurança
de nível recorde que foi depreciado do AX 2012: você ainda pode fazer isso, mas não
era uma abordagem recomendada.
Neste cenário, vamos criar uma política que permita apenas o acesso a veículos do
tipo caminhão. Em Nesse cenário, temos uma equipe que só tem acesso a caminhões
ao criar ordens de serviço.
Para criar uma função, siga estas etapas:

2. Na caixa de diálogo Add New Item, selecione Data Model na lista à esquerda e
Consulta da direita.
3. Digite ConWHSVehicleTruckPolicy no campo Nome e clique em Adicionar.
4. Em nossa nova consulta, arraste a tabela ConWHSVehicleTable para os nodes
dos Data Sources.
5. Adicione o campo VehicleType à lista Fields clicando com o botão direito do
mouse no nó Fields e escolhendo Novo | Campo.
6. Arraste o campo para o nó Intervalos.
7. No novo intervalo VehicleType, altere a propriedade Value para Truck.
8. Salve e feche o designer de consulta.
9. Adicione um novo item ao projeto.
11. Na caixa de diálogo Add New Item, selecione Security na lista à esquerda e
Security Política da direita.
12. Digite ConWHSVehicleTruckPolicy no campo Nome e clique em Adicionar.
13. Defina o rótulo para a política de acesso à tabela do veículo do funcionário da
gerência do veículo.
14. Defina Texto de Ajuda para Restringir o acesso à tabela do veículo para que
apenas caminhões podem ser selecionados.
15. Defina Tabela Primária para ConWHSVehicleTable. Isso informa ao Operations o
nome de tabela principal na propriedade Query.
16. Digite ConWHSVehicleTruckPolicy na propriedade Query.
17. Deixar Use Não Existir Como Núm. Caso contrário, isso teria o efeito de fazer
18. a política permite apenas veículos inativos. Defina Tabela restrita como Sim.
Deixe a operação como Select; estamos pretendendo que esta política entre em
vigor ao selecionar registros.
19. Usando o guia Criar papéis de segurança, crie uma função para um funcionário de
entrada de serviço do Caminhão chamado ConWHSVehicleTruckServiceClerk.
20. Defina o Tipo de Contexto como RoleName e insira
ConWHSVehicleTruckServiceClerk na propriedade Nome da Função.
21. Por fim, defina a propriedade Enabled como Yes.
Quando o usuário na função da política abre um formulário ou quando uma lista

suspensa é exibida, o sistema criará uma consulta que combina a fonte de dados do
formulário com a consulta da política definição como Existente ou Não Existente. A
consulta não pode ser alterada pelo usuário e é aplicado no nível do kernel.
73

Apostila DEV 365FO

Enviado por

Direitos autorais:

Formatos disponíveis

Apostila DEV 365FO

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila DEV 365FO

Enviado por

Direitos autorais:

Formatos disponíveis

Introdução ao desenvolvimento e personalização.

Diferenciando nuvem de arquitetura local................................................................................4

Ferramentas de desenvolvimento no Visual Studio..............................................................5

Elementos, modelos e pacotes........................................................................................................9

Formulários do tipo Dialogs.........................................................................................................16

Gerenciamento de Dados.(Entidade de dados, EDT, Enum, Tables)...........................25

Interface do Usuário (Menus, MenuItem, Forms, Label)..................................................46

O Dynamics AX agora é Dynamics 365 for Finance and Operations.

Planejamento de Recursos Empresariais ou planeamento de recurso corporativo é

Um entendimento da arquitetura subjacente do Dynamics 365 for Finance and

As implantações em nuvem oferecem um serviço totalmente gerenciado pela

Uma implantação em nuvem oferece vários benefícios, incluindo tempo de

As organizações que optam por implantar Finanças e Operações no local também

Quais são as ferramentas de desenvolvimento?

Uma alteração notável do Microsoft Dynamics AX 2012 é que o Microsoft Dynamics

O Visual Studio 2015 é o exclusivo ambiente de desenvolvimento integrado (IDE)

No Visual Studio, o armazenamento de modelo é representado pelo Explorador de

A ilustração a seguir mostra o Explorador de Aplicativos.

As ferramentas do Visual Studio contêm designers para cada tipo de elemento no

O código do X ++ é escrito no editor de código do Visual Studio. Os recursos padrão

Menu do Dynamics 365

As ferramentas adicionam o menu do Dynamics 365 ao Visual Studio. Várias

Elementos, modelos e pacotes representam a hierarquia estrutural no Visual Studio

Cada desenvolvedor tem sua própria VM de desenvolvimento, hospedada no Azure

Para conectar o Visual Studio ao VSTS, siga estas etapas:

6. Isso abrirá a caixa de diálogo conectar-se ao Team Foundation Server, no

8. Depois de pressionar Connect, o Visual Studio está conectado ao seu projeto.

Para o desenvolvimento no D365FO, precisaremos mapear uma pasta de

O controle de origem nas D365FO já percorreu um longo caminho neste lançamento,

Criando um novo projeto, pacote e modelo

1. Abra o Visual Studio como administrador.

Para criar um novo modelo, siga estas etapas:

5. Verifique novamente o resumo com detalhes. Selecione Criar novo projeto se

Neste tópico, vamos cobrir as seguintes personalizações:

 Criando diálogos usando o framework RunBase

Formulários no Dynamics 365 for Finance and Operations representam a interface

Normalmente, os formulários são criados usando o AOT produzindo um objeto de

Criando diálogos usando o RunBase framework:

Diálogos são uma maneira de apresentar aos usuários um formulário de entrada

A classe de aplicativo chamada Dialog é usada para construir diálogos. Outras

Neste exemplo, demonstraremos como construir um diálogo a partir do código

Siga os seguintes passos para completar esta atividade:

1. Adicione um novo projeto Create Dialog

Declare todos os seus objetos na classe, como mostrado a seguir:

class MyDialog extends RunBase

public container pack()

public boolean unpack(container packedClass)

 Crie um método de diálogo para capturar entradas do usuário de tempo de

fieldAccount = dialog.addField(extendedTypeStr(CustAccount),"Conta do Cliente");

public boolean getFromDialog()

public void run()

public static void main(Args _args)

5. Digite as informações em todos os campos e clique em OK. Os resultados serão

Primeiro criamos uma nova classe chamada MyDialog. Ao estendê-lo de RunBase,

Os métodos pack() e unpack() são normalmente usados para converter um objeto

O layout da caixa de diálogo real é construído no método dialog(). Aqui nós

Controles de diálogo adicionais são adicionados ao diálogo usando os métodos

Valores dos controles de diálogo são atribuídos às variáveis chamando o método

O processamento principal é feito no método run(). Para fins de demonstração, esta