Manual de programador _ControlsSAP.pdf

ControlsSAP Framework
Manual
Operativo
V2007.9
Por Oliver Parra

ControlsSAP Framework ®
Í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
2

ControlsSAP Framework ®
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
3

ControlsSAP Framework ®
1 Introducción a ControlsSAP
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.
4

ControlsSAP Framework ®
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
5

ControlsSAP Framework ®
2 Objetos de negocio
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
O. Detalle
O.Detalle
O.Detalle
6
D.B.

ControlsSAP Framework ®
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.
Object:
Methods:
+Add
+GetByKey
+Remove
+Update
…
Properties:
Browser
…
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.
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.
7

ControlsSAP Framework ®
Public Class Contract
Inherits ControlsSAP.SAPObject
End Sub
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()
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.
8

ControlsSAP Framework ®
Object:
Methods:
+Add
+SetCurrentLine
+Delete
Properties:
Count
…
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.
Devuelve el total de líneas.
9

ControlsSAP Framework ®
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)
10

ControlsSAP Framework ®
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
Dim cont As Contract
cont = New Contract(Me.Company)
Listado 5: Ejemplo creación registro.
'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
11

ControlsSAP Framework ®
• 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
'...
_
_
_
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
_
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 ")
12

ControlsSAP Framework ®
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:
13

ControlsSAP Framework ®
2.6.1 Altas/Modificaciones
Add/Update
Validaciones internas
Validating
Adding/Updating
14
Mandatory
HasRelation
NonUpdatable
...
Por cada línea del SAPLines añadida/modificada:
Recorre las líneas
ValidatedLines
Added/Updated
SavingLine
ValidatingLine
Base de
Datos

ControlsSAP Framework ®
2.6.2 Eliminaciones
Remove()
Removing
Eliminamos cada línea del SAPLines:
Recorre las líneas
Removed
15
Delete()
Base de
Datos

ControlsSAP Framework ®
3 Diseño de pantallas
visuales
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.
16

ControlsSAP Framework ®
3.1.1 SAPTextBox
• 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.
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
Numero
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.
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.
17

ControlsSAP Framework ®
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:
18

ControlsSAP Framework ®
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.
19

ControlsSAP Framework ®
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”.
20

ControlsSAP Framework ®
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 ‘%’
21

ControlsSAP Framework ®
• 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
22

ControlsSAP Framework ®
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.
23

ControlsSAP Framework ®
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.
24

ControlsSAP Framework ®
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.
25

ControlsSAP Framework ®
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.
26

ControlsSAP Framework ®
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.
27

ControlsSAP Framework ®
• 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.
28

ControlsSAP Framework ®
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.
29
Browser
Base de
datos

ControlsSAP Framework ®
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
30

ControlsSAP Framework ®
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:
3.2.4 FormSAPAlta
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.
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.
31

ControlsSAP Framework ®
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.
32

ControlsSAP Framework ®
Figura 3: Ejemplo FormApplicacion.
33

ControlsSAP Framework ®
4 Formulario de edición
(FormEditSAP)
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.
34

ControlsSAP Framework ®
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.
End Sub
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
Listado 13: Ejemplo constructor de un FormEditSAP.
35

ControlsSAP Framework ®
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.
36

ControlsSAP Framework ®
'Creación del objeto de negocio y obtención de los datos
_obj = New Contract(_company)
Me.GetAllObjects(_obj)
Me.GoToLast()
4.3 Entrada/Salida de datos
Listado 16: Carga de datos en el objeto de negocio.
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.
37

ControlsSAP Framework ®
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:
38

ControlsSAP Framework ®
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.
39

ControlsSAP Framework ®
5 Impresiones
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.
40

ControlsSAP Framework ®
• 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
41

ControlsSAP Framework ®
5.2 Tipo de conexión
Figura 8
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
42

ControlsSAP Framework ®
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.
43

ControlsSAP Framework ®
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).
44

ControlsSAP Framework ®
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).
45

ControlsSAP Framework ®
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.
46

ControlsSAP Framework ®
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.
47

ControlsSAP Framework ®
6 Mensaje de sistema
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 al aparecen una mensaje del tipo SAPMsg, podremos copiar el texto del
mensaje.
48

ControlsSAP Framework ®
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.
6.3 InputBox
49
Confirmación/Success
Error
Información/Warning
Este tipo de mensaje de sistema nos permitirá obtener un valor del usuario con el método
ControlsSAP.SAPMsg.InputBox.

ControlsSAP Framework ®
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)
50

ControlsSAP Framework ®
7 Autorizaciones
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.
51

ControlsSAP Framework ®
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.
52

ControlsSAP Framework ®
8 Parámetros
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.
53

ControlsSAP Framework ®
• 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
_
Public CANTINI As Integer
' Ruta plantillas
_
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
_
_
Public NumeroPar As Integer
'Valores posibles: Las listas de precios
_
_
Public ListaPrecios
54

ControlsSAP Framework ®
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
_
_
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
55

ControlsSAP Framework ®
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
...
56

ControlsSAP Framework ®
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.
57
Grupo 1
Grupo 2

ControlsSAP Framework ®
9 Módulos de trabajo
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.
Modulo
Versión DLL
Versión Fichero
Versión DB: 2009.0.0.0
Parámetros Autorizaciones
58
Menús
Objetos definidos
en la base de
datos

ControlsSAP Framework ®
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
59

ControlsSAP Framework ®
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.
60

ControlsSAP Framework ®
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.
61

ControlsSAP Framework ®
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.
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
62

ControlsSAP Framework ®
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()
63

ControlsSAP Framework ®
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
_
Public Class WinFormDemoPlugin
Inherits Addon2Core.PluginEngine.CPlugin
Public Overrides Sub Run()
Try
End Sub
End Class
'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
64

ControlsSAP Framework ®
65

ControlsSAP Framework ®
10 Integración
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:
66

ControlsSAP Framework ®
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.
67

ControlsSAP Framework ®
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.
68
Nuevo tipo de menú

ControlsSAP Framework ®
11 Database
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.
69

ControlsSAP Framework ®
• 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.
70

ControlsSAP Framework ®
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:
Categorías
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
Consultas predefinidas
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
71
Búsquedas formateadas