Apostila DEV MS 365 FinOps por Luis Prado

Prévia do material em texto

1 
 
 
 
 
 
Introdução ao desenvolvimento e personalização. 
 
 
 
 
 
 
 
 
 2 
 
 
Í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 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 3 
 
 
 
Conceitual 
O Microsoft Dynamics AX é uma solução de enterprise resource planning (ERP) 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. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 4 
 
 
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. 
 
 
 5 
 
 
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. 
 
 
 6 
 
 
 
 
 
 7 
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. 
 
 
 
 8 
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. 
 
 
 
 
 
 
 
 
 
 
 
 9 
Elementos, modelos e pacotes 
Elementos, modelos e pacotes representam a hierarquia estrutural no Visual Studio 
for Finance and Operations. ElementosAplicar 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: 
 
 
 55 
 
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 
 
 
 56 
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. 
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 
 
 
 57 
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: 
 
 
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. 
 
 
 58 
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. 
Exist join 
As linhas de correspondência de tipo de link de origem de dados 
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. 
Not exist join 
Não existe o tipo de link da fonte de dados do formulário de 
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áriosque 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. 
 
 
 59 
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. 
 
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: 
1. Escolha para adicionar um novo item ao projeto. 
2. Selecione Interface do Usuário no painel esquerdo e Forma no lado direito painel. 
 
 
 60 
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. 
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. 
 
 
 61 
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. 
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 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. 
 
 
 62 
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: 
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 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 propriedadeCaption 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 
 
 
 63 
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. 
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: 
 
 
 
 
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 ListGridDefaultButton 
Command DetailsView 
Propriedade Valor 
Name DetailsTab 
Arrange Method Vertical 
 
 
 64 
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. 
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: 
 
1. Escolha para adicionar um novo item ao projeto. 
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. 
 
 
 65 
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: 
 
 
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. 
 
 
 66 
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: 
 
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 
 
 
 
 67 
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 
seguintes propriedades: 
 
Propriedade Valor 
Name LineViewLineDetailsTabPage 
Label Vehicle Service order lines 
Data Source ConWHSVehicleServiceLine 
 
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. 
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 
seguintes propriedades: 
 
Propriedade Valor Descrição 
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: 
 
Propriedade Valor Descrição 
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 
 
 
 68 
Data Group Overview 
 
41. Crie um controle de tabulação em LineViewLineDetailsTabPage e defina 
seguintes propriedades: 
 
Propriedade Valor 
Name LineViewDetailsTab 
Label @SYS23823 
Data Source ConWHSVehicleServiceLine 
Arrange Method Vertical 
 
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. 
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 
Arrange Method Vertical 
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. 
 
 
Entendendo nosso desenvolvimento: 
 
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 
 
 
 69 
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. 
 
 
 
 
 
 
 
 
 
 
 
 
 
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: 
 
 
 
 70 
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. Naseleçã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. 
 
 
 
 
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. 
 
 
 
 
 
 
 
 
 
 
 
 
 71 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Segurança 
 
Neste tópico, vamos cobrir os seguintes quesitos: 
 
 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) 
 
 
 72 
 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. 
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: 
 
1. Escolha para adicionar um novo item ao projeto. 
 
 
 73 
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 
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:74 
 
1. Escolha para adicionar um novo item ao projeto. 
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. 
4. Preencha a propriedade Descrição; isso deve descrever para a segurança 
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. 
 
 
 
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, 
 
 
 75 
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: 
1. Escolha para adicionar um novo item ao projeto. 
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. 
4. Preencha a propriedade Descrição; isso deve descrever para a segurança 
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. 
 
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: 
 
1. Escolha para adicionar um novo item ao projeto. 
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. 
 
 
 76 
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.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. 
 
 
 10 
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. 
 
 
 11 
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. 
 
 
 
 12 
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 
 
 
 13 
modelos. Pacotes podem ter referências a outros pacotes, assim como os assemblies 
.NET, podem referenciar-se uns aos outros. 
 
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: 
 
 
 
 14 
 
 
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: 
 
 
 
 15 
 
 
 
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. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 16 
 
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. 
 
 
 
 17 
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 
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"); 
 
 
 18 
 
 fieldAccount = dialog.addField(extendedTypeStr(CustAccount),"Conta do Cliente"); 
 fieldName = dialog.addField(extendedTypeStr(CustName),"Nome do Cliente"); 
 
 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(); 
 
 
 
 19 
 if (myDialog.prompt()) 
 { 
 myDialog.run(); 
 } 
} 
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: 
 
 
 
 
 
 20 
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. 
 
 
 
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õesOK 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. 
 
 
 
 21 
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 
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. 
 
 
 
