X for Dummies

Integração C# e Microsoft Dynamics AX

Publicado em AX40, Tutoriais, X++, 23/06/2009, por Edvandro Santos

2


Integração é a chave necessária para qualquer ferramenta tecnológica de sucesso, não importa a plataforma em que esta se baseia cada vez mais programas precisam comunicar-se, criando uma rede associativa ao perfil do usuário que manipula a informação desejada. A internet usa muito disso, uma api que permita que todos os serviços das redes sociais interajam, bastando para isso apenas algumas linhas de códigos em JavaScript/(X)HTML.

Para uma empresa de telefonia, por exemplo, a realidade não surge da necessidade de compartilhar perfis de redes sociais diferentes ou RSS e sim de que o novo ERP que estão implantando na empresa possa comunicar-se com o seu, não menos importante, “SIGES (fictício) – Sistema Interno de Gestão de Estoque”.

É possível comunicar-se com o AX através de uma classe “DOT NET” chamada “Dot NET Business Connector”, criada para permitir que se acessem os dados do AX bem como suas funcionalidades através dos produtos da MS como C#, DOT NET e até mesmo o Microsoft Office. Esse recurso é tão robusto que é capaz de criarmos um front-end onde este trabalhe com as funcionalidades do ERP AX.

Diagrama de integração C# e AX

A comunicação entre as ferramentas poderia ser feita direto ao banco de dados. Mas isso foge à arquitetura do AX. Todo e qualquer acesso aos dados e tabelas que o ERP produz, deve ser feito diretamente através dele, a fim de garantir toda a segurança e consistência nas informações.

Quando criamos uma tabela no AX, ela é criada no banco de dados, e uma cópia, a original é criada para o seu dicionário de dados do AX, onde essa possui as regras de negócio e operações pertinentes a ela, não a criada no banco de dados.

Instalando “.Net Business Connector” Assembly

Antes de criarmos nossa aplicação para comunicar-se com o AX, é preciso instalar a classe, que é um assembly, na máquina. Para isso, com o seu DVD do AX, na opção “Install”, clique em “Microsoft Dynamics AX”.

Instalação do MS Dynamics AX

Na tela a seguir, clique em ”Next”. Caso você já possua componentes instalados na sua máquina, uma tela com estes serão exibidos. Clique em “Next” para continuar. Na próxima tela, serão listadas as opções de quais componentes desejamos instalar. Nesse caso, selecione a opção ”Dot Net Business Connector” e clique em “Next”.

Adicionando o ".Net Business Connector"

Com isso, uma cópia do Assembly do “Dot Net Business Connector” foi criada no caminho onde se localiza a pasta de instalação do ”Client”“%SYSTEMDRIVE%/Arquivos de programas/Microsoft Dynamics AX/40/Client/Bin” do AX, normalmente em . O nome do assembly é “Microsoft.Dynamics.BusinessConnectorNet.dll”.

Agora estamos prontos para permitir a comunicação da nossa aplicação em C# com o AX!

Criando as tabelas envolvidas

Para esse exemplo, vamos criar uma tabela chamada “Book”, com os seguintes campos:

Nome do campo Tipo Descrição
BookId Integer Código do livro
Title String(80) Título do livro

Essa tabela será utilizada para acessarmos suas funções a partir de nossa aplicação.

Para criar a tabela, abra a AOT (Árvore de Objetos do Aplicativo), pelo atalho CTRL + D ou os indicados abaixo:

Atalho para abrir AOT na barra do AX

Atalho para abrir AOT no menu pulldown

No nó “Data Dictionary”, acesse o nó “Tables” e crie uma nova tabela, clicando com o botão direito do mouse sobre esse nó e selecionando a opção “Novo Table”, ou pelo atalho CTRL + N ou no ícone Ícone "Novo Arquivo" da barra do AX. Com a tabela criada, crie os dois campos, levando em consideração o seu tipo. Ao final do processo, teremos a tabela na seguinte estrutura:

Tabela “Book” criada

Agora, na nossa nova tabela, eu vou criar um método chamado “find” que retorne o registro selecionado da tabela “Book” e sobrescrever o método “initValue” para atribuir um novo código de livro para o novo registro:


public static Book find(BookId _bookId)
{
Book b;
;
select b where b.BookId == _bookId;
return b;
}


public void initValue()
{
Book     b;
BookId    newBookId;
;
super();
select reverse firstOnly b;
newBookId = b.BookId + 1;
this.BookId = newBookId;
}

O primeiro método procura por um registro na tabela “Book” a partir de seu código, enquanto que o segundo adiciona um novo código para o registro que está sendo criado. Há diversas maneiras de se fazer à auto-incrementação no AX, porém essa é apenas para exemplicar a chamada de métodos a partir de outros programas.

