manual de programador _controlssap
TRANSCRIPT
ControlsSAP Framework
MMaannuuaall OOppeerraattiivvoo
V2007.9
PPoorr OOlliivveerr PPaarrrraa
2
Cont
rols
SAP
Fram
ewor
k ® Índice de Contenidos
1 Introducción a ControlsSAP ................................................................. 4
1.1 Prerrequisitos ........................................................................................................... 5 1.2 Método de trabajo.................................................................................................... 5
2 Objetos de negocio .............................................................................. 6
2.1 Definición de Objeto de Negocio............................................................................... 6 2.2 Creación de un objeto maestro (SAPObject).............................................................. 7 2.3 Creación de los objetos detalle (SAPLines) ................................................................ 8 2.4 Utilización de un objeto de negocio ........................................................................ 10 2.5 Tipo de validaciones definidas ................................................................................ 11 2.6 Eventos................................................................................................................... 13
2.6.1 Altas/Modificaciones...................................................................................... 14 2.6.2 Eliminaciones ................................................................................................. 15
3 Diseño de pantallas visuales .............................................................. 16
3.1 Controles ................................................................................................................ 16 3.1.1 SAPTextBox .................................................................................................... 17 3.1.2 SAPListBox...................................................................................................... 17 3.1.3 SAPComboBox................................................................................................ 19 3.1.4 SAPGrid .......................................................................................................... 21 3.1.5 SAPTreeSearch ............................................................................................... 24 3.1.6 SAPAttachments............................................................................................. 25
3.2 Pantallas................................................................................................................. 26 3.2.1 FormSAP......................................................................................................... 26 3.2.2 FormEditSAP................................................................................................... 27 3.2.3 FormWizard.................................................................................................... 30 3.2.4 FormSAPAlta .................................................................................................. 31 3.2.5 FormApplication............................................................................................. 32
4 Formulario de edición (FormEditSAP)................................................ 34
4.1 Diseño del formulario ............................................................................................. 34 4.2 Configurar el formulario.......................................................................................... 35 4.3 Entrada/Salida de datos .......................................................................................... 37 4.4 Trabajar con las grids .............................................................................................. 38
5 Impresiones........................................................................................ 40
5.1 Objeto Report ......................................................................................................... 40 5.2 Tipo de conexión .................................................................................................... 42 5.3 Versiones Crystal Reports ....................................................................................... 42 5.4 Visor de informes.................................................................................................... 43 5.5 Configurar informes en formularios ........................................................................ 43
3
Cont
rols
SAP
Fram
ewor
k ® 6 Mensaje de sistema ........................................................................... 48
6.1 Mensajes de dialogo ............................................................................................... 48 6.2 Mensajes en la barra de estado .............................................................................. 49 6.3 InputBox ................................................................................................................. 49
7 Autorizaciones ................................................................................... 51
7.1 Definición ............................................................................................................... 51 7.2 Creación ................................................................................................................. 52
8 Parámetros......................................................................................... 53
8.1 Creación de parámetros.......................................................................................... 53 8.2 Utilización de parametros ....................................................................................... 55
9 Módulos de trabajo............................................................................ 58
9.1 Creación de un módulo........................................................................................... 59 9.2 Creación de los Menús............................................................................................ 59 9.3 Creación de la base de datos................................................................................... 60 9.4 Control de versiones ............................................................................................... 62 9.5 Creación de parámetros.......................................................................................... 62 9.6 Arranque de un módulo de trabajo ......................................................................... 63
10 Integración...................................................................................... 66
10.1 Estilo 8.8................................................................................................................. 66 10.2 Fuente, tamaño de letra y color de las pantallas ..................................................... 67 10.3 Textos Dinámicos (Control + Doble-Click)................................................................ 67 10.4 Menús para SAP Business One ................................................................................ 68
11 Database......................................................................................... 69
11.1 Tablas, campos, índices........................................................................................... 69 11.1.1 Campos .......................................................................................................... 69 11.1.2 Índices............................................................................................................ 70
11.2 Vistas...................................................................................................................... 70 11.3 Procedimientos almacenados ................................................................................. 70 11.4 Sentencia SQL ......................................................................................................... 70 11.5 Categorías, consultas predefinidas, búsquedas formateadas................................... 71
11.5.1 Consultas predefinidas ................................................................................... 71 11.5.2 Búsquedas formateadas ................................................................................. 71
4
Cont
rols
SAP
Fram
ewor
k ®
11 IInnttrroodduucccciióónn aa CCoonnttrroollssSSAAPP
ControlsSAP es un Framework de desarrollo para crear aplicaciones en SAP Business One 2007 utilizando la plataforma de Microsoft .NET Framework 2.0, incluyendo métodos para:
• Replicación de controles y pantallas con la funcionalidad y aspecto de SAP B1, sin necesidad de utilizar la UI.
• Fácil utilización y creación de objetos de negocio no contemplados en la DI de SAP Business One.
• Facilidad en el mantenimiento de objetos de negocio utilizando formularios de edición propios.
• Conjunto de herramientas para la creación en el arranque de: tablas, campos, búsquedas formateadas, consultas predefinidas, vistas, etc. y parametrizaciones necesarias para el funcionamiento de nuestras aplicaciones.
• Control de versiones.
• Impresiones con Crystal Reports.
• Integración completa de pantallas realizadas en .NET dentro de SAP Business One.
• Etc.
Dado a las numerosas carencias proporcionadas por la UI, la mejor forma de trabajar será la de utilizar el AddOn2 Framework para trabajar con pantallas existentes de SAP. Y utilizaremos el framework de ControlsSAP para la creación de nuevas pantallas, ya que este posee un conjunto de controles y pantallas que replican a los proporcionados por la UI, pero con toda la potencialidad de .NET y con la posibilidad de poder añadir a demás controles propios sin ningún tipo de problema.
5
Cont
rols
SAP
Fram
ewor
k ® 1.1 Prerrequisitos
Para seguir el presente manual, y desarrollar con ControlsSAP Framework, es preciso tener instalado:
• Sistema Operativo Windows XP/Server 2003 • SAP Business One 2007 + SDK • Visual Studio 2005 + .NET Framework 2.0 • SQL Server 2000/2005
Adicionalmente se deberá instalar:
• Librerías de Crystal Reports (para poder visualizar informes) • Librerías DevExpress 2008 (para poder diseñar formularios con varios controles) • AddOn2 Framework (para la integración del proyecto en SAP Business One)
1.2 Método de trabajo
La forma de trabajar con ControlsSAP será la de crear módulos de trabajo. Estos módulos serán librerías (dll’s) que podremos añadir en un proyecto cliente. De esta manera conseguiremos reutilizar el mismo código para varios clientes con las mismas necesidades.
Los módulos constarán de:
• Objetos que se deben crear en la base de datos (tablas, vistas, campos, búsquedas formateadas, etc.)
• Opciones de menú
• Lista de Parámetros
• Autorizaciones para los formularios
• Numero de versión de datos
6
Cont
rols
SAP
Fram
ewor
k ®
22 OObbjjeettooss ddee nneeggoocciioo
Antes de crear cualquier pantalla necesitaríamos saber que objetos de negocio va a incluir nuestra aplicación y que relación van a tener entre ellos. Esta es la mejor manera de encapsular nuestro código y poderlo reutilizar mas adelante en diferentes proyectos, gracias a que todo nuestro código se basará en objetos.
Con esto conseguiremos definir en cada módulo una pequeña Data Interface (DI) que se podrá intercambiar entre diferentes Partners.
2.1 Definición de Objeto de Negocio
Podremos definir diferentes tipos de objeto:
• Objetos maestros
• Objetos detalle
Cada uno de ellos trabajará con una tabla de la base de datos. Un objeto maestro podrá contener cero o varios objetos detalle que serán sus líneas.
.
O. Maestro
D.B.
O.Detalle O.Detalle
O. Detalle
7
Cont
rols
SAP
Fram
ewor
k ® 2.2 Creación de un objeto maestro (SAPObject)
Para crear un objeto maestro deberemos heredar de la clase ControlsSAP.SAPObject. Solo por tenerla de base ya dispondremos de una serie de métodos y propiedades para interactuar con la base de datos.
Estos métodos serán los mismos que proporcionan los objetos de la DI por lo que ya deberían de ser de sobras conocidos.
Inicialmente necesitaremos implementar 3 métodos para crear un objeto cabecera:
• Constructor: donde le indicaremos la Company y la tabla de la base de datos de la que obtendrá los datos.
• InicializeLines: Método donde inicializaremos todos los objetos de línea de nuestro objeto de negocio y demás variables que podamos tener. Para inicializar las clases de líneas deberemos llamar al método DestroyLines().
• ModifyingObject: Utilizaremos este método para modificar la estructura interna de nuestro origen de datos antes de empezar a trabajar con sus datos. Desde aquí podremos:
o Añadir un campo mas a nuestra estructura de datos con AddField().
o Indicar que un campo será de solo lectura por lo que no actualizará en la base de datos.
o No permitir nulos con NotAllowNulls(). Cuando un campo no tiene especificado ningún valor entonces por defecto se graba un nulo, si por el contrario queremos que se guarde otro valor usaríamos este método.
Object: <SAPObject>
Properties: Browser <Lines> …
Methods: +Add +GetByKey +Remove +Update …
Añade el objeto en la base de datos. Obtiene los datos del objeto por su clave. Elimina el objeto de la base de datos. Modifica los datos del objeto. Permite navegar entre sus diferentes registros. Los diferentes tipos de Líneas que puede tener el objeto.
8
Cont
rols
SAP
Fram
ewor
k ®
Public Class Contract Inherits ControlsSAP.SAPObject Public Sub New(ByVal Company As SAPbobsCOM.Company) MyBase.New(Company, "@GSP_CNTR") End Sub Protected Overrides Function InitializeLines() As Long End Function Protected Overrides Sub ModifyingObject() End Sub
Listado 1: Ejemplo de creación de un objeto de negocio maestro.
Después solamente deberemos crear una propiedad por cada campo de la tabla que vayamos a publicar. Para obtener o asignar el valor del campo del registro actual utilizaremos la función FilaActual(nombre_campo).
Public ReadOnly Property Code() As String Get Return Me.FilaActual("Code") End Get End Property Public Property CardCode() As String Get Return Me.FilaActual("U_GSP_CardCode") End Get Set(ByVal value As String) Me.FilaActual("U_GSP_CardCode") = Value End Set End Property
Listado 2: Ejemplo de creación de propiedades en objeto de negocio.
Si no se especifica ningún valor para el campo Name (que crea en todas las tablas SAP) se le asignará el mismo valor que contenga el campo Code, que por defecto será el campo clave.
2.3 Creación de los objetos detalle (SAPLines)
Para crear un objeto detalle deberemos crear una nueva clase que herede de ControlsSAP.SAPLines. Esta clase será muy parecida a la del SAPObject pero con las particularidades de trabajar con objetos de líneas parecidos a los de la DI de SAP.
9
Cont
rols
SAP
Fram
ewor
k ®
En esta clase también tendremos métodos para modificar la estructura de datos interna de la clase tal como se hace en el SAPObject. Y deberemos crear también una propiedad por cada campo de nuestra tabla.
En el constructor deberemos indicar la tabla, el objeto cabecera y el campo que relaciona la tabla de líneas con la tabla cabecera.
A diferencia de las líneas de la DI de SAP, en las SAPLines existe una diferencia a tener en cuenta:
Siempre que se quiera añadir una nueva línea se deberá primero llamar al método Add() y después rellenar las propiedades del objeto. Por lo cual si no existe ninguna línea la propiedad Count() devolverá 0, a diferencia de las líneas del SDK de SAP que devuelven 1 aunque no exista ninguna entrada de datos.
Public Class Contract_Lines Inherits ControlsSAP.SAPLines Friend Sub New(ByVal sapobject As Contract) MyBase.New("@GSP_CNT1", "U_GSP_CntrCode", sapobject) End Sub Protected Overrides Sub ModifyingLines() End Sub Public ReadOnly Property CntrCode() As String Get Return Me.FilaActual("U_GSP_CntrCode") End Get End Property Public Property ItemCode() As String
Añade una nueva línea. Se posiciona en una línea determinada. Elimina la línea actual.
Properties: Count …
Methods: +Add +SetCurrentLine +Delete
Object: <SAPLines>
Devuelve el total de líneas.
10
Cont
rols
SAP
Fram
ewor
k ® Get
Return Me.FilaActual("U_GSP_ItemCode") End Get Set(ByVal value As String) Me.FilaActual("U_GSP_ItemCode") = value End Set End Property Public Property Import() As Double Get Return Me.FilaActual("U_GSP_Import") End Get Set(ByVal value As Double) Me.FilaActual("U_GSP_Import") = value End Set End Property
Listado 3: Ejemplo creación de un objeto de tipo línea.
Una vez tengamos la clase líneas creada deberemos crear una propiedad para tener acceso a estas en la clase maestra. Esta deberá ser de solo-lectura e instanciarse solamente si no tiene valor la variable que utilicemos para definirla. No nos olvidemos después de inicializar las líneas en el método InitializeLines.
Private _lines As Contract_Lines Protected Overrides Function InitializeLines() As Long Me.DestroyLines(_lines) End Function Public ReadOnly Property Cnt1() As Contract_Lines Get If Me._lines Is Nothing Then Me._lines = New Contract_Lines(Me) End If Return Me._lines End Get End Property
Listado 4: Añadir referencia clase líneas en objeto cabecera.
2.4 Utilización de un objeto de negocio
Una vez definidas todas las clases que componen nuestro objeto de negocio podremos ser capaces de utilizar este objeto para entrar datos, recuperar datos y actualizarlos.
Dim cont As Contract cont = New Contract(Me.Company)
11
Cont
rols
SAP
Fram
ewor
k ® cont.CardCode = "C000001"
cont.Comments = "Ejemplo creación de contrato" Try cont.Add() Catch ex As Exception ControlsSAP.SAPMsg.Alert("Error creando contrato") End Try
Listado 5: Ejemplo creación registro.
Dim cont As Contract cont = New Contract(Me.Company) 'Consulta de un registro cont.GetByKey("1") cont.Comments = "Ejemplo actualización de contrato" Try cont.Update() Catch ex As Exception ControlsSAP.SAPMsg.Alert("Error actualizando contrato") End Try
Listado 6: Ejemplo modificación de un registro existente.
Este es un ejemplo de utilización por código, aunque lo común será tratar nuestros objetos de negocio mediante formularios visuales. En el próximo capítulo veremos como existen formularios creados explícitamente para trabajar con este tipo de objetos y de una manera sencilla poder crear, consultar, actualizar y eliminar registros.
2.5 Tipo de validaciones definidas
Existirán 3 tipos de atributos que utilizaremos en las propiedades de los clases SAPObject y SAPLines para realizar diferentes tipos de validaciones:
• Mandatory: Forzaremos que en la propiedad se haya indicado un valor antes de guardar. Si lo hacemos en una propiedad que devuelve un SAPLines entonces exigirá que contenga al menos 1 línea.
• HasRelation: Obliga a que el valor de la propiedad este relacionado con un determinado campo de otra tabla.
• NonUpdatable: No permite que se pueda modificar el valor de la propiedad una vez se ha creado el objeto.
También existen 2 funciones por las que podremos saber si desde nuestra clase cabecera SAPObject se han añadido líneas en una determinada clase SAPLines o también si se han eliminado:
• ExistAddedLines
12
Cont
rols
SAP
Fram
ewor
k ® • ExistDeletedLines.
Ejemplo:
Creamos un objeto Presupuesto e intentamos simular el mismo funcionamiento que un documento de la DI de SAP. Tendremos varios campos entre ellos el código de cliente y el nombre. Deberemos tener las siguientes restricciones:
1. Para entrar una Presupuesto es obligatorio entrar el código de cliente.
2. El código de cliente y el nombre no pueden modificarse una vez creado el Presupuesto.
3. El valor del código de cliente debe existir en la tabla de clientes [OCRD.CardCode]
4. Una vez creado el Presupuesto no se permitirá añadir nuevas líneas ni eliminarlas.
Public Class Presupuesto Inherits ControlsSAP.SAPObject '... <NonUpdatable()> _ <Mandatory()> _ <HasRelation("OCRD", "CardCode")> _ Public Property CardCode() As String Get Return Me.FilaActual("U_GSP_CardCode") End Get Set(ByVal Value As String) Me.FilaActual("U_GSP_CardCode") = Value End Set End Property <NonUpdatable()> _ Public Property CardName() As String Get Return Me.FilaActual("U_GSP_CardName") End Get Set(ByVal Value As String) Me.FilaActual("U_GSP_CardName") = Value End Set End Property Private Sub Oferta_Updating(ByVal Obj As SAPObject) Handles Me.Updating If Me.ExistAddedLines(Me.Lines) Then Throw New ValidationException("No se puede añadir una línea una vez creado el documento") End If If Me.ExistDeletedLines(Me.Lines) Then Throw New ValidationException("No se puede borrar una fila una vez creado el documento ")
13
Cont
rols
SAP
Fram
ewor
k ® End If
End Sub
Listado 7: Ejemplo de utilización de atributos de validación
Este mismo tipo de restricciones las podríamos tener para el objeto líneas.
2.6 Eventos
Durante el momento de la ejecución de las diferentes acciones que soportan los objetos de negoció, podemos alterar los datos antes de que estos se guarden o podemos realizar validaciones propias para cancelar determinadas acciones según nuestras necesidades. El orden secuencial de los diferentes eventos más comunes es:
14
Cont
rols
SAP
Fram
ewor
k ® 2.6.1 Altas/Modificaciones
Add/Update
Base de Datos
Validating
Mandatory HasRelation NonUpdatable ...
Validaciones internas
Adding/Updating
ValidatedLines
Added/Updated
Por cada línea del SAPLines añadida/modificada:
Recorre las líneas
SavingLine
ValidatingLine
15
Cont
rols
SAP
Fram
ewor
k ® 2.6.2 Eliminaciones
Remove()
Base de Datos
Removing
Removed
Eliminamos cada línea del SAPLines:
Recorre las líneas
Delete()
16
Cont
rols
SAP
Fram
ewor
k ®
33 DDiisseeññoo ddee ppaannttaallllaass vviissuuaalleess
La librería de ControlsSAP incluye una serie de controles y formularios .NET pero con el Look&Feel de SAP, estos nos ayudaran a trabajar sin las limitaciones que tiene la UI ya que programaremos en la plataforma de Microsoft.NET 2.0.
Por lo que aunque necesitemos algún tipo de control o funcionalidad que no este disponible en ControlsSAP podremos utilizarlo igualmente en nuestros proyectos con lo que podemos utilizar una lista de recursos ilimitada, a diferencia de la programación con la UI.
3.1 Controles
En este apartado veremos una lista de controles disponibles en ControlsSAP. Estos controles dispondrán de una serie de propiedades comunes, ya que la mayoría de ellos implementan una misma Interface.
La mayoría de controles son típicos en Windows por lo que solamente se tratarán con mayor detalle los más importantes y complejos.
La lista de controles disponibles con el Look&Feel de SAP:
• SAPLabel: control de etiqueta.
• SAPCheckBox: casilla de verificación.
• SAPRadioButton: control de opciones.
• SAPPanel: panel de agrupación de controles.
• SAPTextBox: caja de texto.
• SAPListBox: control de selección parecido al ChooseFromList de SAP.
• SAPComboBox: control combo de selección.
17
Cont
rols
SAP
Fram
ewor
k ® • SAPLinkedButton: Control de vinculo o flecha naranja.
• SAPGrid: control de grid.
• SAPTree: control de árbol.
• TreeSearch: control de búsquedas en una grid mediante una serie de filtros fijados.
• SAPAttachments: control por el cual podremos anexar o visualizar diferentes archivos relacionados con un registro.
3.1.1 SAPTextBox Este es el control mas usado junto con las etiquetas SAPLabel. Son cajas de texto donde el usuario podrá introducir o consultar datos.
Podremos definir que tipo de datos va a utilizar el control y la entrada o salida variará según este.
DataType SubDataType
Precio Añade el símbolo de moneda y muestra los decimales indicados en SAP para el tipo Precio.
Importe Añade el símbolo de moneda y muestra los decimales indicados en SAP para el tipo Importe.
Cantidad Muestra los decimales indicados en SAP para el tipo Cantidad.
Numero
Entero No muestra decimales
Porcentaje Muestra el símbolo de ‘%’
Cadena Para datos de tipo texto
Memo Para datos de tipo texto con multilínea
Fecha Fechas
Hora Valores de tipo hora
Los de tipo numérico solamente aceptarán entradas de datos numéricos. Si seleccionamos el tipo Fecha entonces se comportará como las entradas de fecha de SAP.
3.1.2 SAPListBox Este control es también uno de los más utilizados en los formularios y de los más útiles ya que te permite seleccionar valores que pertenezcan a una lista de registros, de una manera sencilla y practica.
18
Cont
rols
SAP
Fram
ewor
k ®
Las propiedades más utilizadas:
• ValueMember: Indica de que columna obtendremos el valor una vez seleccionado un registro.
• DisplayMember: Indica la columna será la que utilizaremos para mostrar en el control una vez seleccionado un valor.
• SelectedValue: Propiedad en la que podremos asignar u obtener el valor del registro seleccionado y que hemos indicado el la propiedad ValueMember.
Otros de los métodos más comunes:
• AddColumn: Añadiremos las columnas que queremos visualizar en la lista de registros.
• SetItemValue: Desde este método podemos asignar también un valor al control pero sin provocar el evento SelectedValueChaged, a diferencia de hacerlo con SelectedValue.
La lista de datos que mostrará el control puede venir de diferentes orígenes:
• Indicando la tabla de la que se obtendrán los datos
With Me.SapListBox1 .Table = "OCRD" .ValueMember = "CardCode" .DisplayMember = "CardName" .Condition = "CardType='C'" .Company = Me._company End With
• Asignándole un objeto DataTable a su propiedad DataSource:
19
Cont
rols
SAP
Fram
ewor
k ® Dim dt as DataTable
dt = ControlsSAP.DoQuery(“SELECT * FROM OCRD”) Me.SapListBox1.DataSource = dt
• Añadiendo los valores manualmente con el método InsertRow
With Me.SapListBox1 .InsertRow("O", "Abierto") .InsertRow("C", "Cerrado") .InsertRow("P", "Pendiente") End With
• También podremos añadir valores con:
o AddValidValues: Consulta la lista de valores validos definidos para un campo de SAP.
o AssignEnum: muestra la lista de valores de la enumeración indicada.
Cuando asignemos los datos mediante la propiedad Table y queramos añadir un registro propio cada vez que se carguen los datos, utilizaremos el evento SAPListBox.BoundTable.
Private Sub lstIC_BoundTable(...) Handles SapListBox1.BoundTable Me.lstIC.InsertRow("-1", "-Ningún Interlocutor comercial-", 0) End Sub
Listado 8: Después de cada carga de IC, añadimos un nuevo valor.
También podemos utilizar la propiedad DisplayControl para especificar otro control en el que se volcarán los datos correspondientes a la columna especificada en el DisplayMember. En vez de mostrarse la descripción en el mismo control se mostrará en el control que indiquemos.
3.1.3 SAPComboBox El control SAPComboBox incorpora la mayoría de funciones y propiedades del control SAPListBox anterior pero con el aspecto de un control combo. Este se utiliza normalmente para mostrar listas pequeñas de valores.
20
Cont
rols
SAP
Fram
ewor
k ®
Para los controles de lista se ha añadido nueva funcionalidad para poder añadir registros nuevos desde el mismo control, ahorrándonos el trabajo de tener que ir a buscar la opción de menú correspondiente a esta acción.
Podremos añadir registros indicando:
• El nombre de la tabla: que abrirá un formulario de alta de registros típico (FormSAPAlta)
• El tipo de formulario: abrirá el formulario de mantenimiento en modo crear. Este tiene que heredar de FormEditSAP.
• El id. de menú de SAP: con este identificador (MenuUID) abriremos la pantalla correspondiente en SAP. Para este tipo de formularios no se podrán añadir los registros creados en el control, solamente servirá para abrir el formulario de SAP.
Las funciones que utilizaremos para el SAPListBox son:
• SetFormToCreate: Que añadirá el botón de “Nuevo” en el formulario de selección.
Y para el control SAPComboBox:
• InsertCreateRow: Que creará un nuevo registro “Definir nuevo”.
21
Cont
rols
SAP
Fram
ewor
k ® 3.1.4 SAPGrid
Complejo control de Grid que nos servirá para mostrar un conjunto de valores y para realizar el mantenimiento de los objetos SAPLines.
Podremos añadir diferentes tipos de columnas según el tipo de datos que queramos mostrar:
• AddColumn: Añade una columna genérica según el tipo de datos que vaya a mostrar.
• AddPriceColumn: columna para datos de tipo precio. Visualizará el símbolo de moneda y los decimales definidos en SAP para el tipo Precio.
• AddImportColumn: columna para datos de tipo importe. Visualizará el símbolo de moneda y los decimales definidos en SAP para el tipo Importe.
• AddQuantityColumn: columna para datos de tipo cantidad. Visualizará los decimales definidos en SAP para el tipo Cantidad.
• AddPercentatgeColumn: visualiza el símbolo de ‘%’
22
Cont
rols
SAP
Fram
ewor
k ® • AddBooleanSAPColumn: visualizara una columna con formato checkbox para
datos alfanuméricos con valores Y o N (Yes/No)
• AddListColumn: parecido al control SAPListBox, donde le indicaremos un origen de datos y la celda de la grid solamente podrá se un valor de esta lista.
• AddComboBoxColumn: visualizara una celda de tipo combo para la selección de un valor en una lista indicada de valores.
• AddProgressBarColumn: muestra una barra de progreso según el valor actual de la celda.
AddMemoColumn: podremos añadir columnas con textos lagos en varias líneas.
AddImageColumn: añadiremos columnas para mostrar imágenes desde una ruta. Deberemos indicar un campo que será el que contenga la ruta específica de la imagen.
Otras configuraciones que puede tener la grid:
• ObjectSource: propiedad para asignar los datos de un objeto SAPLines como origen de datos.
• AcceptsAddLines: nos indica si se pueden añadir nuevas líneas en la grid.
• AcceptsDeleteLines: indica si podremos eliminar registros de la grid.
• Editable: Indica si la grid permitirá edición de sus celdas
• ShowEmptyLine: muestra una fila vacía para la entrada de nuevos registros.
• MarkRow: Marca las filas en negrita que cumplan un criterio establecido.
• DisableRows: Deshabilita las filas que cumplan con un criterio.
• SelectRow: selecciona una o varias filas
• GetSAPLine: posiciona el objeto SAPLines según la fila indicada de la grid.
En próximos apartados veremos como trabajar un objeto de negocio desde un formulario. Los objetos líneas se trabajarán con el control SAPGrid que dispone de varios eventos especiales que nos informarán de cualquier modificación en las líneas:
• UpdatingSAPLine
• UpdateSAPLine
• ValidateSAPLine
• DeletedSAPLine
• DeletingSAPLine
3.1.4.1 Multiselección
Las columnas de tipo lista (AddListColumn) disponen de la opción de multiselección. Existe un parámetro por el que podremos indicar si queremos utilizar multi-selección o no. Los eventos
23
Cont
rols
SAP
Fram
ewor
k ® UpdateSAPLine/ UpdatingSAPLine del SAPGrid se ejecutarán por cada fila, como si las
hubieramos entrado una a una.
Si alguna de las filas no pasa con éxito la validación entonces no se añadirá en la grid.
c = .AddListColumn("Cód.artículo", "U_GSP_ItemCode", Me._company, "OITM", "ItemCode", New String() {"ItemName", "ItemCode", _ "VatGourpSa", "ItmsGrpCod"}, , , True)
3.1.4.2 Columnas obligatorias
Existe un método en el control SAPGrid por el que podremos indicar si alguna de las columnas que hemos añadido es una columna de inicio, que quiere decir que es obligatorio que introduzcamos un valor en una de estas columnas antes que en ninguna otra.
Ejemplo:
No podremos introducir ningún valor en las líneas mientras no exista un valor en la columna de artículo:
.AddBeginningColumn("U_GSP_ItemCode")
Listado 9: Código de ejemplo para indicar un columna obligatoria.
24
Cont
rols
SAP
Fram
ewor
k ®
Figura 1: Ejemplo de advertencia al intentar introducir un valor en una columna diferente a la indicada
como obligatoria.
Se ha publicado también un evento ShowingEditor por el que podremos conseguir efectos parecidos al anterior, o sea no permitir la edición de una celda mientras no se cumplan determinados criterios.
Ejemplo:
No podemos introducir ningún valor en la grid mientras no se haya introducido el código del cliente (campo de cabecera):
Private Sub SapGrid1_ShowingEditor(...) Handles SapGrid1.ShowingEditor If Not Me.lstCardCode.HasValue Then ControlsSAP.SAPMsg.StatusBarMsg("Falta código de interlocutor comercial", True) e.Cancel = True End If End Sub
3.1.5 SAPTreeSearch Control de vista de datos para realizar diferentes tipos de filtros (panel izquierda). Además de poder filtrar en tiempo de ejecución.
25
Cont
rols
SAP
Fram
ewor
k ®
3.1.6 SAPAttachments Control utilizaremos para adjuntar o visualizar archivos en una carpeta de documentos anexos de una manera sencilla.
Podremos realizar las siguientes acciones:
Explorar: Seleccionaremos un archivo y lo anexaremos por defecto en la carpeta de documentos de anexo especificada en SAP. Si indicamos una ruta mediante la propiedad AttachmentPath entonces se utilizará esta ruta para realizar una copia del archivo.
Visualizar: Abrirá el documento seleccionado.
Borrar: Eliminará el documento seleccionado de la lista de documentos del control.
Drag&Drop: El control permite la posibilidad de arrastrar y soltar archivos dentro de este, con lo que se creara una copia del archivo en la ruta de anexos especificada.
También permitirá arrastrar y soltar mensajes de correo desde Microsoft Outlook.
26
Cont
rols
SAP
Fram
ewor
k ® Se utilizará para guardar documentos adjuntos por ejemplo en un SAPObject. Para ello
solamente necesitaremos una propiedad de tipo String donde guardaremos la lista de archivos en cadena y separados por punto y coma.
Para obtener la lista de archivos utilizaremos la propiedad Attachments del control.
3.2 Pantallas
Existen varios tipos de pantallas con las que podremos trabajar. La base de todas ellas será la clase ControlsSAP.Forms.FormSAP. Esta clase será la que utilicemos normalmente y la que proporcionará a nuestros formularios el aspecto de pantalla de SAP e incluirán todos los mecanismos de integración en SAP Business One como si fueran pantallas propias de la UI.
3.2.1 FormSAP Este tipo de formulario será la clase base de las que heredarán todos nuestros formularios. Con esto dispondremos de todos los métodos, funciones y propiedades que nos servirán para interactuar con las demás pantallas y facilitarán la integración con SAP.
Podremos interactuar con algunos botones de la barra de herramientas de SAP Business One como son los de Excel, los de Word, los de impresión y presentación preliminar, y también los de mailing. Para ello disponemos de una serie de eventos y de propiedades para habilitar o no los botones de la barra de herramientas:
• AcceptsExcel: Habilita el botón de Excel de la barra de herramientas y podemos capturar la pulsación a través del evento Excel.
• Word Habilita el botón de Word de la barra de herramientas y podemos capturar la pulsación a través del evento Word.
• AcceptsPrint/AcceptsPreview: Habilita la impresión/presentación preliminar que capturaremos desde el evento Print
• eMailing: será el evento que capturaremos si queremos modificar la pantalla de mailing que aparecerá por defecto. Como por ejemplo añadir un destinatario, datos adjuntos, etc.
También tendremos funciones muy utilizadas como:
• OpenForm: Abre un formulario y lo integra en SAP automáticamente.
• OpenFormDialog: abre un formulario en modo dialogo para obtener un resultado.
• OpenFormEdit: abre un formulario de edición (que veremos en el próximo apartado) y se sitúa en un registro indicado.
• OpenReport: muestra una pre-visualización de un informe de CrystalReports.
27
Cont
rols
SAP
Fram
ewor
k ® 3.2.2 FormEditSAP
Nos permite realizar el mantenimiento de los objetos de negocio creados a partir de un SAPObject de una manera rápida y sencilla. Este es formulario mas complejo que existe pero también el mas utilizado, por lo que dedicaremos un capitulo especifico para hablar de el.
Este tipo de formularios interactúa con los botones de la barra de herramientas referentes al mantenimiento de datos, a demás de los ya mencionados anteriormente por el hecho de heredar de FormSAP. Estos son:
• AcceptsAdd: permite tener habilitado el botón de Nuevo.
• AcceptsDelete: habilita la opción de menú de eliminar.
• AcceptsSearch: activa el botón de búsquedas
• AcceptsUpdate: habilita los botones de desplazamiento de registros (primero, anterior, siguiente, ultimo)
Una vez configuradas las acciones que queremos tener disponibles en nuestra pantalla deberemos conocer los estados que puede tener el formulario por motivo de realizar cualquiera de estas acciones. Desde la propiedad Estat podremos saber si estamos en alguno de los estados siguientes:
• CONSULTING: indica que estamos en un estado de consulta. Se provoca en el momento de desplazarse entre los registros
• UPDATE: indica que estamos realizando una actualización en un registro ya existente. La mayoría de los controles vistos hasta ahora disponen de una propiedad CausesActionUpdate que si esta activada indicará que cualquier cambio en ese control provocará un cambio de estado en el formulario.
• SEARCH: no se utiliza.
• ADD/ADDING: nos informa de que se esta añadiendo un nuevo registro.
Existe una propiedad ButtonForm para indicar que botón del formulario será el indicado en recibir los cambios de estado del formulario y proceder a un tipo de acción u otra dependiendo de este:
Estado Texto del ButtonForm Acción
CONSULTING “Ok” Cerrar el formulario
UPDATE “Actualizar” Actualizar los datos
ADD “Crear” Crea un nuevo registro
Todo este tipo de acciones tienen una serie de métodos asignados que podremos sobrescribir para añadir funcionalidad propia según nuestras necesidades:
• DoAdd: prepara el formulario para crear un nuevo registro. Se ejecuta en el momento de de pulsar sobre el botón de “Nuevo”. Podemos utilizarlo para asignar valores por defecto en los controles.
28
Cont
rols
SAP
Fram
ewor
k ® • DoDelete: realiza la acción de eliminar el registro actual. Se ejecuta cuando
pulsamos sobre la opción de menú Datosà Eliminar
• DoSearch: realiza una búsqueda entre todos los datos. Se obtiene cuando pulsamos sobre buscar.
• GoToFirst: se desplaza al primer registro.
• GoToLast: nos desplazamos al último registro.
• GoToPrevious: nos desplazamos al registro anterior.
• GoToNext: registro siguiente
• GoToKey: de posiciona en el registro que coincida con la clave indicada.
3.2.2.1 Carga de datos
Existirán 2 maneras de cargar datos en un FormEditSAP trabajando con un objeto de negocio SAPObject.
• Usando GetAllObjects:
Esta es la manera más usual de obtener los datos en un FormEditSAP. Podremos consultar todos los datos del objeto existentes en ese momento. Se puede también indicar por que campo queremos que aparezcan ordenados los registros.
29
Cont
rols
SAP
Fram
ewor
k ®
Deberemos asignar el objeto al formulario y este se encargará de consultar los datos del registro indicado en cada momento.
_of = New Oferta(_company) Me.GetAllObjects(_of, "U_GSP_CardName")
Listado 10: Instanciación y uso del un SAPObject en un FormEditSAP.
• Usando el GetSAPObject del objeto:
Otra manera de consultar los datos de un objeto es la de asignarle previamente el origen de datos (por el que queremos navegar) al Browser del objeto. Es necesario que en el origen de datos exista un campo con la clave principal del objeto.
Para ello utilizaremos el método GetSAPObject que indicará al formulario que debe trabajar con los datos del objeto actual.
Ejemplo: Solamente podremos navegar por registros donde el total sea mayor de 1000.
Browser
Base de datos
30
Cont
rols
SAP
Fram
ewor
k ® Dim dt As DataTable
dt =DoQuery("SELECT Code, U_CardCode, U_CardName, U_DocDate FROM [@GSP_DEMO_OFERTA] WHERE (U_GSP_DocTotal > '1000')", Me._company) If dt.Rows.Count > 0 Then _of.Browser.RecordSet = dt End If Me.GetSAPObject(_of)
Listado 11: Utilización del Browser y uso del GetSAPObejct.
Solo podremos desplazarnos por los registros seleccionados en el momento de cargar el Browser del objeto. Por los que si existen nuevos registros creados posteriormente por otros usuario o procesos no se visualizarán, pero si los cambios ya que en cada movimiento se refrescarán los datos del objeto actual.
Por defecto si no se especifica ninguna acción en el momento de la carga el formulario se posicionará en el último registro.
3.2.3 FormWizard Este tipo de formulario puede ser muy útil para realizar pantallas asistentes de forma rápida y práctica. Consistirá en un formulario con un control de pestañas que en el momento de ejecución se visualizará como una pantalla asistente propia de las de SAP.
Permitiremos realizar un cambio de página dependiendo de si se cumplen las validaciones que creemos oportunas, capturando los eventos:
• PageChanged
• PageChanging
31
Cont
rols
SAP
Fram
ewor
k ® Estos eventos nos informarán de que página venimos y a que página nos dirigimos. Podremos
cambiar la información descriptiva de la página actual por medio de la propiedad Description. También podremos desplazarnos por las páginas a través de código mediante:
• NextPage: nos desplazamos a la página siguiente.
• PreviousPage: nos movemos a la anterior página.
• ActualPage. Podemos obtener en que pagina estamos actualmente y podemos desplazarnos también a una página en concreto asignándole un valor.
El formulario asistente podrá tener 2 configuraciones diferentes según la propiedad PageEnd:
1. Si es “False” al llegar a la última página el botón de continuar quedará deshabilitado.
2. Si es “True” en la última página aparecerá un botón de finalizar que lanzará un evento FinalizeWizard que deberemos capturar para ejecutar las acciones necesarias al finalizar el asistente.
3.2.4 FormSAPAlta Es un sencillo y práctico tipo de formulario que utilizaremos para crear o actualizar registros en una tabla de usuario de SAP. Estas pantallas son útiles para tablas básicas, donde solamente sea necesario indicar un código y una descripción.
Podremos utilizarlas sobre todo para realizar mantenimientos de tablas en entornos fuera de SAP Business One.
Figura 2: Ejemplo de pantalla tipo FormSAPAlta.
32
Cont
rols
SAP
Fram
ewor
k ® 3.2.5 FormApplication
Si queremos reutilizar nuestro código en un entorno fuera de SAP Business One, podremos simular un entorno parecido en aspecto y funcionalidades vistas, utilizando el tipo de formulario FormApplication. Con el dispondremos de una interficie parecida a la de SAP incluyendo la barra de herramientas, barra de menú, menú principal, etc. Dispone de métodos para:
• Conectar a la base de datos
• Añadir los módulos de trabajo y sus menús
• Abrir formularios
• Desplazarse por los registros, crear, buscar, etc.…
• Gestionar las aplicaciones
• Control de versiones
En el evento Load del formulario llamaremos a la función Connect. Esta función realizará la conexión a la última base de datos de SAP conectada. Si es la primera vez se mostrará un formulario en el que indicaremos los datos necesarios para la conexión.
Para cargar módulos de trabajo utilizaremos AddNewModule/AddItemModule y lo realizaremos en el evento LoadModules. Si estos necesitan crear tablas, campos, etc. lo realizarán antes de iniciarse la aplicación informando al usuario de los cambios que se van a realizar para cada módulo.
Public Class frmMenu Private Sub frmMenu_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load Me.Connect() End Sub Private Sub frmMenu_LoadModules(ByVal sender As Object, ByVal e As EventArgs) Handles Me.LoadModules Me.AddItemsModule(DLL.LoadDLL(Me.Company)) End Sub End Class
Listado 12: Conexión y arranque de un módulo desde un formulario FormApplication.
33
Cont
rols
SAP
Fram
ewor
k ®
Figura 3: Ejemplo FormApplicacion.
34
Cont
rols
SAP
Fram
ewor
k ®
44 FFoorrmmuullaarriioo ddee eeddiicciióónn ((FFoorrmmEEddiittSSAAPP))
En este capitulo veremos en profundidad como trabajar un objeto de negocio SAPObject a través de un formulario de edición FormEditSAP.
4.1 Diseño del formulario
Primero de todo diseñaremos una pantalla que herede de FormEditSAP y le añadiremos los controles necesarios para poder editar el objeto con el que vayamos a trabajar.
Figura 4: Ejemplo diseño de un formulario de edición.
35
Cont
rols
SAP
Fram
ewor
k ® El objeto de negocio con el que trabajaremos será el visto en ejemplos anteriores. Para el
mantenimiento de las propiedades del objeto Contrato necesitaremos añadir los siguientes controles y configurarlos de manera:
1. “Código”: SAPTextBox, no acepta ediciones ni en alta ni en actualizaciones.
2. “Código cliente”: SAPListBox, de consulta de los clientes
• Table = “OITM” • ValueMember =”CardCode” • DisplayMember = “CardName” • Condition = “CardType=’C’”
3. “Fecha Inicio”/”Fecha Fin”: SAPTextBox acepta todo tipo de ediciones
• DataType = Fecha
4. “Comentarios”: SAPTextBox multilínea, acepta todo tipo de ediciones
• DataType = Memo
5. “Líneas de contrato”: Las líneas las trabajaremos mediante un SAPGrid.
A todos estos controles les deberemos indicar también las propiedades siguientes para que interactúen con el estado del formulario:
• CausesActioUpdate = True
• CausesAspectChage = True
4.2 Configurar el formulario
El paso siguiente será entrar ya en el código y crear un constructor que reciba un objeto SAPBobsCOM.Company. Definiremos dos variables de clase que utilizaremos para el objeto de negocio con el que trabajará el formulario y la otra variable para referenciar la Company.
Private _company As SAPbobsCOM.Company Private _obj As Contract Public Sub New(ByVal Company As SAPbobsCOM.Company) MyBase.New() 'El Diseñador de Windows Forms requiere esta llamada. InitializeComponent() 'Agregar cualquier inicialización después de la llamada a 'InitializeComponent() Me._company = Company End Sub
Listado 13: Ejemplo constructor de un FormEditSAP.
36
Cont
rols
SAP
Fram
ewor
k ® Una vez definido el constructor pasaremos a configurar los controles que utilizará el formulario.
Para ello utilizaremos el evento Load del formualrio. Definiremos también con el método ViewColumnInSearch las columnas que queremos que se muestren en el momento de las búsquedas.
Private Sub FormEditSAP1_Load(ByVal sender As Object, _ ByVal e As EventArgs) Handles MyBase.Load 'Configuración de la busqueda del formulario Me.ViewColumnInSearch("Code", "Código") Me.ViewColumnInSearch("U_GSP_CardCode", "Código cliente") Me.ViewColumnInSearch("U_GSP_DataIn", "Fecha inicio") Me.ViewColumnInSearch("U_GSP_DateOut", "Fecha de fin") 'Configuración del Listbox de clientes With lstCardCode .Company = Me._company .AddColumn("CardCode", "Código") .AddColumn("CardName", "Nombre", 200) .AddColumn("Phone1", "Teléfono") End With 'Configuración de la Grid With grdCnt1 .AddListColumn("Cod. Artículo", "U_GSP_ItemCode", _ Me._company, "OITM", "ItemCode", _ New String() {"ItemName"}) .AddColumn("Descripción", "ItemName") .AddQuantityColumn("Cantidad inicial", "U_GSP_QuantIn") .AddQuantityColumn("Cantidad final", "U_GSP_QuantOut") .AddImportColumn("Importe", "U_GSP_Import") End With
Listado 14: Ejemplo configuración del formulario y sus controles.
Existe la posibilidad también, en el momento de buscar , de hacer aparecer datos de otras tablas sobrescribiendo la consulta del formulario.
Para ello deberemos capturar el evento BuldingSearch. Como requisito indispensable debe aparecer como mínimo el campo clave del objeto en la nueva búsqueda.
Private Sub frmOferta_BuldingSearch(ByRef sqlQuery As String) Handles _ Me.BuldingSearch sqlQuery = "SELECT [@GSP_DEMO_OFERTA].Code, OCRD.CardCode, OCRD.CardName, OCRD.Address FROM [@GSP_DEMO_OFERTA] INNER JOIN OCRD ON [@GSP_DEMO_OFERTA].U_GSP_CardCode = OCRD.CardCode" End Sub
Listado 15: Ejemplo utilización búsqueda propia con BuldingSearch.
También instanciaremos el objeto y cargaremos todos los datos por defecto del objeto de negocio para poder empezar a trabajar con el, dentro del evento Load.
37
Cont
rols
SAP
Fram
ewor
k ® 'Creación del objeto de negocio y obtención de los datos
_obj = New Contract(_company) Me.GetAllObjects(_obj) Me.GoToLast()
Listado 16: Carga de datos en el objeto de negocio.
4.3 Entrada/Salida de datos
El formulario dispondrá de 2 métodos que deberemos sobrescribir y que necesitaremos para realizar la entrada de datos del objeto hacia el formulario como el proceso contrario. Deberemos sobrescribir el LoadFormWithObject que se ejecutará cada vez que se necesite cargar datos en los controles desde el objeto actual:
Public Overrides Sub LoadFormWithObject() txtCode.Text = Me._obj.Code lstCardCode.SelectedValue = Me._obj.CardCode txtDataIn.Text = Me._obj.DataIn txtDateOut.Text = Me._obj.DateOut txtComments.Text = Me._obj.Comments 'Carga de las líneas grdCnt1.ObjectSource = Me._obj.Cnt1 End Sub
Para el proceso contrario, cargar los datos entrados en el formulario en las propiedades del objeto sobrescribiremos el método LoadObjectWithForm. Este se ejecutara en el momento de añadir o actualizar:
Public Overrides Sub LoadObjectWithForm() Me._obj.CardCode = lstCardCode.SelectedValue Me._obj.DataIn = txtDataIn.Value Me._obj.DateOut = txtDateOut.Value Me._obj.Comments = txtComments.Text End Sub
Hay que observar que las líneas no necesitan actualizarse ya que al trabajarse con la Grid se actualizan directamente en su origen de datos, por lo que el objeto dispondrá de los nuevos valores en todo momento.
Con esto ya estaríamos en disposición de poder realizar ya un mantenimiento básico de nuestro objeto. Por lo que si añadimos una nueva opción de menú en la que abramos el formulario podremos ya realizar altas, modificaciones, búsquedas, etc.
38
Cont
rols
SAP
Fram
ewor
k ®
Figura 5: Ejemplo formulario de edición en tiempo de ejecución.
4.4 Trabajar con las grids
Para completar nuestro mantenimiento con las líneas, deberemos realizar algunas validaciones, y completar algunos datos como por ejemplo: en el caso de entrar un código de artículo querremos que nos aparezca automáticamente la descripción. Para ello necesitaremos capturar un evento de la grid que nos informe que se ha modificado y actualizar la propiedad de la línea correspondiente.
Private Sub grdCnt1_UpdateSAPLine(ByVal l As ControlsSAP.SAPLines, ByVal ColumnName As String) Handles grdCnt1.UpdateSAPLine If ColumnName = "U_GSP_ItemCode" Then Dim it As SAPbobsCOM.Items it = Me._company.GetBusinessObject(oItems) it.GetByKey(Me._obj.Cnt1.ItemCode) 'Actualizamos la descripción Me._obj.Cnt1.ItemName = it.ItemName End If End Sub
Para validar por ejemplo que la cantidad inicial sea siempre menor que la cantidad final haríamos lo siguiente:
39
Cont
rols
SAP
Fram
ewor
k ®
Private Sub grdCnt1_ValidateSAPLine(ByVal l As ControlsSAP.SAPLines, _ ByVal e As DevExpress.XtraGrid.Views.Base.RowAllowEventArgs) Handles grdCnt1.ValidateSAPLine With Me._obj.Cnt1 If .QuantIn > .QuantOut Then ControlsSAP.SAPMsg.StatusBarMsg("La cantidad inicial debe de ser mayor que la cantidad final", True) e.Allow = False End If End With End Sub
Es recomendable que todas las validaciones que debamos realizar sobre los objetos de negocio se realicen dentro del propio objeto. Ya que si en otro momento lo utilizamos sin el formulario correspondiente, nos servirán las mismas validaciones y cumpliremos en cualquier entorno las reglas de negocio siempre.
40
Cont
rols
SAP
Fram
ewor
k ®
55 IImmpprreessiioonneess
El Framework de ControlsSAP dispone de utilidades para facilitar el trabajo con informes realizados con la herramienta Cystal Reports. Esto facilita la incorporación de informes en las aplicaciones realizadas.
5.1 Objeto Report
Existe un objeto Report que podemos utilizar para imprimir, previsualizar, exportar a pdf, etc., informes creados con la herramienta de Crystal Reports.
Las propiedades y métodos mas usados para este tipo de objeto son:
• ReportName: Indicaremos la ruta del fichero “rpt”. El informe deberá estar dentro de la ruta especificada en el formulario de configuración (Figura 6).
• SetParameterValue: Si el informe contiene parámetros podremos indicarle los valores a estos mediante este método.
• Print: Realiza la impresión del informe indicado en la propiedad ReportName. Si el informe incluye parámetros y no hemos indicado sus valores aparecerá un formulario de demanda (Figura 7). También se mostrará un dialogo de impresión para especificar la impresora y el numero de copias (Figura 8). Si no queremos imprimir directamente por una impresora sin mostrar el dialogo de impresión entonces utilizaremos el método DirectPrint.
• DirectPrint: Realiza la impresión directa del informe. Funcionará igual que el método Print pero sin mostrar el dialogo de impresión. Deberemos especificar una impresora y el número de copias. Si no especificamos ninguna se imprimirá una copia por la impresora por defecto.
• Preview: Realizará una impresión preliminar. Si el informe incluye parámetros y no hemos indicado sus valores aparecerá un formulario de demanda.
41
Cont
rols
SAP
Fram
ewor
k ® • SelectionFormula: Podemos indicar una formula con formato de Crystal Reports para
poder filtrar los registros por el criterio indicado.
En el constructor deberemos especificar el objeto SAPBobsCOM.Company. Este se utilizará para conectar la base de datos del informe hacia la indicada en el objeto. Por lo que podremos reutilizar cualquier informe aunque este se haya creado con una conexión diferente.
Es importante que realicemos la liberación del objeto Report con el método Dispose. Para no tener problemas posteriores de memoria.
Figura 6: Formulario de configuración. Especificar la ruta de los informes
Figura 7: Formulario de demanda de parámetros
42
Cont
rols
SAP
Fram
ewor
k ®
Figura 8
5.2 Tipo de conexión
Al diseñar informes con Crystal Reports podemos utilizar 2 tipos de conexión con la base de datos, que serán compatibles con la impresión de ControlsSAP:
• ODBC: Por defecto ControlsSAP Framework ® creará una conexión de tipo ODBC que podremos utilizar para diseñar los informes con Crystal Reports. Podemos consultar/modificar sus datos desde Gestión à Configuración.
• OleDB (ADO): Podremos utilizar los informes creados con una conexión OleDB (ADO) para SQL Server.
El sistema se encargará de reconocer que conexión utiliza el informe antes de actualizar los datos de conexión con la base de datos actual.
5.3 Versiones Crystal Reports
Podemos diseñar informes que sean compatibles con las versiones de Crystal Reports 10 o Crystal Reports para NET 2.0 o la ultima versión de Crystal Reports 2008.
El objeto Report lo podremos encontrar en una de las siguientes librerías, dependiendo de que versión de Crystal Reports que necesitemos:
• ControlsSAP.CrystalReports.v10.dll
• ControlsSAP.CrystalReports.v12.dll
43
Cont
rols
SAP
Fram
ewor
k ® Podremos utilizar una u otra, o las dos a la vez. En estas librerías encontraremos el objeto
Report. El objeto lo encontraremos en el namespace:
• ControlsSAP.CrystalReports .Cr10.Report
• ControlsSAP.CrystalReports .Cr12.Report
5.4 Visor de informes
Cada visor incluirá su propia barra de herramientas, además podremos utilizar también la barra de herramientas de SAP o del formulario de aplicación si estamos por fuera.
5.5 Configurar informes en formularios
Existen propiedades y métodos en los formularios de tipo FormSAP, que nos permitirán añadir internamente informes para posteriormente poderlos previsualizar o imprimir. También permitiremos añadir informes externamente a nivel de usuario, pudiendo duplicar informes existentes o añadiendo nuevos.
Para utilizar esta nueva funcionalidad deberemos activar la propiedad UseSystemPrinting. Por defecto esta propiedad estará a “False”, por lo que al pulsar sobre imprimir/previsualizar se ejecutará el método OnPrint y el evento PrintingForm. Pero si queremos utilizar esta funcionalidad esta propiedad deberá estar a “True”, y ya no se ejecutarán los métodos y eventos anteriormente mencionados.
44
Cont
rols
SAP
Fram
ewor
k ® Para añadir un informe tenemos una propiedad Reports que nos permitirá añadir varios
informes al formulario del siguiente modo:
Me.Reports.Add("Facturas", New cr12.Report(GetType(misfacturas), Me._company)) Me.Reports.Add("Factura2", New cr12.Report(GetType(factura1), Me._company), _ New CrystalReportsParameter("Code", Me.txtCode))
Public Sub Add(Description as String,
ReportObj AS ControlsSAP.CrystalReports.IReport,
ParamArray Parameters CrystalReportsParameter())
Description: Descripción que le daremos al informe. Deberá ser única para los informes del formulario.
ReportObj: Instanciaremos un objeto Report indicándole el tipo de la clase que hace referencia al informe CrystalReports, y la company desde la que obtendrá los datos.
Parameters: Lista de parámetros que queramos pasar a el informe en el momento de imprimirlo. Los parámetros podrán ser de tipo Discreto o de tipo Rango. Necesitaremos indicar el nombre del parámetro y de que control del formulario obtendremos el valor. También podremos pasar valores constantes.
Para poder incluir informes dentro de nuestros proyectos y así utilizarlos como una clase deberemos tener instalado alguna versión de Crystal Reports que incluya herramientas de integración para Visual Studio.
Podemos obtener una desde la herramienta de instalación de Visual Studio 2005, marcando la casilla Crystal Reports para Visual Studio que instalará las librerías para Crystal Reports 10 (Figura 9).
45
Cont
rols
SAP
Fram
ewor
k ®
Figura 9: Crystal Reports para Visual Studio 2005
Si tenemos esta funcionalidad ya podremos anexar documentos *.rpt en nuestro proyecto. Al anexarlos al proyecto automáticamente se generará una clase *.vb que utilizaremos para hacer referencia a estos informes.
Con esto ya tendríamos definidos varios informes de sistema. Ahora podríamos definir otros informes de usuario, propios para cada tipo de cliente. Para ello utilizaremos el botón del diseñador de layaouts de SAP (Figura 10: Diseñador de informes).
46
Cont
rols
SAP
Fram
ewor
k ®
Figura 10: Diseñador de informes
Desde el diseñador podremos realizar las siguientes acciones:
Fijar como estándar: Podremos definir que formulario queremos fijar por defecto. Podremos indicar si lo queremos para todos lo usuarios o solamente para el usuario actual.
Si algún usuario tuviera una configuración propia no se le cambiaría si indicamos que lo queremos para todos los usuarios. Solamente afectara cuando el usuario no tenga ningún informe definido por defecto para el.
Duplicar: Creará una copia del informe seleccionado en un archivo rpt, en la ruta de los informes indicada en la configuración.
Nuevo informe: Podremos añadir un nuevo informe de CrystalReports. Para ello deberemos indicar una descripción que no se podrá repetir y seleccionar un informe rpt que creará una copia en la ruta de los reports.
Una vez seleccionado el fichero con el report aparecerán los parámetros de este. Si queremos que el parámetro este relacionado con algún control del formulario deberemos indicar el nombre de este control. Si por lo contrario queremos indicar un valor fijo se lo indicaremos entre llaves ({Valor}), y si lo dejamos en blanco entonces en el momento de la impresión se lo pedirá al usuario.
También podremos indicar el número de copias por defecto. Si indicamos una impresora fija se imprimirá directamente por ella, si lo dejamos en blanco en el momento de imprimir aparecerá el dialogo de impresión con la impresora por defecto del sistema.
47
Cont
rols
SAP
Fram
ewor
k ®
Figura 11: Añadir un nuevo informe.
Editar: Permitirá editar una informe de usuario. Los informes de sistema no se pueden modificar. Si queremos variar algún valor deberemos duplicar el informe y entonces editar el nuevo informe de usuario.
Eliminar: Eliminaremos el informe de usuario seleccionado.
Diseñar: Permite abrir el informe para su diseño siempre y cuando tengamos las herramienta de Crystal Reports instalada en la máquina.
Una vez configurados los informes si pulsamos previsualizar nos aparecerá una lista con los informes incluidos en el formulario.
Si pulsamos el botón de imprimir , imprimiremos el informe considerado por defecto.
48
Cont
rols
SAP
Fram
ewor
k ®
66 MMeennssaajjee ddee ssiisstteemmaa
Disponemos de una serie de mensajes de sistema con la apariencia de SAP Business One, para facilitar la comunicación entre el usuario y la aplicación.
Existirán diferentes tipos de mensajes:
• Informativo
• Aviso
• Decisión
• Error
• Acción
• Entrada de datos
6.1 Mensajes de dialogo
Existen una serie de mensajes ya definidos según el tipo de mensaje que queramos mostrar:
Ico Tipo
SAPMsg.Question
SAPMsg.Alert
SAPMsg.Critical/Exception
SAPMsg.Info
Podemos configurar nuestro propio mensaje con la función SAPMsg.Show indicando el mensaje, el icono, los botones.
Pulsando <Control + C> al aparecen una mensaje del tipo SAPMsg, podremos copiar el texto del mensaje.
49
Cont
rols
SAP
Fram
ewor
k ® Para utilizar mensajes que muestren excepciones capturadas podemos utilizar la función
SAPMsg.Show y pasarle la excepción. Este tipo de mensajes permite que haciendo doble clic sobre el mensaje de error, poder visualizar la pila de la excepción (Figura 12: Mensaje mostrando la excepción completa.).
Figura 12: Mensaje mostrando la excepción completa.
6.2 Mensajes en la barra de estado
También se han añadido los 3 tipos de mensaje que se pueden indicar en la barra de estado mediante la función SAPMsg.StatusBar.
Confirmación/Success
Error
Información/Warning
6.3 InputBox
Este tipo de mensaje de sistema nos permitirá obtener un valor del usuario con el método ControlsSAP.SAPMsg.InputBox.
50
Cont
rols
SAP
Fram
ewor
k ®
Figura 13: Ejemplo InputBox de tipo fecha.
Dim d As DateTime d = SAPMsg.InputBox( _ "Hasta que fecha quieres eliminar los registros del 'Log de modificaciones'", _ SAPMsg.InputType.Date, Today)
51
Cont
rols
SAP
Fram
ewor
k ®
77 AAuuttoorriizzaacciioonneess
ControlsSAP Framework proporciona una serie de funcionalidades integradas con SAP Business One que permiten definir autorizaciones de usuario para mostrar o no las pantallas definidas con la herramienta. Estas autorizaciones se configurarán desde el formulario de autorizaciones de SAP Business One.
7.1 Definición
Al arrancar un módulo de trabajo, se generará una autorización de usuario, por cada formulario que cargue nuestra aplicación de manera automática.
Estas autorizaciones se modificarían desde la pantalla de SAP Gestión à Inicialización sistema à Autorizaciones à Autorizaciones generales, desde las autorizaciones de usuario (Figura 14).
Será necesario definir un atributo por cada formulario con una descripción (máximo 40 caracteres) que defina el formulario. Si no se especifica ningún atributo la descripción de la autorización será la misma que el nombre del formulario. El atributo que utilizaremos será ControlsSAP.Forms.FormDescription.
Por defecto todos los formularios estarán controlados mediante autorizaciones. Si queremos que un formulario determinado no este sujeto a ningún tipo de autorización (podrá abrirlo cualquier usuario) utilizaremos el atributo ControlsSAP. Authorizations.AuthorizationExempt.
52
Cont
rols
SAP
Fram
ewor
k ®
Figura 14
Por defecto todas las autorizaciones nuevas que se creen lo harán por defecto con “Autorización total”.
7.2 Creación
De momento para que se creen automáticamente las autorizaciones de todos los formularios de una librería, es necesario cambiar el AssemblyDataBaseVersion para provocar una actualización y que exista en el modulo algún objeto para crear en la base de datos ya sea una tabla, campo, vista, etc. desde el FormDLL (ver capitulo Módulos de trabajo).
Existirá una opción en el menú administrador, para crear/actualizar estas autorizaciones, de manera manual.
53
Cont
rols
SAP
Fram
ewor
k ®
88 PPaarráámmeettrrooss
Existe una clase por la que podemos crear de una manera fácil objetos que contendrán una lista de parámetros que nos puede servir para la parametrización del módulo. Sin la necesidad de crear nuevos objetos y ni tablas en la base de datos.
Estos se podrán modificar ya sea desde el propio objeto o por el usuario de la aplicación mediante el formulario de Parámetros en el menú Gestión.
8.1 Creación de parámetros
Nuestros módulos podrán tener una lista de parámetros con los que poder interactuar. Para ello definiremos en nuestro proyecto una clase que herede de ControlsSAP.Parameters.ApplicationParameters y definiremos una lista de variables, cada una con el atributo ControlsSAP.Parameters.ParameterAttribute. Donde podremos especificar:
• El tipo de parámetro que normalmente coincidirá con el tipo de la variable.
• El nombre del parámetro (opcional).
• Descripción.
• Valor por defecto.
• Visibilidad del parámetro. Si es un parámetro de sistema solamente será posible modificarlo entrando en la aplicación en modo Administrador.
• Comentarios.
Podemos indicar al parámetro datos extras mediante otros atributos como Data y Mask:
• Una sentencia SQL con los valores validos para el parámetro.
• Una lista de valores que serán los valores validos que puede aceptar el parámetro.
54
Cont
rols
SAP
Fram
ewor
k ® • Una mascara de entrada de datos.
Podemos ver un ejemplo de cómo definir una clase con 2 parámetros:
Imports ControlsSAP Imports ControlsSAP.Parameters Imports ControlsSAP.Parameters.ParameterType Public Class Parametros1 Inherits ControlsSAP.Parameters.ApplicationParameters Public Sub New(ByVal c As SAPbobsCOM.Company) MyBase.New(c) End Sub ' Cantidad inicial <Parameter([Integer], _ "Cantidad inicial", _ 5, False, _ "Cantidad mínima inicial ")> _ Public CANTINI As Integer ' Ruta plantillas <Parameter([String], _ "Ruta plantillas", _ "C:\Plantillas", False, _ "Ruta compartida donde estarán las plantillas de contratos")> _ Public PATHPLANT As String End Class
Ejemplos para indicar un origen de datos con el atributo ControlsSAP.Parameters.Data. El origen podrá ser una sentencia SQL, o una lista de valores del mismo tipo definido en la variable:
'Valores posibles: Numeros par del 0 al 20 <Parameter([Integer], ...)> _ <Data(0, 2, 4, 8, 10, 12, 14, 16, 18, 20)> _ Public NumeroPar As Integer
'Valores posibles: Las listas de precios <Parameter([Integer], ... > _ <Data("SELECT ListNum, ListName FROM OPLN"> _ Public ListaPrecios
55
Cont
rols
SAP
Fram
ewor
k ® Existe otro tipo de atributo ControlsSAP.Parameters.Mask. Con los que podremos definir
mascaras con expresiones regulares, para la entrada de datos desde el formulario de parámetros.
Ejemplo:
'Solamente se podrán introducir direcciones ftp <Parameter([String], ...)> _ <Mask("ftp\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S+)?")> _ Public DireccionFtp As String
8.2 Utilización de parametros
Para modificar los valores lo podremos hacer desde código o mediante el formulario de edición de parámetros (Figura 15) que hay en GestiónàParámetros, donde estarán todos los parámetros de los módulos añadidos.
Dim p As Parametros1 p = New Parametros1 (c) p. PATHPLANT="C:\Plantillas\Demo" p.Save()
Para que nuestra clase parámetros aparezca en el formulario de edición de parámetros que trae el framework de ControlsSAP y podamos editarlos es necesario que en algún momento del arranque de la aplicación, registremos una instancia de nuestra clase con:
ControlsSAP.Register.Parameter(ApplicationParameter)
Public Overrides Sub Run() ... ControlsSAP.Register.Parameter(DLL.GetParameters(c)) End Sub
56
Cont
rols
SAP
Fram
ewor
k ®
Figura 15
Desde la clase ApplicationParameters, donde definimos los parámetros de nuestro módulo, podremos indicarle al constructor el nombre de una categoría por la que se agruparán los parámetros de un mismo módulo, cuando se muestren desde el formulario de parámetros (Figura 16).
Public Class ParemetersDemo Inherits ControlsSAP.Parameters.ApplicationParameters Public Sub New(ByVal c As SAPbobsCOM.Company) MyBase.New(c, "Demo Categoria") End Sub ...
57
Cont
rols
SAP
Fram
ewor
k ®
Figura 16
Por lo que podremos tener registrados en un mismo módulo/librería varias clases de parámetros. Que se localizarán en la misma pestaña y se agruparán por las categorías indicadas.
Grupo 1
Grupo 2
58
Cont
rols
SAP
Fram
ewor
k ®
99 MMóódduullooss ddee ttrraabbaajjoo
Nuestras aplicaciones pueden crear en el arranque varios tipos de objetos newcesarios para el inicio de la aplicación, como son:
• Objetos que se deben crear en la base de datos (tablas, vistas, campos, búsquedas formateadas, etc.)
• Opciones de menú
• Lista de Parámetros
• Autorizaciones para los formularios
Que dejarán la aplicación preparada para comenzar a trabajar con ella sin la necesidad de realizar ninguna acción extra.
Objetos definidos en la base de datos
Modulo Versión DLL Versión Fichero
Versión DB: 2009.0.0.0
Menús
Parámetros Autorizaciones
59
Cont
rols
SAP
Fram
ewor
k ® 9.1 Creación de un módulo
Para crear nuestro modulo deberemos utilizar un objeto de tipo formulario, que utilizaremos para definir el menú de la aplicación y sus objetos a crear en la base de datos.
Tendremos que crear un formulario del tipo ContolsSAP.Forms.FormDLL. Utilizaremos el diseñador del formulario para crear el menú de nuestro modulo añadiendo varios MenuStrip para cada tipo de menú.
9.2 Creación de los Menús
Un módulo podrá constar de 3 tipos diferentes de menús:
• Menú de aplicación: Será el menú principal que utilizará el usuario de la aplicación.
• Menú definición: Este es el menú que aparecerá dentro del menú Gestión à Definición y que utilizaremos para añadir las opciones referentes a la creación de datos maestros. Parecido al menú que definición que aparece en SAP.
• Menú administrador: Este menú solamente lo podrán visualizar los programadores y nos servirá para ocultar determinadas opciones al usuario.
Para diseñar cada tipo de menú utilizaremos el control MenuStrip (propios de .NET) según nuestras necesidades.
En cada MenuStrip añadido podremos definir una o varias opciones de menú y submenús.
Existirá 3 propiedades en la clase FormDLL para especificar si el menú es de aplicación, definición o de administrador:
• MenuAdminStrip
• MenuApplicationStrip
• MenuDefinitionStrip
60
Cont
rols
SAP
Fram
ewor
k ®
9.3 Creación de la base de datos
Nuestro modulo necesitará definir una serie de objetos en la base de datos de SAP para funcionar correctamente. Los objetos se crearán la primera vez que arranque el módulo o cuando se detecte un cambio de versión lo que provocará que se creen o actualicen aquellos objetos que se han añadido o modificado.
En próximos capítulos veremos más extensamente que objetos utilizaremos para crear tablas, campos, vista, etc.… en la base de datos.
61
Cont
rols
SAP
Fram
ewor
k ® Desde nuestro formulario iremos añadiendo todos los objetos necesarios para poder ejecutar
nuestro modulo y en el momento del arranque estos se crearán si es necesario. Para esto existe la propiedad DataBase que nos proporciona un objeto de tipo lista, para ir añadiendo tablas, campos y demás objetos que deberá crear nuestro modulo al arrancar o al cambiar de versión.
Deberemos sobrescribir el método CreateDataBaseObjects() e ir añadiendo las tablas y campos. Los objetos se definirán igual que lo haríamos desde el diseñador de SAP (sin el ‘@’ delante de las tablas y sin el ‘U_’ delante de los campos).
Definiremos 2 tablas con sus diferentes campos:
Public Overrides Sub CreateDataBaseObjects() MyBase.CreateDataBaseObjects() With Me.DataBase.AddTable("GSP_CNTR", "Contratos").Fields .AddAlfanumerico("GSP_CardCode", "Código cliente", 50) .AddAlfanumerico("GSP_CardName", "Nombre", 100) .AddFecha("GSP_DataIn", "Fecha inicio") .AddFecha("GSP_DateOut", "Fecha de fin") .AddMemo("GSP_Comments", "Comentarios") End With With Me.DataBase.AddTable("GSP_CNT1", "Lineas de contratos").Fields .AddAlfanumerico("GSP_CntrCode", "Cód.contrato", 8) .AddAlfanumerico("GSP_ItemCode", "Cod. Artículo", 50) .AddAlfanumerico("GSP_ItemName", "Descripción", 150) .AddCantidad("GSP_QuantIn", "Cantidad inicial") .AddCantidad("GSP_QuantOut", "Cantidad final") .AddImporte("GSP_Import", "Importe") End With End Sub
Podemos añadir a la lista objetos de tipo:
• Tablas: dentro de cada tabla podemos añadir objetos como campos, valores validos, e índices.
• Vistas
• Procedimientos almacenados
• Acciones SQL: como inserts, updates, deletes.
• Categorías SAP: dentro de cada categoría podemos definir búsquedas formateadas, consultas predefinidas.
62
Cont
rols
SAP
Fram
ewor
k ® 9.4 Control de versiones
Para el control de versiones existe un mecanismo mediante un atributo de ensamblado por el cual el programador podrá modificar e indicará que el modulo en cuestión debe ser actualizado. Este se deberá indicar en el archivo AssemblyInfo del proyecto.
<Assembly: ControlsSAP.AssemblyDataBaseVersion("2007.0.0.12")>
En el momento de arrancar se detectará si se ha modificado la versión o si es un nuevo módulo por lo que se avisará al usuario que se van a ejecutar modificaciones en SAP. De esta manera no hará falta que el consultor o los usuarios de SAP sepan que campos o tablas se tienen que crear en una nueva versión.
9.5 Creación de parámetros
Nuestros módulos podrán tener una o varias listas de parámetros con los que poder interactuar.
Para que nuestras clases de parámetros estén disponibles desde el formulario de edición que trae el framework de ControlsSAP es necesario que en algún momento de la carga inicial registremos una instancia de nuestra clase con:
ControlsSAP.Register.Parameter(ApplicationParameter)
Ejemplo de registro de los parámetros desde la carga del pluggin.
Public Overrides Sub Run() ... ControlsSAP.Register.Parameter(DLL.GetParameters(c)) End Sub
63
Cont
rols
SAP
Fram
ewor
k ®
9.6 Arranque de un módulo de trabajo
Una vez creado el formulario que contendrá el módulo definiremos una clase (por norma general se llamará DLL) con un método –LoadDLL- que retornará un objeto LibraryDLL que utilizaremos mas adelante.
Public Class DLL Public Shared Function GetParameters(ByVal c As Company) As Parametros1 Return New ParemetersDemo(c) End Function Public Shared Function LoadDLL(ByVal c As SAPbobsCOM.Company) As ControlsSAP.Forms.FormDLL.LibraryDLL ControlsSAP.Register.Parameter(DLL.GetParameters(c)) Dim f As New frmDLL(c) Return f.GetMenuDLL End Function End Class
Después si lo que queremos el cargar el modulo creado dentro de SAP Business One crearemos un Pluggin y en el momento de ejecutar el Run realizaremos 3 acciones:
1. Conectaremos al AddOn mediante AddOnConnection()
64
Cont
rols
SAP
Fram
ewor
k ® 2. Cargaremos los módulos que necesite nuestra aplicación
(AddModule/AddItemsModule)
3. Arrancaremos una aplicación que creará un nuevo punto de menú en SAP B1 incluyendo las opciones de menú de los módulos cargados hasta ese momento.
Imports ControlsSAP Imports ControlsSAP.SapUI <PluginEngine.Plugin("Demo2005", "DemoProject2005", _ "Integracion AddOn DemoProject2005", "Oliver Parra", "1.0")> _ Public Class WinFormDemoPlugin Inherits Addon2Core.PluginEngine.CPlugin Public Overrides Sub Run() Try 'Conecta la libreria ControlsSAP con el AddOn AddOn.AddonConnection() 'Carga de los modulos que tendra nuestra 'aplicación en SAP Business One AddOn.AddItemsModule( _ DLL.LoadDLL(Addon2Core.Addon.CB1App.Company)) 'Arranca una aplicación con los módulos 'cargados hasta ese momento ControlsSAP.SapUI.AddOn.Start("SBO_OneDemo2") Catch ex As Exception SapMsg.Show(ex) End Try End Sub End Class
65
Cont
rols
SAP
Fram
ewor
k ®
66
Cont
rols
SAP
Fram
ewor
k ®
1100 IInntteeggrraacciióónn
10.1 Estilo 8.8
Las pantallas se repintarán según el estilo elegido en SAP Business One. Sin la necesidad de realizar ninguna modificación desde el diseñador de código.
• Estilo clásico:
• Nuevo Estilo 8.8:
67
Cont
rols
SAP
Fram
ewor
k ® 10.2 Fuente, tamaño de letra y color de las pantallas
En el momento de abrirse los formularios se mostrarán con la configuración de fuente y color establecidos en SAP Business One.
En modo diseño se continuaría diseñando las pantallas tal y como hasta ahora. Para que se pueda utilizar esta nueva funcionalidad el formulario debe tener la propiedad AutoScaleMode a Font. Por defecto los formularios ya se crean con este valor.
10.3 Textos Dinámicos (Control + Doble-Click)
Se podrán modificar los textos de las etiquetas de algunos controles, tal y como hace SAP, pulsando {CONTROL} y haciendo DOBLE-CLICK con el ratón.
Los controles con esta función habilitada serán:
• SAPLabel (etiquetas)
• SAPTabPage (Pestañas)
• SAPRadioButton/SAPCheckBox
• Columnas de la grid
Esta funcionalidad se grabará en la base de datos donde se conecte por defecto el AddOn.
68
Cont
rols
SAP
Fram
ewor
k ® 10.4 Menús para SAP Business One
Para crear nuestro menú de aplicación desde el formulario FormDLL existirá un tipo de control que nos permitirá añadir la opción de menú dentro de unas coordenadas específicas en el menú de SAP.
La propiedad que utilizaremos para ello será SapLocation desde la que podremos especificar:
• ParentUID: Identificador del menú padre de la que colgara nuestra opción. Si no se especifica ningún valor, se pintará la opción en su lugar por defecto. Si se especifica 0 o el valor 43520 se añadirá en el menú raíz.
• Position: Posición que ocupará nuestra opción dentro de las opciones que cuelgan de menú indicado en el ParentUID. Si la posición es -1, la opción se añadirá al final.
Para poder utilizar este nuevo control en opciones ya creadas, podemos convertir la opción de menú a SAPMenuItem fácilmente. Desde la opción “Convertir en...” en el menú contextual que existe en el diseñador de menús de Visual Studio haciendo clic derecho sobre el control.
Nuevo tipo de menú
69
Cont
rols
SAP
Fram
ewor
k ®
1111 DDaattaabbaassee
En este capitulo veremos una serie de objetos que podemos crear en la base de datos de SAP Business One. Todos ellos implementan una interficie que incluye un método Execute. Que sirve para crear/actualizar el objeto en la base de datos.
Si necesitamos crear en un momento dado cualquiera de estos objetos utilizaríamos este método. Pero lo normal será que se creen los objetos en el momento de arranque del módulo. Y para ello en vez de utilizar el método Execute lo que haríamos es añadir los objetos en la colección FormDLL.DataBase dentro del método FormDLL.CreateDataBaseObjects.
11.1 Tablas, campos, índices
Podemos crear tablas en SAP Business One con el objeto SAPUserTable. Indicándole un nombre y una descripción.
11.1.1 Campos Para definir los campos utilizaremos la colección Fields.
Podemos definir campos con los métodos siguientes:
• AddAlfanumerico: Añade un campo de tipo alfanumérico.
• AddBooleano: Añade un campo alfanumérico de longitud 1 carácter, con los valores válidos (Y)es/(N)o.
• AddCantidad: define un campo de tipo cantidad.
• AddImporte: crea un campo en la tabla de tipo importe.
• AddPrecio: define un campo de tipo precio.
• AddFecha: define un campo de tipo fecha.
• AddHora: define un campo de tipo hora.
70
Cont
rols
SAP
Fram
ewor
k ® • AddLinkTable: define un campo alfanumérico de 8 caracteres, vinculado a una tabla de
usuario.
• AddMemo: crea un campo de tipo texto.
• AddNumerico: añade un campo de tipo numérico de una longitud indicada.
• AddPorcentaje: crea un campo de tipo porcentaje.
Estas instrucciones devuelven un objeto de tipo SAPUserField, que podemos utilizar para añadir varios valores validos.
11.1.2 Índices Desde el objeto SAPUserTable podemos también definir índices desde la propiedad Keys.
Podemos definir 2 tipos de índices:
• AddIndex: Añade un índice a la tabla. Indicaremos el nombre del índice y la lista de campos que lo componen. Los campos se indicarán sin el ‘U_’.
• AddUniqueIndex: Añade un índice como el anterior pero este de tipo único.
11.2 Vistas
Para crear vistas en la base de datos utilizaremos el objeto SAPView. Deberemos indicar el nombre de la vista y la consulta SQL.
11.3 Procedimientos almacenados
Para definir procedimientos almacenados utilizaremos el objeto SAPProcedure. Indicaremos el nombre del procedimiento a crear y la sentencia SQL que lo compone.
11.4 Sentencia SQL
Para realizar sentencias SQL como INSERT, UPDATE, DELETE, disponemos de método ControlsSAP.DoAction, que realiza la acción en el instante. Pero si lo que queremos es que se ejecuten este tipo de sentencias SQL en el momento de la carga de la aplicación, por ejemplo insertar valores por defecto después de crear una tabla, entonces la sentencia anterior no nos serviría. Para esto existe el objeto SAPAction donde indicaremos la acción a realizar y la añadiremos junto con los demás objetos en el momento de crear.
71
Cont
rols
SAP
Fram
ewor
k ® El objeto SAPAction no esta pensado para realizar acciones en la base de datos fuera de los
formularios de tipo FormDLL (para añadirlos en el objeto Database). Para realizar este tipo acciones se debe utilizar la función ControlsSAP.DoAction.
11.5 Categorías, consultas predefinidas, búsquedas formateadas
Podemos añadir consultas predefinidas, y búsquedas formateadas propias de SAP. Para ello deberemos añadir primero una categoría. Utilizaremos el objeto SAPQueryCategories indicando un nombre.
La estructura de estos objetos en SAP es la siguiente:
11.5.1 Consultas predefinidas Desde el método AddQuery del objeto SAPQueryCategories crearemos una consulta predefinida de SAP de tipo SAPUserQuery. Deberemos indicarle un nombre a la consulta y la sentencia SQL a ejecutar.
Podremos añadir al objeto SAPUserQuery búsquedas formateadas de SAP.
11.5.2 Búsquedas formateadas Para añadir búsquedas formateadas propias de SAP Business One necesitaremos añadirlas desde el objeto SAPUserQuery. Con el método AddFormatedSearch asignaremos estas búsquedas a las consultas de SAP.
Dim q As New SAPQueryCategories(Me.Company, "Consultas Generales") With q With .AddQuery("ConsultaFamilias", _ "SELECT Code, Name FROM [@GSP_FAMILIES] WHERE U_GSP_GroupCode = $[OITM.ItmsGrpCod]") .AddFormattedSearch("150", "U_GSP_FAMILIA") End With End With
Categorías
Consultas predefinidas
Búsquedas formateadas