Siga os seguintes passos para completar esta atividade: 
 
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(); 
 
 
 22 
 } 
 
public boolean unpack(container packedClass) 
 { 
 return true; 
 } 
 
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) 
{ 
 
 
 23 
 MyDialogSelect myDialogSelect = new MyDialogSelect(); 
 
 if (myDialogSelect.prompt()) 
 { 
 myDialogSelect.run(); 
 } 
} 
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: 
 
 
 
 24 
 
 
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: 
 
 
 
Entendendo nosso desenvolvimento: 
 
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. 
 
 
 
 25 
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 modificaqualquer 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. 
 
 
 
 
 
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 
 
 
 26 
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 
configuration 
Copiar configuração entre empresa / ambientes. 
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. 
 
 
 
 
Criando uma entidade de dados 
 
Siga os seguintes passos para completar esta atividade: 
 
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: 
 
 
 
 27 
 
 
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: 
 
 
 
 28 
 
 
 
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: 
 
 
 
 29 
 
 
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. 
 
 
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: 
 
 
 
 30 
 
 
 
 
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. 
 
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 
 
 
 31 
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 
simples e Detalhes - 
grade da lista 
Isso é usado para a tabela de apoio para 
drop-down 
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 
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 
Header 
Transaction Line 
Lista simples e 
Detalhes com Guias 
padrão 
Isso é usado para conjuntos de dados, 
como a fatura formulário de diário, que 
contém informações transacionais 
dados com cabeçalho e linhas. 
Transaction Lista simples e 
Detalhes com 
padrão guias 
Isso é usado para tabelas, como o 
Formulário de transação de Inventário, 
que contém dados transacionais, mas 
em um único nível. 
Worksheet header 
Worksheet line 
Detalhes Transação Isso é usado para conjuntos de dados de 
entrada de dados, como a ordem de 
compra, em que o conjunto de dados é 
 
 
 32 
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. 
 
 
 
 
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: 
 
 
 
 33 
 
 
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. 
 
 
 
 
 34 
 
 
 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 
 
 
 35 
Canceled 4 
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.SalesStatuscoluna Método de pagamento com 
a pesquisa: 
 
 
 
 38 
 
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 
 
 
 
 39 
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: 
 
 
 
 
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 
 
 
 40 
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. 
 
 
 
 
 
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á 
 + + 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 
Created Date Time 
Modified By 
Modified Date Time 
Yes 
Developer 
Documentation 
A tabela ConWHSVehicleParameters armazena os 
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. 
 
 
 41 
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 
Cardinality 
ZeroOne O valor não é obrigatório, então 
podemos, portanto, referem-se a zero 
registros de grupos de veículos, ou 
um. 
Relationship 
Type 
Association O registro de parâmetro está 
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; 
 
 
 42 
if (!parameter && !parameter.isTmp()) 
{ 
// Create the parameter 
Company::createParameter(parameter); 
} 
return parameter; 
} 
 
 
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 nestafase, é 
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: 
 
 
 43 
 
 
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. 
 
 
 44 
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 
 
 
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. 
 
 
 45 
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 
 
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 
Created Date Time 
Modified By 
Modified Date Time 
Yes 
Developer 
Documentation 
ConWHSVehicleTable contains vehicle records 
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. 
 
 
 46 
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 
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); 
 
 
 47 
if(this.AcquiredDateNo 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: 
 
 
 
 48 
 
 
 
 
 
 
 
 
 
 
 
 
 
Cada menu aparece na opção Módulos, conforme mostrado na captura de tela a 
seguir: 
 
 
 
 49 
 
 
 
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: 
 
 
 50 
 
 
 
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: 
 
 
 
 
 51 
 
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. 
 
 
 
 
 
 
 52 
 
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: 
 
 
 53 
 
Propriedade Valor Comentário 
Caption Parâmetros de gerenciamento 
de veículos 
Isso é mostrado no título do 
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: 
 
 
 54 
 
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 após o nome do controle. Clique com 
o botão direito do mouse controle e escolha