Agora vamos inserir algumas linhas para testarmos nossa brincadeira. Dentro do AX, clique na tabela “Book” com o botão direito do mouse e acesse a opção “Suplementos/Navegados de Tabela”. Essa opção é um formulário que lista os registros da tabela onde podemos inserir, alterar e excluir os dados desta. Com isso, vamos inserir três linhas:

# Título
1 Harry Potter e o prisioneiro de Azkaban
2 O diário de Bridget Jones
3 O senhor dos anéis

Como o número é auto-incremento, o código foi criado automaticamente.

Registros na tabela "Book"

Com a parte do AX pronta, vamos agora criar o nosso programa em C#. Vale lembrar que criar projetos e adicionar componentes de tela pelo Visual Studio não será de abrangido nesse post. Só não esqueça de que seu projeto deverá ser em C#.

Com o projeto criado, vamos adicionar os seguintes elementos ao nosso formulário:

  • Três botões (”Buttons”) – Um para conectar, outro para desconectar do AX e outro para buscar um registro;
  • Duas caixas de texto (“TextBox”) – Uma para informarmos o código do livro que deveremos pesquisar e outra para exibir o título do livro quando for encontrado ou para inserirmos um novo título a ser criado no AX;
  • Dois “Labels” – Para identificar os campos de código e título do livro;
  • Um caixa de lista (“ListBox”) – Para listar todos os registros da tabela “Book”.

Obteremos então o seguinte resultado:

Formulário criado

Com o layout pronto, vamos adicionar a referência do “Dot Net Business Connector” na nossa aplicação.

Adicionando o assembly Dot NET no programa C#

Adicionando funções do AX

Declarando variáveis e referências

Com a referência criada assim como a interface, vamos agora ao que interessa! Sob a visualização de código, adicione o assembly do “Dot NET Business Conector”, que é a linha abaixo:


using Microsoft.Dynamics.BusinessConnectorNet;

Agora, crie uma variável global do tipo “Axapta”:


Axapta ax;

Efetuando login

Dê um duplo clique no botão “Conectar”. Agora vamos adicionar código no evento click deste:


try
{
//Instanciando objeto de referência do AX
ax = new Axapta();

//Logando no sistema com a credencial do usuário conectado na máquina
ax.Logon(null,null,null,null);
MessageBox.Show(“Conectado!”);
}
catch(Exception ex)
{
MessageBox.Show(“Não foi possível conectar-se ao AX: ” + ex.Message);
}

Ao instanciar o objeto “Axapta”, estamos criando a interação com o AX, ou seja, é com ele que criamos instâncias de objetos do ERP, como tabelas e classes X++.

O método logon possui os seguintes parâmetros:

  1. String company – o nome da companhia em conectaremos no AX;
  2. String language – a linguagem que será exibida;
  3. String objectServer – o nome da AOS que a ser conectada;
  4. String configuration – o nome da configuração definida no “Cliente Configuration Utility” a ser conectada.

A função aceita valores nulos, daí ele entende de que as configurações a serem utilizadas são as que já estão definidas para o usuário conectado no sistema.

Efetuando logoff

Agora dê um duplo clique no botão “Desconectar” e adicione, no evento click, o código abaixo:


try
{
ax.Logoff();
 //limpando o campo de título do livro
txtTituloLivro.Clear();

//limpando o campo de código do livro
txtCodLivro.Clear();

//Limpando as linhas do listbox
 lbRegistros.Items.Clear();

MessageBox.Show("Desconectado!");
}
catch (Exception ex)
{
MessageBox.Show("Não foi possível desconectar-se do AX: " + ex.Message);
}

Com o código acima, já podemos nos conectar ao AX!

Vale lembrar de que o usuário conectado na máquina deve ser cadastrado no AX.

Carregando registros

Agora que nos conectamos e desconectamos do AX, vamos manipular e acessar os dados da tabela “Book”. Primeiro, vamos ler os registros e adicioná-los no nosso “list box”. Como o objeto global “Axapta” referencia-se às interações e manipulações do AX em si, é através dele que criamos uma variável do tipo “AxaptaRecord” que contém as informações da tabela que queremos instanciar. Vamos, então, adicionar mais código no botão “Conectar”, onde ele irá preencher a “list box” com os registros encontrados na nossa tabela.


//Criando uma variável do tipo da tabela Book
AxaptaRecord book = ax.CreateAxaptaRecord("Book");

//Selecionando todos os registros da tabela
 book.ExecuteStmt("SELECT BookId, Title FROM %1");

 //Limpando as linhas do listbox
 lbRegistros.Items.Clear();

 //Percorrendo os registros retornados
 while (book.Found)
 {
 //Adicionando registros no list box
 lbRegistros.Items.Add(String.Format("{0} - {1}",
 book.get_Field("BookId").ToString(),
 book.get_Field("Title").ToString()
 ));
//Passando para o próximo registro
book.Next();

}

