Introducción
Bizagi presenta el Asistente de Replicación en cual le ayudará en la configuración de la conexión de una base datos externa SQL Server u Oracle (para integración a nivel de datos).
Para otra fuente de datos diferente a SQL Server y Oracle, se puede sobrescribir los métodos y clases utilizado por Bizagi en la Replicación.
¿Qué se debe hacer?
Para poder utilizar la Replicación de Bizagi con una fuente de datos externa diferente a SQL Server u Oracle se debe seguir los siguientes pasos:
1. Crear una librería de Replicación.
A través de una librería personalizada, usted podrá sobrescribir las clases y métodos de replicación de Bizagi (como se describe en la siguiente sección: Sobrescribir de Clases y Métodos).
2. Configurar el proveedor de datos de Bizagi para utilizarlo en la librería personalizada de Replicación.
Esta configuración utiliza la configuración estándar de Bizagi para replicaciones en Bizagi.
Sobrescribir de Clases y Métodos
Para personalizar la virtualización de Bizagi, es necesario desarrollar un componente que implemente las interfaces:
•ICustomProviderDA
•ICustomQueryDA
•ICustomReplicationDA
•IDatabaseProperties
Bizagi separa la operación de conexión, desconexión y administración transaccional de la operación de la búsqueda, de datos desde el proveedor de datos externos y de las interfaces de la entidad. Es decir, cuando se crea una librería de Replicación personalizada, Bizagi sigue las mejores prácticas para la gestión y diseño de la implementación.
Interfaz del proveedor: ICustomProviderDA
La clase que invoca la interfaz debe contener los siguientes métodos:
•void Init (Dictionary<string, string> metadata): A cargo de tomar la información suministrada, como el nombre del servidor, el nombre de la base de datos, usuario, contraseña, etc. La clase recibe el objeto Dictionary<string, string>, el cual contiene los datos configurados como metadata del sistema.
•void OpenConnection(): Este método es utilizado para realizar la conexión con el sistema externo. En el caso de una base de datos, el método construye los enlaces de la conexión y abre la conexión con el repositorio.
•void CloseConnection(): A cargo de cerrar la conexión con el sistema de datos externos.
•void BeginTransaction(): A cargo de iniciar una nueva transacción para la operación actual del sistema.
•void Commit(): Realizar commit de la transacción actual en el sistema de referencia.
•void Rollback(): Realizar un rollback (regresar al estado inicial) de la transacción actual del sistema de referencia.
Interfaz del proveedor: ICustomQueryDA
La clase que invoca la interfaz debe contener los siguientes métodos:
•void AddParameter (string parameterName, BizagiDataType dataType, int size, byte precision, byte scale, object value, ParameterDirection parameterDirection): A cargo de adicionar parámetros al query que será ejecutado.
•void ClearParameters(): Elimina los parámetros presentes en el query.
•DataSet RunQuery(string query, string tableName): Se usa para consultar los valores de la fuente de datos externa. La lógica es equivalente a hacer un query sobre los campos del objeto.
Interfaz de la entidad: ICustomReplicationDA
La clase que invoca la interfaz debe contener los siguientes métodos:
•void Init(ICustomProviderDA provider): Inicia la conexión con el sistema.
Parámetros |
Descripción |
|---|---|
provider |
Permite convertir el objeto que invoca la interfaz ICustomProviderDA. |
•DataSet GetEntity(string entitySource, string[] columnList, string optionalSourceFilter): Utilizado como consulta de los valores de la fuente de datos externa. Esto es equivalente a realizar una consulta en los campos del objeto sin tener que aplicar filtros.
Parámetros |
Descripción |
|---|---|
entitySource |
Nombre de la tabla a replicar en la fuente de datos. |
arrsColList |
Arreglo que contiene el nombre de las columnas de la consulta en la fuente de datos. |
optionalSourceFilter |
Contiene la clausula where para consultar en la fuente de datos. |
RETURNED DataSet |
Un DataSet con los valores de la entidad. |
Interfaces de constantes: IDatabaseProperties
Tenga en cuenta que Bizagi construirá el query y su sintaxis.
Para ello, debe necesariamente definir todas las constantes que se usan en la sintaxis del motor de la Base de datos.
Ejemplo
En el ejemplo, vamos a configurar una replicación personalizada para un motor de base de datos MySQL.
Vamos a presentar un ejemplo de las clases de replicación que implementan las interfaces "ICustomProviderDA", "ICustomQueryDA" y "IReplicationEntDA".
|
Tenga en cuenta que el siguiente código ilustra la implementación del método "GetEntity()" (para servir como una guía), sin embargo otros métodos no son incluidos y podría necesitar otro un mayor desarrollo. |
Crear una librería de replicación
En este ejemplo específico, para poder implementar las clases de replicación que conecten la base de datos MySQL, primero se debe descargar e instalar el componente MySQL Connector/NET para realizar la conexión.
Para el ejemplo, las siguientes clases fueron desarrolladas utilizando Microsoft Visual Studio. A través de este proyecto .NET se hace referencia a la librería MySql.Data.dll, la cual debió ser instalado por el componente MySQL Connector/Net ya que es necesario.
También es necesario hacer referencia a la librería BizAgi.EntityManager.Interfaces.CustomSource.dll.
Esta se encuentra en la carpeta “bin” dentro de la carpeta de la aplicación del proyecto (por defecto en "C:\Bizagi\Projects\[PROJECT_NAME]\WebApplication\bin\").
Clase de las Interfaces ICustomProviderDA and ICustomQueryDA
using System;
using System.Data;
using BizAgi.EntityManager.Interfaces.CustomSource;
using MySql.Data.MySqlClient;
using System.Collections.Generic;
using System.Collections;
using System.Text;
namespace BizagiMySQL
{
public class CMySQLProvider : ICustomProviderDA, ICustomQueryDA
{
private Dictionary<string, string> _metadata;
private MySqlConnection _mySqlconn;
private bool _disposed;
//--- The array used to store the parameters to a stored procedure
private readonly List<CMySqlParameter> _params;
public CMySQLProvider()
{
_disposed = false;
_mySqlconn = null;
_params = new List<CMySqlParameter>();
}
#region IProviderVirtualDA2 Members
public void AddParameter(string parameterName, BizagiDataType dataType, int size, byte precision, byte scale, object value, ParameterDirection parameterDirection)
{
_params.Add(new CMySqlParameter(parameterName, dataType, size, precision, scale, value, parameterDirection));
}
public void ClearParameters()
{
_params.Clear();
}
public DataSet RunQuery(string query, string tableName)
{
MySqlCommand command = new MySqlCommand();
MySqlDataAdapter adapter = new MySqlDataAdapter();
DataSet ds = new DataSet();
command.Connection = this.GetConnection();
command.CommandText = ReplaceQueryParameters(query, _params);
command.CommandType = CommandType.Text;
GetParameters(command);
adapter.SelectCommand = command;
adapter.Fill(ds, tableName);
return ds;
}
public IDatabaseProperties Properties
{
get { return CMySqlDatabaseConstants.Instance; }
}
private void GetParameters(MySqlCommand oCmd)
{
//--- Get an enumerator for the parameter array list
IEnumerator oEnumerator = _params.GetEnumerator();
//--- Loop through the Parameters in the ArrayList
while (oEnumerator.MoveNext())
{
//--- Add the SQLParameter object to the SQLCommand object
oCmd.Parameters.Add(ConvertParameterToMySqlParameter((CMySqlParameter)oEnumerator.Current));
}
}
private MySqlParameter ConvertParameterToMySqlParameter(CMySqlParameter oP)
{
MySqlDbType dbType = oP.DataType;
//--- Instantiate a SqlParameter object
MySqlParameter mySqlParameter = new MySqlParameter(oP.ParameterName, dbType, oP.Size);
mySqlParameter.Value = oP.Value;
mySqlParameter.Direction = (ParameterDirection)oP.Direction;
mySqlParameter.Precision = oP.Precision;
mySqlParameter.Scale = oP.Scale;
mySqlParameter.SourceColumn = oP.SourceColumn;
mySqlParameter.SourceVersion = oP.UseCurrentSourceColumnValue ? DataRowVersion.Current : DataRowVersion.Original;
return mySqlParameter;
}
/// <summary>
/// Replace parameter in the form '?', by parametes in the form ':ParamName'
/// </summary>
/// <param name="sQuery"></param>
/// <returns></returns>
private static string ReplaceQueryParameters(string sQuery, List<CMySqlParameter> alParams)
{
if (alParams != null && alParams.Count > 0)
{
char cInter = '?', cQuote = '\'', cAt = '@', cColon = ':';
string sParamToken = ":";
bool bInQuote = false; // indicates if current character is in ''
StringBuilder sbResp = new StringBuilder();
int _i = 0, _n = sQuery.Length, nNumParam = 0, nLastStrIndex = 0;
while (_i < _n)
{
if (bInQuote)
{
if (sQuery[_i] == cQuote)
{
if ((_i + 1) < _n && sQuery[_i + 1] == cQuote)
{
// "...''..." case, already in quote
_i += 2;
}
else
{
// "...'" case
bInQuote = false;
_i++;
}
}
else
{
_i++;
}
}
else
{
if (sQuery[_i] == cInter)
{
// "...?..." case
if (nNumParam >= alParams.Count)
{
// parameter doesn't exists
throw new Exception(string.Format("Parameter {0} doesn't exists in command: '{1}'", nNumParam, sQuery));
}
else
{
// get valid param name
string sValidParamName = GetValidParamName(((CMySqlParameter)alParams[nNumParam]).ParameterName, alParams, nNumParam - 1);
(alParams[nNumParam]).ParameterName = sValidParamName;
// replace parameter by name
sbResp.Append(sQuery.Substring(nLastStrIndex, _i - nLastStrIndex));
sbResp.Append(sParamToken + sValidParamName);
nLastStrIndex = _i + 1;
nNumParam++;
}
}
else if (sQuery[_i] == cAt)
{
// replace parameter by name
sbResp.Append(sQuery.Substring(nLastStrIndex, _i - nLastStrIndex));
sbResp.Append(cInter);
nLastStrIndex = _i + 1;
nNumParam++;
}
else if (sQuery[_i] == cQuote)
{
// "'..." case
bInQuote = true;
}
_i++;
}
}
sbResp.Append(sQuery.Substring(nLastStrIndex, _n - nLastStrIndex));
return sbResp.ToString();
}
return sQuery;
}
/// <summary>
/// Gets a valid parameter name, unique for first iMaxParamIndex parameters
/// </summary>
/// <param name="sParamName"></param>
/// <param name="alParams"></param>
/// <param name="iMaxParamIndex"></param>
/// <returns></returns>
private static string GetValidParamName(string sParamName, List<CMySqlParameter> alParams, int iMaxParamIndex)
{
int iMaxDbIdLength = CMySqlDatabaseConstants.Instance.MaxDbIdLength;
string sResp = (iMaxDbIdLength < sParamName.Length) ? sParamName.Substring(0, iMaxDbIdLength) : sParamName;
int iSuffix = 1;
while (IndexOfParam(sResp, alParams, iMaxParamIndex) != -1)
{
// find an unique name
string sSuffix = iSuffix.ToString();
sResp = (iMaxDbIdLength - sSuffix.Length < sParamName.Length) ? sParamName.Substring(0, iMaxDbIdLength - sSuffix.Length) : sParamName;
sResp += sSuffix;
iSuffix++;
}
return sResp;
}
private static int IndexOfParam(string sParamName, List<CMySqlParameter> alParams, int iMaxParamIndex)
{
int i = 0, n = iMaxParamIndex;
while (i < n)
{
if ((alParams[i]).ParameterName == sParamName)
{
n = i;
}
else
{
i++;
}
}
return (n == iMaxParamIndex) ? -1 : n;
}
#endregion
#region IProviderVirtualDA Members
public void Init(Dictionary<string, string> metadata)
{
this._metadata = metadata;
}
public void BeginTransaction()
{
}
public void Commit()
{
}
public void Rollback()
{
}
public void OpenConnection()
{
if (_mySqlconn == null)
{
//Verify all parameters are filled
if (!_metadata.ContainsKey("Server") || !_metadata.ContainsKey("Database") ||
!_metadata.ContainsKey("Username") || !_metadata.ContainsKey("Password"))
{
throw new CustomVirtualizationException("Incomplete metadata: connection parameters missing");
}
else
{
//Build the connection string with the parameters received from Bizagi Server
string sServer = _metadata["Server"];
string sDatabase = _metadata["Database"];
string sUsername = _metadata["Username"];
string sPassword = _metadata["Password"];
string sConn = "Server=" + sServer + ";Database=" + sDatabase + ";Uid=" + sUsername + ";Pwd=" + sPassword + ";";
_mySqlconn = new MySqlConnection(sConn);
_mySqlconn.Open();
}
}
}
public void CloseConnection()
{
if (_mySqlconn != null)
_mySqlconn.Close();
_mySqlconn = null;
}
#endregion
#region IDisposable Members
void IDisposable.Dispose()
{
if (!_disposed)
{
_disposed = true;
}
}
#endregion
#region internal methods
internal MySqlConnection GetConnection()
{
return this._mySqlconn;
}
internal DataSet ExecuteMySQLQuery(string sSQL)
{
DataSet ds = new DataSet();
MySqlCommand command = new MySqlCommand(sSQL, this.GetConnection());
MySqlDataAdapter adapter = new MySqlDataAdapter(command);
adapter.Fill(ds);
return ds;
}
internal DataSet ExecuteMySQLQuery(MySqlCommand command)
{
DataSet ds = new DataSet();
MySqlDataAdapter adapter = new MySqlDataAdapter(command);
adapter.Fill(ds);
return ds;
}
internal void ExecuteNonQueryMySQL(string sSQL)
{
MySqlCommand command = new MySqlCommand(sSQL, this.GetConnection());
command.ExecuteNonQuery();
}
/// <summary>
/// Initializes command with current connection and transaction
/// </summary>
internal MySqlCommand GetCommand()
{
MySqlCommand m_oledbCmd = new MySqlCommand();
m_oledbCmd.Connection = GetConnection();
m_oledbCmd.CommandType = CommandType.Text;
m_oledbCmd.Parameters.Clear();
return m_oledbCmd;
}
#endregion
}
}
Clase de la interfaz ICustomReplicationDA
using System;
using System.Data;
using System.Collections.Specialized;
using System.Text;
using BizAgi.EntityManager.Interfaces.CustomSource;
namespace BizagiMySQL
{
public class CMySQLReplication : ICustomReplicationDA
{
/// <summary>
/// Flag to show if object has been disposed
/// </summary>
protected bool m_bDisposed;
/// <summary>
/// Connection with the virtual System
/// </summary>
protected CMySQLProvider m_objSystem;
/// <summary>
/// Metadata used to initialize object, as collection of name-value pairs
/// </summary>
protected HybridDictionary m_htMetadata;
public CMySQLReplication()
{
m_bDisposed = false;
}
#region ICustomReplicationDA Members
public void Init(ICustomProviderDA provider)
{
m_objSystem = (CMySQLProvider)provider;
}
public DataSet GetEntity(string entitySource, string[] columnList, string optionalSourceFilter)
{
try
{
StringBuilder sbSQL = new StringBuilder();
sbSQL.Append(" SELECT ");
sbSQL.Append(string.Join(",", columnList));
sbSQL.Append(" FROM ");
sbSQL.Append(entitySource);
if (!string.IsNullOrWhiteSpace(optionalSourceFilter))
{
sbSQL.Append(" WHERE ");
sbSQL.Append(optionalSourceFilter);
}
DataSet ds = m_objSystem.ExecuteMySQLQuery(sbSQL.ToString());
return ds;
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
#endregion
#region IDisposable Members
void IDisposable.Dispose()
{
if (!m_bDisposed)
{
// nunca se debe cerrar la conexión dentro de este método!!
m_bDisposed = true;
}
}
#endregion
}
}
Clase de los parámetros
using BizAgi.EntityManager.Interfaces;
using BizAgi.EntityManager.Interfaces.CustomSource;
using MySql.Data.MySqlClient;
namespace BizagiMySQL {
using System.Data;
public class CMySqlParameter
{
private BizagiDataType dataType; //--- Provider-independent data type
private MySqlDbType dbDataType; //--- Provider-specific datatype of the parameter
private string paramName; //--- The Internal name of the parameter
private string originalParamName; //--- The Original o External name of the parameter
//-------------------------------------------------------------------------------------------------------
//--- Class Constructors
//--- Overloaded: Yes
//-------------------------------------------------------------------------------------------------------
public CMySqlParameter(string sParameterName, BizagiDataType BizagiDataType, int iSize, object oValue) {
ParameterName = sParameterName;
dataType = BizagiDataType;
dbDataType = getSqlDataType(BizagiDataType);
Size = iSize;
Value = oValue;
Direction = ParameterDirection.Input;
}
public CMySqlParameter (string sParameterName, BizagiDataType BizagiDataType, int iSize, object oValue, ParameterDirection eDirection) {
ParameterName = sParameterName;
dataType = BizagiDataType;
dbDataType = getSqlDataType(BizagiDataType);
Size = iSize;
Value = oValue;
Direction = eDirection;
}
public CMySqlParameter (string sParameterName, BizagiDataType BizagiDataType, int iSize, byte iPrecision, byte iScale, object oValue, ParameterDirection eDirection)
{
ParameterName = sParameterName;
dataType = BizagiDataType;
dbDataType = getSqlDataType(BizagiDataType);
Size = iSize;
Precision = iPrecision;
Scale = iScale;
Value = oValue;
Direction = eDirection;
}
public CMySqlParameter (string sParameterName, BizagiDataType BizagiDataType, int iSize, byte iPrecision, byte iScale, object oValue, ParameterDirection eDirection, string sSourceColumn, bool bUseCurrentSourceColumnValue)
{
ParameterName = sParameterName;
dataType = BizagiDataType;
dbDataType = getSqlDataType(BizagiDataType);
Size = iSize;
Precision = iPrecision;
Scale = iScale;
Value = oValue;
Direction = eDirection;
SourceColumn = sSourceColumn;
UseCurrentSourceColumnValue = bUseCurrentSourceColumnValue;
}
public ParameterDirection Direction { get; private set; }
public object Value { get; private set; }
public string SourceColumn { get; private set; }
public string ParameterName
{
get { return paramName; }
set
{
string sResult = value;
originalParamName = value;
paramName = sResult.Replace ("@","?");
}
}
//--
// Only for this IParameter implementation
// ReadOnly -- Return the original name of the parameter
//--
public string OriginalName
{
get { return originalParamName; }
}
public BizagiDataType Type
{
get { return dataType; }
set
{
dataType = value;
dbDataType = getSqlDataType(dataType);
}
}
public int Size { get; set; }
public byte Precision { get; set; }
public byte Scale { get; set; }
public bool UseCurrentSourceColumnValue { get; set; }
public MySqlDbType DataType
{
get { return dbDataType; }
}
private static MySqlDbType getSqlDataType(BizagiDataType BizagiDataType) {
MySqlDbType oDbType = MySqlDbType.Int32;
switch (BizagiDataType) {
case BizagiDataType.BigInt:
oDbType = MySqlDbType.Int64;
break;
case BizagiDataType.Int:
oDbType = MySqlDbType.Int32;
break;
case BizagiDataType.SmallInt:
oDbType = MySqlDbType.Int16;
break;
case BizagiDataType.TinyInt:
oDbType = MySqlDbType.Byte;
break;
case BizagiDataType.Boolean:
oDbType = MySqlDbType.Bit;
break;
case BizagiDataType.Decimal:
oDbType = MySqlDbType.Decimal;
break;
case BizagiDataType.Numeric:
oDbType = MySqlDbType.Float;
break;
case BizagiDataType.Money:
oDbType = MySqlDbType.Decimal;
break;
case BizagiDataType.Float:
oDbType = MySqlDbType.Float;
break;
case BizagiDataType.Real:
oDbType = MySqlDbType.Float;
break;
case BizagiDataType.DateTime:
oDbType = MySqlDbType.DateTime;
break;
case BizagiDataType.SmallDateTime:
oDbType = MySqlDbType.DateTime;
break;
case BizagiDataType.Char:
oDbType = MySqlDbType.VarChar;
break;
case BizagiDataType.VarChar:
oDbType = MySqlDbType.VarChar;
break;
case BizagiDataType.Text:
oDbType = MySqlDbType.Text;
break;
case BizagiDataType.Binary:
oDbType = MySqlDbType.Binary;
break;
case BizagiDataType.VarBinary:
oDbType = MySqlDbType.VarBinary;
break;
case BizagiDataType.Image:
oDbType = MySqlDbType.VarBinary;
break;
case BizagiDataType.Guid:
oDbType = MySqlDbType.Guid;
break;
case BizagiDataType.NChar:
oDbType = MySqlDbType.VarChar;
break;
case BizagiDataType.NVarChar:
oDbType = MySqlDbType.VarChar;
break;
case BizagiDataType.NText:
oDbType = MySqlDbType.Text;
break;
default:
break;
}
return oDbType;
}
}
}
Clase de la Interfaz IDatabaseProperties
using BizAgi.EntityManager.Interfaces.CustomSource;
namespace BizagiMySQL
{
/// <summary>
/// Specific database constants
/// </summary>
public class CMySqlDatabaseConstants : IDatabaseProperties
{
#region Singleton
private static readonly CMySqlDatabaseConstants MySqlInstance = new CMySqlDatabaseConstants();
public static CMySqlDatabaseConstants Instance
{
get { return MySqlInstance; }
}
protected CMySqlDatabaseConstants() {}
#endregion
#region Fields / Properties
/// <summary>
/// Open character for enclose a name that is reserverd word or has special characters
/// </summary>
private readonly string m_sQuotedNameOpenChar = "'";
public string QuotedNameOpenChar { get { return m_sQuotedNameOpenChar; } }
/// <summary>
/// Close character for enclose a name that is reserverd word or has special characters
/// </summary>
private readonly string m_sQuotedNameCloseChar = "'";
public string QuotedNameCloseChar { get { return m_sQuotedNameCloseChar; } }
/// <summary>
/// Indicates if by default comparisons between strings are case sensitive
/// </summary>
private readonly bool m_bCaseSensitive = false;
public bool CaseSensitive { get { return m_bCaseSensitive; } }
internal int MaxDbIdLength
{
get { return 128; }
}
#endregion
}
}
Configurar el proveedor en Bizagi
En este paso, se configurará el Sistema y el proveedor de datos de la Replicación especificando qué librería debe ser usada (el componente personalizado creado anteriormente).
|
Tenga en cuenta que la configuración es hecha a través del método de configuración estándar de replicación, el cual requiere que las entidades a ser replicadas hayan sido creadas en el modelo de datos de Bizagi. |
1. Clic en Sistemas, en la vista de Experto de Bizagi.
Puede dar clic derecho sobre el elemento sistema y seleccionar Nuevo Sistema del menú desplegable o dar clic en Nuevo sistema de la barra del menú.
2. Ingrese el Nombre a mostrar y Descripción para el nuevo sistema y seleccione la casilla de Habilitar proveedores de datos.
Después dé clic en Ok para guardar cambios.
3. Clic en el signo (+) al lado del sistema recién creado.
Clic derecho en el elemento Nuevo Proveedor.
4. En la ventana del Nuevo Proveedor ingrese Nombre, Nombre Visible y Descripción en la pestaña de configuración del proveedor.
Seleccione la opción Permitir replicación de datos. De igual manera, seleccione la opción Permitir virtualización de datos para este proveedor.
5. Seleccione la pestaña de Detalles de conexión y en la opción Librería, dé en Nueva librería (New Assembly).
6. Ingrese Nombre, Nombre Visual, Namespace y Descripción.
Luego haga clic Seleccionar Librería para seleccionar el .dll de la librería de replicación personalizada previamente. Dé clic en Ok en la ventana de Nueva Librería.
7. Dé clic en el botón Nueva Clase y dentro de la ventana Nueva Clase para Librería, ingrese el nombre de la clase que implementa la interfaz IProviderVirtualDA.
Dé clic en Ok.
8. Ahora, en la pestaña Propiedades desarrollo de Proveedor, incluya las propiedades de la conexión haciendo clic en el botón Metadata para crear una nueva fila Propiedad-Valor.
Dé clic en Ok en la ventana Nuevo Proveedor.
9. Expanda el elemento nuevo proveedor, seleccione el elemento Entidades Replicadas y cree una Nueva Clase de Replicación.
10. Seleccione la librería de la lista desplegable en la ventana Nueva Clase para Librería (si la clase de la Entidad esta en la misma librería que la Clase del Proveedor) o incluya una nueva, dando clic en Nueva Librería.
Dé clic en Nueva Clase y complete los campos necesarios en la nueva ventana. Haga clic en Ok para completar la Configuración de la Clase de la Entidad.
11. Dé clic derecho sobre el nuevo elemento de la clase de la entidad y seleccione la opción Nueva Programación de Replicación.
12. En la ventana de Configuración de Replicación, ingrese un Nombre, Nombre Visual y una Descripción para la programación de replicación.
Seleccione la pestaña Props. Calendario y configure la frecuencia con que la información será replicada desde la fuente de datos.
Defina la periodicidad y frecuencia de ejecución de acuerdo a la información de la siguiente tabla:
Opciones del programador |
Descripción |
|---|---|
Habilitar programador para la replicación |
Marque esta opción en Bizagi para ejecutar los datos de la replicación desde la fuente de datos externa. |
Periodicidad |
Marque, diario, semanal o mensual para definir con que frecuencia Bizagi ejecutará el esquema de Replicación. |
Cada [...] día(s) |
Esta opción cambiara de acuerdo a la opción seleccionada en Periodicidad. •Cuando se selecciona Diario: ingrese el número de días para realizar la repetición. •Cuando se selecciona semanal: ingrese el número de semanas para realizar la repetición. También seleccione en que día de la semana se debe ejecutar el esquema. •Cuando se selecciona mensual: ingrese el número de meses para realizar la repetición. También seleccione en que día del mes se debe ejecutar el esquema. |
Frecuencia diaria |
Defina si la ejecución ocurre una vez al día (y en que hora), o si se debe ejecutar cada cierto tiempo (horas, minutos). |
Inicio |
Configure la fecha inicial para que el esquema comience la ejecución. |
Descripción de las propiedades del programador
Luego de configurar la fecha de inicio de ejecución, haga clic en Ok.
13. Haga clic derecho sobre el esquema y seleccione Adicionar Entidad a Replicación.
14. En la ventana Agregar Entidad a Replicación, seleccione la entidad deseada de la lista desplegable de Entidades Paramétricas. Luego, digite el nombre de la entidad externa dentro del campo Fuente Externa. Posteriormente, de la lista de atributos de la entidad de Bizagi, seleccione uno (o más) que será la llave del negocio (un atributo que tiene un valor único de tal modo que este puede ser usado para diferenciar un registro de otro).
Dé clic en Ok para guardar estos cambios.
15. Seleccione la entidad replicada y para cada atributo seleccione el atributo correspondiente externo.
Esto se hace, haciendo clic derecho sobre el atributo y seleccionando Propiedades.
En la ventana Editar Atributo, escriba el nombre del atributo externo y haga clic en Ok.
Haga esto para todos los atributos de la entidad replicada.
|
Si su librería de replicación personalizada tiene referencias a otras librerías, es necesario copiarlas a la carpeta del Programador, usualmente es: "C:\Bizagi\Projects\[PROJECT_NAME]\Scheduler". |
Ya hemos terminado la configuración de la Replicación utilizando un componente personalizado para una base de datos MySQL.
Verificar la Replicación (Punto de chequeo)
Una vez la Replicación ha sido configurada, usted puede verificar la ejecución de la sincronización de las Entidades Paramétricas con las tablas externas.
Existen dos maneras de realizar esto: Utilizando las opciones que se encuentran en el moduló Sistemas (Vista Experto) o través de la información mostrada de las entidades (Moduló de Entidades).
Las opciones representadas en el módulo de Sistemas son útiles para los ambientes de producción o pruebas.
Las opciones representadas en el módulo de Entidades servirán para realizar la verificación mientras se esta realizando la configuración en el Ambiente de desarrollo.
Para más información sobre cómo verificar si la Replicación se ejecuta correctamente, visite Verificar Replicación.