Con motivo de la integración de nuestras aplicaciones .NET
con Microsoft Dynamics AX 2012, he ido resumiendo la información que he ido
leyendo y probando.
AX2012 proporciona las siguientes formas de integrarse con aplicaciones:
Managed Interop o Proxy
Classes.
Te permite acceder a las Clases, Tablas y Enums del AOT
(Application Object Tree) de Ax2012 desde Visual Studio a través de Proxys, así
como ver datos de display, métodos, etc... directamente, por lo que tienes un acceso a ALTO
NIVEL a los objetos de Axapta.
Este método de acceso, comparado con el Business Connector,
tiene la ventaja de tener Intellisense de las clases, tablas y enums que vas manejando, así
como la detección de errores por parte del compilador, al ser objetos tipados.
Aquí recomiendo la consulta de “Tips de integración AX2012”
si surge algún error.
Pasos para usar Interop:
-
Nos creamos un nuevo proyecto en Visual Studio 2010
(en un equipo que tengamos instalado AX2012 con las Developer Tools)
-
En el proyecto que vayamos a acceder a Ax,
creamos una referencia a Microsoft.Dynamics.AX.ManagedInterop
que se ubica en “C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin”
- Botón derecho en el proyecto en el “explorador
de soluciones” -> Add Project1 to AOT.
- Se nos habrá creado una ventana “Application
explorer” (que la podemos sacar de Ver > Application Explorer) en la que
tenemos el AOT de AX2012.
- Elegimos los objetos con los que queremos interactuar del AOT (recuerda: Tablas, clases y enumerados) y los arrastramos al árbol de proyecto en el Explorador de Soluciones de VS2010. Esto nos creará unos proxys con los que podremos trabajar
- Usaremos los proxys
Un ejemplo de uso:
Fijaos en el consumo de VendTable. VendTable es el proxy que se ha generado al arrastrar la tabla al árbol de proyecto. Estamos usando el método FindByCompany, y luego estamos recuperando la información de forma tipada, con Intellisense, e incluso, pudiendo llamar a Displays y métoodos.
Business Connector for
.NET
NOTA: Se recomiendan los otros tipos de integración, ya que este método se mantiene por compatibilidad con anteriores desarrollos, y no se garantiza su continuidad en futuras versiones.
Es otro componente que permite accede a los elementos del
AOT, pero sin tener proxys ni tipos, y llamando directamente a sus métodos y propiedades.
Ataca un nivel más bajo que los proxyes de Interop, ya que
los campos display y los métodos hay que llamarlos mediante Call() y no
aparecen integrados dentro de la llamada principal.
Pasos para usar Business Connector.
Son unos
pasos parecidos al Managed Interop.
- Nos creamos una solución en Visual Studio 2010 (en un equipo que tengamos instalado AX2012 con las Developer Tools)
- En el proyecto que vayamos a acceder a Ax, creamos una referencia a Microsoft.Dynamics.BusinessConnectorNet.dll que se ubica en “C:\Program Files (x86)\Microsoft Dynamics AX\60\Client\Bin”
- Botón derecho en el proyecto en el “explorador de soluciones” -> Add Project1 to AOT.
- Creamos el código.
Si habéis trabajado con el AxaptaComConnector de la versión
3, esto os recordará su manejo.
También fijaos que los Displays Name y Email hay que
llamarlos. En el proxy generado de Managed Interop, estas llamadas estan incluidas en el proxy, por lo que el código resultante es más compacto.
Application
Integration Framework (AIF)
http://axwonders.blogspot.com.es/2012/01/microsoft-dynamics-ax-2012-services-and.html
El AIF es una plataforma que permite interactuar con
cualquier aplicación, ya sea .Net o de otro tipo, ya que la comunicación se
basa en WCF.
Algunos de estos servicios se pueden publicar en el AOS
(Application Object Server) o en el IIS.
Por buscar símiles, el IIS expone servicios WCF y el AOS
expone los servicios AX2012
El AIF se compone de:
- Document Services
- Custom Services
- System Services
Document Services
Su símil con WCF sería el Contract; o sea, el objeto que se expone al servicio. Se trata de una query autogenerada (query con prefijo AXD ) a partir de una entidad determinada.
Microsoft ya ha creado unos 70 documents de las entidades más representativas, a
falta de exponerlos en el AIF.
Los campos DEL_ de las tablas y los campos con la propiedad "Visible=false" no son incluidos en el documento.
En el caso de que quisiéramos crear nosotros nuestro propio document Service , se
puede seguir el siguiente walkthrough
Pasos para crear un Document Service.
- Creamos la Query (o buscamos la query AXD ya generada que nos cuadre)
- Creamos el servicio basándonos en la query
(Espacio de desarrollo > herramientas > Marco de integración de la aplicación > Crear servicio
de documentos), eligiendo los métodos que queremos que nos autogenere (Read, Write, Find...)
- Este paso generará una clase con prefijo AXD y un servicio ya preconfigurado con los métodos que hemos elegido.
- Nos quedará publicarlo; para ello vamos a Service Groups, creamos un nuevo Service Group y añadimos un nuevo nodo por cada servicio que queramos añadir en el Service Group. En propiedades de cada nodo vamos eligiendo el Service que queremos publicar.
- Una vez tengamos todo el Service Group completo, implementaremos.
- Para ver que el servicio está correctamente publicado, lo podremos ver en el espacio de trabajo > Administracion del sistema > Configurar > Services and Application Integration Framework > Puertos de entrada.
Esto te crea un nuevo servicio de tipo "Base" que es creado con una configuración por defecto. Si queremos configurar el adaptador y poder ajustar más opciones, en esa misma pantalla podríamos eliminar y crear un nuevo puerto de entrada, que sería de modo extendido, y permitiría configurar todos los parámetros posibles (configurar el Binding del WCF)
Más info en
http://msdn.microsoft.com/en-us/library/aa609947
Tipos de puertos
Ya que hemos tocado los puertos, decir que los InboundPorts reciben peticiones desde fuera de AX y los Outbound ports emiten peticiones a otros sistemas.
Consumo de un Document Service
En Visual Studio 2010, nos creamos una referencia de servicio a la dirección que aparece en la imagen superior, en el campo "uri de WSDL"
aquí os pongo un ejemplo de cómo se haría un "read" de un proveedor.
Custom Services
Son unos servicios más flexibles y personalizados que los
Document Services, ya que permiten exponer directamente una clase a un servicio, que es lo que hacemos normalmente con WCF.
Pasos para crear un Custom Service.
-
En el AOT, creamos nueva clase
- Añadimos métodos decorándolos con atributos correctamente. [SysEntryPointAttribute(true), AifCollectionTypeAttribute('return', Types::String)]
- Creamos un nuevo service, y lo mapeamos a la
clase (propiedad class).
-
Dentro de Servicios, en el árbol Operaciones, añadimos las operaciones(seleccionamos
los métodos que hemos creado)
-
Creamos un nuevo grupo de servicio, y añadimos nuevos serviceNodeReference asociados a services.
- Publicamos
Como anteriormente hemos comentado, para ver que el servicio está correctamente publicado, lo podremos ver en el espacio de trabajo > Administracion del sistema > Configurar > Services and Application Integration Framework > Puertos de entrada.
Consumo de un Custom Service
Lo consumiremos como como un servicio normal, creando un Service Reference (que ya hemos visto en los Document Services)
Estos métodos devuelven tipos básicos. Si queremos que
devuelva tipos complejos (clases de datos) , usaremos los DataContracts, como en WCF
Para ello, creamos una clase contenedora de datos y la etiquetamos como [DataContractAttribute], s métodos los etiquetando los métodos con [DataMemberAttribute('XXX')]
Más info en:
http://sumitsaxfactor.wordpress.com/2012/06/13/data-contracts-and-custom-services-ax-2012/
System Services
Solo AOS sobre TCP. Usado para recibir metadatos, datos de
una query o información de usuario.
Los system services son un conjunto de los siguientes servicios:
- Query Services
- Dynamic Query
- User-session Services
http://msdn.microsoft.com/en-us/library/gg879657.aspx
Query Services
Expone el AOT para realizarle queries. Devuelve datasets. La
url es net.tcp://<hostname:port>/DynamicsAX/Services/QueryService
El llamador necesita tener los permisos apropiados para
recoger la información.
Se componen de:
Static query
User-Defined query
http://msdn.microsoft.com/EN-US/library/gg847959.aspx
Static Query
Query que ha sido definida
previamente en el AOT.
http://msdn.microsoft.com/en-us/library/gg863932.aspx
User-defined query
Query definida usando la clase
QueryMetaData del MetadataService
Dynamic Query
(Ejemplo: buscar clase KanbanOverviewJobsQueryBuilder)
Query definida en una clase X++
que hereda de AIFQueryBuilder, implementándose en el método Initialize
QueryServiceClient
client = new QueryServiceClient();
DataSet dataSet;
Paging
paging = null;
CustTransQueryBuilderArgs args = new CustTransQueryBuilderArgs() {
parmCustAccount = "4008" };
dataSet = client.ExecuteDynamicQuery("CustTransQueryBuilder",
args, ref paging);
http://msdn.microsoft.com/en-us/library/gg847959.aspx
Metadata service
Permite obtener información de los metadatos del AOS.
net.tcp://<hostname:port>/DynamicsAX/Services/MetadataService
http://msdn.microsoft.com/EN-US/library/gg880762.aspx
User - session service
Permite obtener información del usuario llamante. (User Company, timezone, …)
net.tcp://<hostname:port>/DynamicsAX/Services/UserSessionService
http://msdn.microsoft.com/EN-US/library/gg881307.aspx
Y nada más; espero que con esta ayuda os hagáis una idea de qué herramientas tenemos disponibles para integrar apps.
Happy interop!!!