Na 1ª. Linha foi criada uma variável do tipo da tabela “Book”. Em seguida, executamos um comando SQL e percorrermos os registros obtidos a partir do resultado. O método do objeto “AxaptaRecord”,“get_Field” tem como parâmetro o nome do campo que desejamos obter o dado. Quando formos editar um registro, o método “set_Field” é utilizado. “Next” move o cursor para o próximo registro na consulta retornada.

Procurando registros

Como já conhecemos o objeto do tipo “AxaptaRecord”, e sabemos que o objeto “Axapta” é quem representa o ax propriamente dito, podemos executar métodos, sejam de qual tipo for, não importando o que eles retornam, vamos agora pesquisar por um registro da tabela criada.
Dê um duplo clique no botão “Pesquisar” do seu formulário e, no evento click, adicione o seguinte código:


AxaptaRecord book;
;

//Executando o método find da tabela "Book" e convertendo o tipo Object para um registro da tabela
book = (AxaptaRecord) ax.CallStaticRecordMethod("Book", "find", txtCodLivro.Text);

//Limpando as linhas do listbox
 lbRegistros.Items.Clear();

 //limpando o campo de título do livro
 txtTituloLivro.Clear();

 //Adicionando a linha do registro encontrado
 lbRegistros.Items.Add(String.Format("Registro encontrado! {0}",book.get_Field("Title").ToString()));

//Adicionando o título do livro no campo adequado
 txtTituloLivro.Text = book.get_Field("Title").ToString();

O método “callStaticRecordMethod” executa um método estático de uma variável que seja do tipo “Record”. Dependendo de qual o seu retorno, não é necessário fazer o “casting”. Nesse caso se faz necessário para que possamos ter o controle total do tipo que esperamos.

Editando registros

Vamos agora aprender a alterar e incluir um registro e a usar o controle de transação no “DotNetBusinessConnector”, que é obrigatório em operações de atualização de registro, assim como selecionar o registro para ”UPDATE”. No método”KeyDown” da caixa de texto que armazena o título do livro, insira o seguinte código:


//Verificando se a tecla pressionada foi ENTER
if (e.KeyCode == Keys.Enter)
{
//Se o campo txtCodLivro estiver diferente de vazio, atualizamos o registro
 //com o valor que está no campo txtTituloLivro se o encontrarmos. Caso contrário, inserimos um novo
 //Obtendo o valor do campo código

 //Obtendo o código do livro
 int bookId = Int32.Parse(txtCodLivro.Text.Trim() != "" ? txtCodLivro.Text : "0");

 //Pesquisando pelo registro a partir do seu código
 AxaptaRecord book = (AxaptaRecord)ax.CallStaticRecordMethod("Book", "find", bookId);

 //Se encontramos o registro, então vamos atualizá-lo
 if (book.Found)
 {
 //Início da transação
 ax.TTSBegin();
try
 {
 //é obrigatório marcarmos o registro para ser atualizado
 //portanto, o método selectForUpdate, que espera um tipo booleano, true para atualizar; false para não.
 book.Call("selectForUpdate", true);

 //Colocando o novo valor no campo título
 book.set_Field("Title", txtTituloLivro.Text);

 //Atualizando o registro
 book.Update();

 //Fim da transação
 ax.TTSCommit();

 //Mensagem de sucesso!
 MessageBox.Show("Registro atualizado com sucesso!");
}
 catch (Exception ex)
 {
 //Abortando a transação
 ax.TTSAbort();

 //Exibindo mensagem
 MessageBox.Show("Erro ao editar registro: " + ex.Message);
}
}
 else //Como não encontramos o registro, vamos inserí-lo
 {
 //Criando um novo registro
 book = ax.CreateAxaptaRecord("Book");

 //um novo número será atribuído ao campo BookId
 book.InitValue();
 book.set_Field("Title", txtTituloLivro.Text);
 book.Insert();

 //Mensagem de sucesso
MessageBox.Show("Registro criado com sucesso!");
}
}

Com isso, já sabemos conectar ao AX e obter as configurações de segurança e acesso ao aplicativo a partir do perfil do usuário conectado. Também sabemos editar* um registro específico que foi pesquisado. É importante ressaltar a importação do controle de transação e a marcação do registro para ser atualizado, pois sem essas variáveis não é possível edita-lo e obteríamos um erro.

*Para deletar, basta apenasr substituir, na parte de atualização, o método “update()” para “delete()”.

Faça o download dos objetos usados no post clicando aqui

É isso pessoal, espero que tenha ajudado. Até a próxima


Posts relacionados


    Fatal error: Call to undefined function wp_related_posts() in /home/storage/8/42/49/axfordummies/public_html/wp-content/themes/axfordummies/single.php on line 33