private string GetDataById(string pData, ProcessConfiguration wServiceConfiguration)
{
string wResult;
object wAux = _CacheManager.GetData(wServiceConfiguration.Name + pData);
if (wAux == null)
{
wResult = String.Empty;
}
else
{
wResult = wAux.ToString();
}
// Si no esta chacheado el servicio, ejecutarlo.
if (wResult == String.Empty)
{
FacadeHelper wHelper = new FacadeHelper();
wResult = wHelper.RunTransactionalProcess(pData, wServiceConfiguration);
if (wResult != String.Empty)
{
if (Convert.ToString(wResult) != String.Empty)
{
_CacheManager.Add(wServiceConfiguration.Name + pData, wResult);
}
}
}
return wResult;
}
/// /// Return AvailabilityPath Composed Funcrtion
public static Func <Order, ShippingDate> AvailabilityPathFunc(ProcessConfiguration c, AvailabilityPath spl)
{
Func <Order, ShippingDate> p = spl.AvailabilityFunctions.Where((x) => x.availabilityChoose == c.availabilityChoice).Select((x) => x.calcAvailability).FirstOrDefault()
.Compose(spl.ShippingDateFunctions.Where((x) => x.shippingDateChoose == c.shippingDateChoice).Select((x) => x.calcShippingDate).FirstOrDefault());
return(p);
}
/// <summary>
/// Almacena la configuración de un nuevo proceso de negocio.
/// </summary>
/// <param name="pProcessConfiguration">Configuración del proceso de negocio.</param>
/// <date>2006-02-13T00:00:00</date>
/// <author>gmedina</author>
public void AddProcessConfiguration(ProcessConfiguration pProcessConfiguration)
{
XmlDocument wDocument;
XmlElement wNode;
try
{
wDocument = GetXMLProcessConfigurationDocument();
wNode = (XmlElement) Node.NodeCreateAndAdd((XmlElement)wDocument.DocumentElement.SelectSingleNode("Processes"), "Process");
NodeAttribute.AttributeCreateAndSet(wDocument, wNode, "Name", pProcessConfiguration.Name);
Node.NodeCreateAndAdd(wNode, "Description", pProcessConfiguration.Description);
Node.NodeCreateAndAdd(wNode, "Handler", pProcessConfiguration.Handler);
Node.NodeCreateAndAdd(wNode, "Request", pProcessConfiguration.Request);
Node.NodeCreateAndAdd(wNode, "Response", pProcessConfiguration.Response);
Node.NodeCreateAndAdd(wNode, "Available", pProcessConfiguration.Available.ToString());
Node.NodeCreateAndAdd(wNode, "Audit", pProcessConfiguration.Audit.ToString());
Node.NodeCreateAndAdd(wNode, "ProcessTransactionalBehaviour", Enum.GetName(typeof(TransactionalBehaviour), pProcessConfiguration.ProcessTransactionalBehaviour));
Node.NodeCreateAndAdd(wNode, "ProcessIsolationLevel", Enum.GetName(typeof(IsolationLevel), pProcessConfiguration.ProcessIsolationLevel));
Node.NodeCreateAndAdd(wNode, "Timeout", pProcessConfiguration.Timeout.ToString());
wDocument.Save(GetXMLRepositoryPath());
}
finally
{
wNode = null;
wDocument = null;
}
}
private static IEnumerable <Process> DoesMatchProcessFilter(ProcessConfiguration processConfiguration, Process[] processes)
{
var namePattern = processConfiguration.ClosableProcessesSettings.NamePattern;
if (namePattern == "*")
{
foreach (var process in processes)
{
yield return(process);
}
}
else
{
var patterns = namePattern.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var process in processes)
{
foreach (var pattern in patterns)
{
if (process.ProcessName.Contains(pattern))
{
yield return(process);
break;
}
}
}
}
}
/// <summary>
/// 添加审批活动
/// </summary>
/// <returns></returns>
public int AddApprovalActivity()
{
using (OracleConnection conn = DapperHelper.GetConnString())
{
conn.Open();
ProcessConfiguration pc = new ProcessConfiguration();
int result = 0;
string sql = @"select * from ProcessConfiguration";
var configurationList = conn.Query <ProcessConfiguration>(sql, null).ToList();
for (var i = 0; i <= 1; i++)
{
ApprovalActivity activity = new ApprovalActivity();
activity.ProcessID = configurationList[i].ProcessID;
activity.NodeID = configurationList[i].NodeID;
activity.ProcessCode = configurationList[i].ProcessCode;
activity.ApprovalRoleID = configurationList[i].ApprovalRoleID;
activity.NextApprovalRoleID = configurationList[i].NextApprovalRoleID;
activity.ApprovalUserID = configurationList[i].ApprovalUserID;
activity.NextApprovalUserID = configurationList[i].NextApprovalUserID;
activity.JudgmentID = configurationList[i].JudgmentID;
activity.CondtionID = configurationList[i].CondtionID;
activity.TureCondtionID = configurationList[i].CondtionID;
activity.Creator = configurationList[i].Creator;
activity.CreateTime = configurationList[i].CreateTime;
string sql1 = @"insert into ApprovalActivity
(processid,nodeid,processcode,approvalroleid,nextapprovalroleid,approvaluserid,nextapprovaluserid,judgmentid,condtionid,turecondtionid,creator,createtime)
values
(:processid,:nodeid,:processcode,:approvalroleid,:nextapprovalroleid,:approvaluserid,:nextapprovaluserid,:judgmentid,:condtionid,:turecondtionid,:creator,:createtime)";
result = conn.Execute(sql1, activity);
}
return(result);
}
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["MinNumberRatings"] = _minNumRatings.ToString();
return(pc);
}
/// Return InvoicePath Composed Function
public static Func <Order, Freight> InvoicePathFunc(ProcessConfiguration c, InvoicingPath fpl)
{
Func <Order, Freight> p = fpl.InvoiceFunctions.Where((x) => x.InvoiceChoose == c.invoiceChoice).Select((x) => x.CalcInvoice).FirstOrDefault()
.Compose(fpl.ShippingFunctions.Where((x) => x.ShippingChoose == c.shippingChoice).Select((x) => x.calcShipping).FirstOrDefault())
.Compose(fpl.frieghtFunctions.Where((x) => x.freightChoose == c.freightChoice).Select((x) => x.calcFrieght).FirstOrDefault());
return(p);
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["MaxAuxItems"] = MaxAuxItems.ToString();
pc["AuxDomainFiles"] = "Music 5";
return(pc);
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["ProductGroups"] = _productGroups.Select(pg => pg.ToString())
.Aggregate((cur, next) => cur + "," + next);
pc["AdditionalFeatures"] = "SalesRank";
return(pc);
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["Recommender"] = _recommender.GetType().Name;
pc["TrainFile"] = context.GetAsString("TrainFile");
pc["TestFile"] = context.GetAsString("TestFile");
return(pc);
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["TrainRatio"] = TrainRatio.ToString();
pc["CrossDomainAuxData"] = CrossDomain.ToString();
pc["AuxDomainFiles"] = _auxDomainsPath.Length > 0 ? _auxDomainsPath.Aggregate((cur, next) => cur + "," + next.GetFileName()) : "";
return(pc);
}
/// <summary>
/// 添加流程配置
/// </summary>
/// <param name="collect"></param>
/// <returns></returns>
public int AddConfiguration(ProcessConfiguration processConfiguration)
{
using (OracleConnection conn = DapperHelper.GetConnString())
{
conn.Open();
string sql = @"insert into ProcessConfiguration(processid, nodeid,processcode,approvalroleid,nextapprovalroleid,approvaluserid,nextapprovaluserid,judgmentid,condtionid,creator,createtime)values(:processid,:nodeid,:processcode,:approvalroleid,:nextapprovalroleid,:approvaluserid,:nextapprovaluserid,:judgmentid,:condtionid,:creator,:createtime)";
processConfiguration.CreateTime = DateTime.Now;
int result = conn.Execute(sql, processConfiguration);
return(result);
}
}
public ProcessConfiguration GetConfiguration(PipelineContext context)
{
var pc = new ProcessConfiguration();
pc["LearningAlgorithm"] = LearningAlgorithm.ToString();
pc["Iterations"] = Iterations.ToString();
pc["Dimensions"] = Dimensions;
pc["LearningRate"] = LearningRate.ToString();
pc["TrainFile"] = context.GetAsString("TrainFile");
pc["TestFile"] = context.GetAsString("TestFile");
pc["AdditionalArgs"] = _additionalArgs;
return(pc);
}
/// <summary>
/// Ejecuta un servicio de negocio dentro de un ámbito transaccional.
/// </summary>
/// <param name="pData">XML con datos de entrada.</param>
/// <param name="pServiceConfiguration">Configuración del servicio.</param>
/// <returns>XML con datos de salida del servicio.</returns>
/// <date>2006-02-07T00:00:00</date>
/// <author>gmedina</author>
public string RunNonTransactionalProcess(string pData, ProcessConfiguration pServiceConfiguration)
{
string wResult;
try
{
wResult = this.RunProcess(pData, pServiceConfiguration);
}
catch (Exception ex)
{
throw ex;
}
return wResult;
}
//Setup of the Process Configuration and Data
public static (Order order, ProcessConfiguration processConfiguration) setConfiguration()
{
ProcessConfiguration processConfiguration = new ProcessConfiguration();
Customer customer = new Customer();
Order order = new Order();
processConfiguration.invoiceChoice = InvoiceChoice.Inv3;
processConfiguration.shippingChoice = ShippingChoice.Sh2;
processConfiguration.freightChoice = FreightChoice.fr3;
processConfiguration.availabilityChoice = AvailabilityChoice.AV2;
processConfiguration.shippingDateChoice = ShippingDateChoice.SD2;
order.customer = customer;
order.date = new DateTime(2021, 3, 16);
order.cost = 2000;
return(order, processConfiguration);
}
protected override void OnStartup(StartupEventArgs e)
{
//register service
Context.AddService("HL7", new FTPLis());
Context.AddService("ASTM", new ASTMLis());
//register configuration
ProcessConfiguration config = new ProcessConfiguration();
Context.RegisterConfiguration("process", config, GroupVisiblity.ALL, 0);
DatabaseMaintenanceSetting dConfig = new DatabaseMaintenanceSetting();
Context.RegisterConfiguration("db", dConfig, GroupVisiblity.ALL, 1);
Context.RegisterConfiguration("externalQC", GetExternalControlConfigurations(), GroupVisiblity.ALL, 3);
Context.RegisterConfiguration("lis", new LISConfiguration(), GroupVisiblity.ALL, 2);
base.OnStartup(e);
}
/// <inheritdoc />
public EwsDiscoveryProcessor CreateTestableProcessor()
{
if (_processor != null)
{
return(_processor);
}
Type processorType;
ActivatorHelper.ActivateObject <EwsDiscoveryProcessor>("SmartConnector.UtilityExtensions.dll", "SmartConnector.UtilityExtensions.EwsDiscoveryProcessor", out processorType);
var config = ProcessConfiguration.ExtractConfiguration(processorType);
_processor = config.InstantiateInstance <EwsDiscoveryProcessor>();
_processor.OutputFilePath = @"%PROGRAMDATA%\SmartConnector\SBO Output.txt";
_processor.Address = @"http://localhost:8081/EcoStruxure/DataExchange";
_processor.UserName = "******";
_processor.Password = "******";
return(_processor);
}
public static ProcessConfiguration Configuration()
{
var section = ConfigurationSectionProvider.Open<ProcessSection>("shuttle", "process");
var configuration = new ProcessConfiguration();
var connectionStringName = "Process";
if (section != null)
{
connectionStringName = section.ConnectionStringName;
}
var settings = ConfigurationManager.ConnectionStrings[connectionStringName];
configuration.ConnectionString = settings.ConnectionString;
configuration.ProviderName = settings.ProviderName;
return configuration;
}
public ProcessViewModel(ProcessConfiguration configuration)
{
_displayName = configuration.DisplayName;
FileName = configuration.ProcessFileName;
RootFolderPath = configuration.RootPath;
if (Enum.TryParse <LoggingTypeSourceEnum>(configuration.LoggingSourceType, out var val))
{
LoggingSourceType = val;
}
else
{
LoggingSourceType = LoggingTypeSourceEnum.Console;
}
RabbitMQTopicName = configuration.RabbitMQTopicName;
MeasureSettings = new ObservableCollection <MeasureSettingViewModel>(configuration.MeasureSettings.Select(x => x.ToViewModel()));
Init();
}
/// <summary>
/// Almacena la configuración de un nuevo proceso de negocio.
/// </summary>
/// <param name="pProcessConfiguration">Configuración del proceso de negocio.</param>
/// <date>2006-02-13T00:00:00</date>
/// <author>gmedina</author>
public void AddProcessConfiguration(ProcessConfiguration pProcessConfiguration)
{
Datablock.Database wBPConfig = Datablock.DatabaseFactory.CreateDatabase(_DatabaseConfigSection.ConnectionName);
using (System.Data.Common.DbCommand wCmd = wBPConfig.GetStoredProcCommand("Process_i"))
{
wBPConfig.AddInParameter(wCmd, "Name", System.Data.DbType.String, pProcessConfiguration.Name);
wBPConfig.AddInParameter(wCmd, "Description", System.Data.DbType.String, pProcessConfiguration.Description);
wBPConfig.AddInParameter(wCmd, "Handler", System.Data.DbType.String, pProcessConfiguration.Handler);
wBPConfig.AddInParameter(wCmd, "Request", System.Data.DbType.String, pProcessConfiguration.Request);
wBPConfig.AddInParameter(wCmd, "Response", System.Data.DbType.String, pProcessConfiguration.Response);
wBPConfig.AddInParameter(wCmd, "Available", System.Data.DbType.String, pProcessConfiguration.Available);
wBPConfig.AddInParameter(wCmd, "Audit", System.Data.DbType.String, pProcessConfiguration.Audit);
wBPConfig.AddInParameter(wCmd, "ProcessTransactionalBehaviour", System.Data.DbType.String, Enum.GetName(typeof(TransactionalBehaviour), pProcessConfiguration.ProcessTransactionalBehaviour));
wBPConfig.AddInParameter(wCmd, "ProcessIsolationLevel", System.Data.DbType.String, Enum.GetName(typeof(IsolationLevel), pProcessConfiguration.ProcessIsolationLevel));
wBPConfig.AddInParameter(wCmd, "Timeout", System.Data.DbType.Int32, pProcessConfiguration.Timeout);
wBPConfig.AddInParameter(wCmd, "Cacheable", System.Data.DbType.Int32, pProcessConfiguration.Cacheable);
wBPConfig.ExecuteNonQuery(wCmd);
}
}
//Adjusted Cost for Order
public static Func <Order, double> CalcAdjustedCostofOrder(ProcessConfiguration c, InvoicingPath InvoicePath, AvailabilityPath AvailabilityPath)
{
return((x) => AdjustCost(x, InvoicePathFunc(c, InvoicePath), AvailabilityPathFunc(c, AvailabilityPath)));
}
/// <summary>
/// Genera un log de tipo "Error" cuando se ha producido
/// un error en la ejecución del servicio.
/// </summary>
/// <param name="pException">Excepción.</param>
/// <param name="pConfig">Configuración del servicio.</param>
private void LogNonSucessfulExecution(Exception pException, ProcessConfiguration pConfig)
{
//Logger wLogger = new Logger();
//wLogger.Error("Application", pException.ToString());
//wLogger = null;
}
/// <summary>
/// Ejecuta un servicio de negocio dentro de un ámbito transaccional.
/// </summary>
/// <param name="pData">XML con datos de entrada.</param>
/// <param name="pServiceConfiguration">Configuración del servicio.</param>
/// <returns>XML con datos de salida del servicio.</returns>
/// <date>2006-02-07T00:00:00</date>
/// <author>gmedina</author>
public string RunTransactionalProcess(string pData, ProcessConfiguration pServiceConfiguration)
{
string wResult;
TransactionScopeHandler wTransactionScopeHandler = this.CreateTransactionScopeHandler(pServiceConfiguration);
try
{
// Ejecución del servicio.
wTransactionScopeHandler.InitScope();
wResult = this.RunProcess(pData, pServiceConfiguration);
wTransactionScopeHandler.Complete();
#region < Log >
if (pServiceConfiguration.Audit == true)
{
LogSuccessfulExecution(pData, wResult, pServiceConfiguration);
}
#endregion
}
catch (Exception ex)
{
wTransactionScopeHandler.Abort();
#region < Log >
if (pServiceConfiguration.Audit == true)
{
LogNonSucessfulExecution(ex, pServiceConfiguration);
}
#endregion
throw ex;
}
finally
{
wTransactionScopeHandler.Dispose();
wTransactionScopeHandler = null;
}
return wResult;
}
/// <summary>
/// Genera un log de tipo "Information" cuando se ha ejecutado
/// correctamente un servicio.
/// </summary>
/// <param name="pRequestData">Datos del Request del servicio.</param>
/// <param name="pResultData">Datos del Response del servicio.</param>
/// <param name="pConfig">Configuración del servicio.</param>
private void LogSuccessfulExecution(string pRequestData, string pResultData, ProcessConfiguration pConfig)
{
//Logger wLogger = new Logger();
//StringBuilder wMessage = new StringBuilder();
//wMessage.Append("[Request]");
//wMessage.Append("\r\n\t");
//wMessage.Append("Name: ");
//wMessage.Append(pConfig.Request);
//wMessage.Append("\r\n\t");
//wMessage.Append("Data: ");
//wMessage.Append(pRequestData);
//wMessage.Append("\r\n\r\n");
//wMessage.Append("[Response]");
//wMessage.Append("\r\n\t");
//wMessage.Append("Name: ");
//wMessage.Append(pConfig.Response);
//wMessage.Append("\r\n\t");
//wMessage.Append("Data: ");
//wMessage.Append(pResultData);
//wLogger.Information("Application", wMessage.ToString());
//wLogger = null;
}
public int AddConfiguration(ProcessConfiguration processConfiguration)
{
var result = ProcessConfiguration.AddConfiguration(processConfiguration);
return(result);
}
/// <summary>
/// Genera un log de tipo "Warning" cuando se ha intentado ejecutar
/// un servicio que está deshabilitado.
/// </summary>
/// <param name="pConfig">Configuración del servicio.</param>
private void LogNotAvailableExcecution(ProcessConfiguration pConfig)
{
//Logger wLogger = new Logger();
//wLogger.Warning("Application", "Se ha intentado ejecutar un servicio que está configurado como no disponible.");
//wLogger = null;
}
//public ServiceConfiguration GetServiceConfiguration(string pServiceName)
//{
// // Instanciación del ServiceConfigurationManager.
// IServiceConfigurationManager wServiceConfigurationManager = ObjectProvider.GetServiceConfigurationManager();
// // Obtención de la configuración del servicio.
// ServiceConfiguration wResult = wServiceConfigurationManager.GetServiceConfiguration(pServiceName);
// return wResult;
//}
/// <summary>
/// Crea un ámbito de transacción en base a la configuración del servicio de negocio.
/// </summary>
/// <param name="pServiceConfiguration">Configuración del servicio de negocio.</param>
/// <returns>Ámbito de transacción.</returns>
/// <date>2007-12-20T00:00:00</date>
/// <author>gmedina</author>
private TransactionScopeHandler CreateTransactionScopeHandler(ProcessConfiguration pServiceConfiguration)
{
//Creación del ámbito de la transacción.
TransactionScopeHandler wResult = new TransactionScopeHandler(pServiceConfiguration.ProcessTransactionalBehaviour, pServiceConfiguration.ProcessIsolationLevel, new TimeSpan(0, 0, pServiceConfiguration.Timeout));
return wResult;
}
/// <summary>
/// Valida que el servicio esté disponible para ser ejecutado.
/// </summary>
/// <param name="pServiceConfiguration">Configuración del servicio.</param>
/// <date>2006-02-07T00:00:00</date>
/// <author>gmedina</author>
public void ValidateAvailability(ProcessConfiguration pServiceConfiguration)
{
// Validación de disponibilidad del servicio.
if (!pServiceConfiguration.Available)
{
#region < Log >
LogNotAvailableExcecution(pServiceConfiguration);
#endregion
throw new Exception("El servicio no se encuentra disponible");
}
}
/// <summary>
/// Recupera la configuración de todos los procesos de negocio.
/// </summary>
/// <returns>Colección de configuraciones de procesos de negocio.</returns>
/// <date>2006-02-10T00:00:00</date>
/// <author>gmedina</author>
public ProcessConfigurationCollection GetAllProcesses()
{
ProcessConfigurationCollection wResult;
XmlDocument wDocument;
try
{
wDocument = GetXMLProcessConfigurationDocument();
wResult = new ProcessConfigurationCollection();
foreach (XmlNode wNode in wDocument.DocumentElement.SelectSingleNode("Processes").SelectNodes("Process"))
{
ProcessConfiguration wProcessConfiguration = new ProcessConfiguration();
wProcessConfiguration.Name = Convert.ToString(wNode.Attributes["Name"].InnerText);
wProcessConfiguration.Description = Convert.ToString(wNode.SelectSingleNode("Description").InnerText);
wProcessConfiguration.Handler = Convert.ToString(wNode.SelectSingleNode("Handler").InnerText);
wProcessConfiguration.Request = Convert.ToString(wNode.SelectSingleNode("Request").InnerText);
wProcessConfiguration.Response = Convert.ToString(wNode.SelectSingleNode("Response").InnerText);
wProcessConfiguration.Available = Convert.ToBoolean(wNode.SelectSingleNode("Available").InnerText);
wProcessConfiguration.Audit = Convert.ToBoolean(wNode.SelectSingleNode("Audit").InnerText);
wProcessConfiguration.ProcessTransactionalBehaviour = (TransactionalBehaviour)Enum.Parse(typeof(TransactionalBehaviour), wNode.SelectSingleNode("ProcessTransactionalBehaviour").InnerText);
wProcessConfiguration.ProcessIsolationLevel = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), wNode.SelectSingleNode("ProcessIsolationLevel").InnerText);
wProcessConfiguration.Timeout = Convert.ToInt32(wNode.SelectSingleNode("Timeout").InnerText);
wResult.Add(wProcessConfiguration);
}
return wResult;
}
finally
{
wDocument = null;
}
}
/// <summary>
/// Actualiza la configuración de un proceso de negocio.
/// </summary>
/// <param name="pProcessConfiguration">Configuración del proceso de negocio.</param>
/// <date>2006-02-10T00:00:00</date>
/// <author>gmedina</author>
public void SetProcessConfiguration(ProcessConfiguration pProcessConfiguration)
{
XmlDocument wDocument;
XmlElement wNode;
try
{
wDocument = GetXMLProcessConfigurationDocument();
wNode = GetXMLProcessNode(pProcessConfiguration.Name, wDocument);
if (wNode == null)
{
throw new Exception("El proceso " + pProcessConfiguration.Name + " no se encuentra configurado.");
}
wNode.Attributes["Name"].InnerText = pProcessConfiguration.Name;
wNode.SelectSingleNode("Description").InnerText = pProcessConfiguration.Description;
wNode.SelectSingleNode("Handler").InnerText = pProcessConfiguration.Handler;
wNode.SelectSingleNode("Request").InnerText = pProcessConfiguration.Request;
wNode.SelectSingleNode("Response").InnerText = pProcessConfiguration.Response;
wNode.SelectSingleNode("Available").InnerText = pProcessConfiguration.Available.ToString();
wNode.SelectSingleNode("Audit").InnerText = pProcessConfiguration.Audit.ToString();
wNode.SelectSingleNode("ProcessTransactionalBehaviour").InnerText = Enum.GetName(typeof(TransactionalBehaviour), pProcessConfiguration.ProcessTransactionalBehaviour);
wNode.SelectSingleNode("ProcessIsolationLevel").InnerText = Enum.GetName(typeof(IsolationLevel),pProcessConfiguration.ProcessIsolationLevel);
wNode.SelectSingleNode("Timeout").InnerText = pProcessConfiguration.Timeout.ToString();
wDocument.Save(GetXMLRepositoryPath());
}
finally
{
wNode = null;
wDocument = null;
}
}
public MigratorBuilder <T> SetupProcessConfiguration(Func <ProcessConfiguration, ProcessConfiguration> configuration)
{
_processConfiguration = configuration(_processConfiguration);
return(this);
}
public List <ProcessConfiguration> GetProcessConfiguration()
{
var result = ProcessConfiguration.GetProcessConfiguration();
return(result);
}
/// <summary>
/// Almacena la configuración de un proceso de negocio.
/// </summary>
/// <param name="pProcessConfiguration">Configuración del proceso de negocio.</param>
/// <date>2006-02-10T00:00:00</date>
/// <author>gmedina</author>
public void SetProcessConfiguration(ProcessConfiguration pProcessConfiguration)
{
Datablock.Database wBPConfig = Datablock.DatabaseFactory.CreateDatabase(_DatabaseConfigSection.ConnectionName);
using (System.Data.Common.DbCommand wCmd = wBPConfig.GetStoredProcCommand("Process_u"))
{
wBPConfig.AddInParameter(wCmd, "Name", System.Data.DbType.String, pProcessConfiguration.Name);
wBPConfig.AddInParameter(wCmd, "Description", System.Data.DbType.String, pProcessConfiguration.Description);
wBPConfig.AddInParameter(wCmd, "Handler", System.Data.DbType.String, pProcessConfiguration.Handler);
wBPConfig.AddInParameter(wCmd, "Request", System.Data.DbType.String, pProcessConfiguration.Request);
wBPConfig.AddInParameter(wCmd, "Response", System.Data.DbType.String, pProcessConfiguration.Response);
wBPConfig.AddInParameter(wCmd, "Available", System.Data.DbType.String, pProcessConfiguration.Available);
wBPConfig.AddInParameter(wCmd, "Audit", System.Data.DbType.String, pProcessConfiguration.Audit);
wBPConfig.AddInParameter(wCmd, "ProcessTransactionalBehaviour", System.Data.DbType.String, Enum.GetName(typeof(TransactionalBehaviour), pProcessConfiguration.ProcessTransactionalBehaviour));
wBPConfig.AddInParameter(wCmd, "ProcessIsolationLevel", System.Data.DbType.String, Enum.GetName(typeof(IsolationLevel), pProcessConfiguration.ProcessIsolationLevel));
wBPConfig.AddInParameter(wCmd, "Timeout", System.Data.DbType.Int32, pProcessConfiguration.Timeout);
wBPConfig.AddInParameter(wCmd, "Cacheable", System.Data.DbType.Int32, pProcessConfiguration.Cacheable);
int wAffected = wBPConfig.ExecuteNonQuery(wCmd);
if (wAffected == 0)
{
throw new Exception("El proceso " + pProcessConfiguration.Name + " no se actualizó por no encontrarse configurado.");
}
}
}
public static ProcessViewModel ToViewModel(this ProcessConfiguration pc)
{
return(new ProcessViewModel(pc));
}
/// <summary>
/// Mapea los campos de una datarow a propiedades de una configuración de proceso.
/// </summary>
/// <returns>Configuracion de proceso de negocio.</returns>
/// <date>2006-02-13T00:00:00</date>
/// <author>gmedina</author>
private ProcessConfiguration GetProcessConfigurationFromRow(System.Data.DataRow pProcessRow)
{
ProcessConfiguration wProcessConfiguration = new ProcessConfiguration();
wProcessConfiguration.Name = Convert.ToString(pProcessRow["Name"]);
wProcessConfiguration.Description = Convert.ToString(pProcessRow["Description"]);
wProcessConfiguration.Handler = Convert.ToString(pProcessRow["Handler"]);
wProcessConfiguration.Request = Convert.ToString(pProcessRow["Request"]);
wProcessConfiguration.Response = Convert.ToString(pProcessRow["Response"]);
wProcessConfiguration.Available = Convert.ToBoolean(pProcessRow["Available"]);
wProcessConfiguration.Audit = Convert.ToBoolean(pProcessRow["Audit"]);
wProcessConfiguration.ProcessTransactionalBehaviour = (TransactionalBehaviour)Enum.Parse(typeof(TransactionalBehaviour), pProcessRow["ProcessTransactionalBehaviour"].ToString());
wProcessConfiguration.ProcessIsolationLevel = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), pProcessRow["ProcessIsolationLevel"].ToString());
wProcessConfiguration.Timeout = Convert.ToInt32(pProcessRow["Timeout"]);
wProcessConfiguration.Cacheable = Convert.ToBoolean(pProcessRow["Cacheable"]);
return wProcessConfiguration;
}
public int DeleteConfiguration(int id)
{
var result = ProcessConfiguration.DeleteConfiguration(id);
return(result);
}
/// <summary>
/// Ejecuta el servicio de negocio.
/// </summary>
/// <param name="pData">XML con datos de entrada.</param>
/// <param name="pServiceConfiguration">Configuración del servicio.</param>
/// <returns>XML que representa el resultado de la ejecución del servicio.</returns>
/// <date>2007-06-28</date>
/// <author>gmedina</author>
private string RunProcess(string pData, ProcessConfiguration pServiceConfiguration)
{
//por desgracia no transacciona porque no mandamos una excepcion. deberan ver como solucionarlo.
//no es grave, pero no llegué a ver como hacerlo. saludos. rodrigo.
//obtengo el tipo de request
Type wTipoEntidad = ReflectionFunctions.CreateType(pServiceConfiguration.Request);
//Creo un array de Objetos para pasar como parametro.
Object[] o = new Object[1];
o[0] = SerializationFunctions.Deserialize(wTipoEntidad, pData);
// Obtención del Response.
Type wProcessType = ReflectionFunctions.CreateType(pServiceConfiguration.Handler);
Object wProcessInstance = Activator.CreateInstance(wProcessType);
Object wResponse = wProcessType.GetMethod("Execute").Invoke(wProcessInstance, o);
return SerializationFunctions.Serialize(wResponse);
}
