/// <summary>
/// Solo chequea si existe el proveedor. Si no, lanza una excepción.-
/// </summary>
/// <param name="providerName"></param>
static void CheckWrapperExist(string providerName, IServiceContract res)
{
//Dado que el proveedor por defecto es agregado como String.Empty
if (String.IsNullOrEmpty(providerName))
{
providerName = _DefaultProviderName;
}
if (!_WraperPepository.ContainsKey(providerName))
{
TechnicalException te;
if (providerName.Equals(_DefaultProviderName))
{
te = new TechnicalException(string.Concat("El proveedor de configuración del wrapper por defecto del lado del cliente, no existe, verifique en el archivo de configuracion si existe la seccion FwkWrapper y el proveedor por defecto"));
}
else
{
te = new TechnicalException(string.Concat("El proveedor de configuración del wrapper ", providerName, " del lado del cliente, no existe, verifique en el archivo de configuracion si existe la seccion FwkWrapper y el proveedor mencionado"));
}
te.ErrorId = "6000";
Fwk.Exceptions.ExceptionHelper.SetTechnicalException(te, typeof(WrapperFactory));
res.Error = ProcessConnectionsException.Process(te);
}
}
/// <summary>
/// Ejecuta un servicio de negocio. (Metodo vigente solo por compatibilidad con versiones anteriores donde se pasaba el
/// nombre del servicio como parametro.-
/// </summary>
/// <param name="pReq">Clase que implementa IServiceContract con datos de entrada para la ejecución del servicio.</param>
/// <returns>Clase que implementa IServiceContract con datos de respuesta del servicio.</returns>
/// <date>2007-06-23T00:00:00</date>
/// <author>moviedo</author>
public TResponse ExecuteService <TRequest, TResponse>(TRequest pReq)
where TRequest : IServiceContract
where TResponse : IServiceContract, new()
{
pReq.InitializeHostContextInformation();
TResponse wResponse = new TResponse();
try
{
pReq.InitializeHostContextInformation();
string wResult = ExecuteService(pReq.ServiceName, pReq.GetXml());
//wResponse.SetXml(wResult);
//16/05/2012 Se deja esta serializacion se comenta la anterior
//Motivo: Cuando el Response implementaba un BussinesData escalar o entidad no List y se retornaba Null (en BussinesData)
//No se podia hace un SetXml
wResponse = (TResponse)Fwk.HelperFunctions.SerializationFunctions.DeserializeFromXml(typeof(TResponse), wResult);
//wResponse.InitializeHostContextInformation();
}
catch (Exception ex)
{
wResponse.Error = ProcessConnectionsException.Process(ex, _URL);
}
//wResponse.InitializeHostContextInformation();
return(wResponse);
}
/// <summary>
/// Inicializa un wrapper deacuerdo el nombre del proveedor
/// Carga al wrapper el nombre
/// </summary>
/// <param name="providerName">Proveedor del wrapper. Este valor debe coincidir con un proveedor de metadata en el dispatcher</param>
internal static void InitWrapper(string providerName)
{
//Si no se espesifica npmbre de provdor se da por entendido que se trata de un proveedor por defecto
if (String.IsNullOrEmpty(providerName))
{
providerName = _DefaultProviderName;
}
if (!_WraperPepository.ContainsKey(providerName))
{
try
{
WrapperProviderElement provider = _ProviderSection.GetProvider(providerName);
if (provider == null)
{
TechnicalException te;
if (providerName.Equals(_DefaultProviderName))
{
te = new TechnicalException(string.Concat("El proveedor de configuración del wrapper por defecto del lado del cliente, no existe, verifique en el archivo de configuracion si existe la seccion FwkWrapper y el proveedor por defecto"));
}
else
{
te = new TechnicalException(string.Concat("El proveedor de configuración del wrapper ", providerName, " del lado del cliente, no existe, verifique en el archivo de configuracion si existe la seccion FwkWrapper y el proveedor mencionado"));
}
te.ErrorId = "6000";
Fwk.Exceptions.ExceptionHelper.SetTechnicalException(te, typeof(WrapperFactory));
throw te;
}
///No se almacenan mas providers con String.Empty
//if (provider.Name.Equals(_ProviderSection.DefaultProviderName)) providerName = String.Empty;
IServiceWrapper w = (IServiceWrapper)ReflectionFunctions.CreateInstance(provider.WrapperProviderType);
w.ProviderName = provider.Name;
w.SourceInfo = provider.SourceInfo;
w.ServiceMetadataProviderName = provider.ServiceMetadataProviderName;
w.AppId = provider.AppId;
//w.DefaultCulture = provider.DefaultCulture;
_WraperPepository.Add(providerName, w);
}
catch (Exception ex)
{
ServiceError wServiceError = ProcessConnectionsException.Process(ex);
TechnicalException te = new TechnicalException(wServiceError.Assembly, wServiceError.Namespace, wServiceError.Class, wServiceError.Machine, wServiceError.UserName, wServiceError.Message, ex);
throw te;
}
}
}
/// <summary>
/// Ejecuta un servicio de negocio.
/// Si se produce el error:
/// The parameter is incorrect. (Exception from HRESULT: 0x80070057 (E_INVALIDARG))
/// Se debe a un error que lanza una llamada asincrona en modo debug
/// </summary>
/// <param name="req">Clase que imlementa la interfaz IServiceContract datos de entrada para la ejecución del servicio.</param>
/// <returns>Clase que imlementa la interfaz IServiceContract con datos de respuesta del servicio.</returns>
/// <returns>response</returns>
public TResponse ExecuteService <TRequest, TResponse>(TRequest req)
where TRequest : IServiceContract
where TResponse : IServiceContract, new()
{
FwkRemoteObject wFwkRemoteObject = CreateRemoteObject();
TResponse response;
try
{
req.InitializeHostContextInformation();
response = (TResponse)wFwkRemoteObject.ExecuteService(_ServiceMetadataProviderName, req);
response.InitializeHostContextInformation();
}
catch (Exception ex)
{
response = new TResponse();
response.Error = ProcessConnectionsException.Process(ex, "");
}
return(response);
}
/// <summary>
/// Ejecuta un servicio de negocio. (Metodo vigente solo por compatibilidad con versiones anteriores donde se pasaba el
/// nombre del servicio como parametro.-
/// Si se produce el error:
/// The parameter is incorrect. (Exception from HRESULT: 0x80070057 (E_INVALIDARG))
/// Se debe a un error que lanza una llamada asincrona en modo debug
/// </summary>
/// <param name="pReq">Clase que implementa IServiceContract con datos de entrada para la ejecución del servicio.</param>
/// <returns>Clase que implementa IServiceContract con datos de respuesta del servicio.</returns>
/// <date>2011-06-23T00:00:00</date>
/// <author>moviedo</author>
public TResponse ExecuteService <TRequest, TResponse>(TRequest pReq)
where TRequest : IServiceContract
where TResponse : IServiceContract, new()
{
pReq.InitializeHostContextInformation();
TResponse wResponse = new TResponse();
try
{
pReq.InitializeHostContextInformation();
string wResult = ExecuteService(pReq.ServiceName, pReq.GetXml());
//wResponse.SetXml(wResult);
wResponse = (TResponse)Fwk.HelperFunctions.SerializationFunctions.DeserializeFromXml(typeof(TResponse), wResult);
//wResponse.InitializeHostContextInformation();
}
catch (Exception ex)
{
wResponse.Error = ProcessConnectionsException.Process(ex, _URL);
}
//wResponse.InitializeHostContextInformation();
return(wResponse);
}
/// <summary>
/// Ejecuta un servicio de negocio
/// Si se produce el error:
/// The parameter is incorrect. (Exception from HRESULT: 0x80070057 (E_INVALIDARG))
/// Se debe a un error que lanza una llamada asincrona en modo debug
/// </summary>
/// <typeparam name="TRequest">Tipo del Request</typeparam>
/// <typeparam name="TResponse">Tipo del Response</typeparam>
/// <param name="providerName">Proveedor del wrapper</param>
/// <param name="pRequest">Objeto request del tipo </param>
/// <returns></returns>
public static TResponse ExecuteService <TRequest, TResponse>(string providerName, TRequest pRequest)
where TRequest : IServiceContract
where TResponse : IServiceContract, new()
{
TResponse wResponse = new TResponse();
//no se utiliza mas este codigo debido q los wrappers se cargan en el constructor estatico
//InitWrapper(providerName);//Commented because every provider was loaded on static init constructor
if (String.IsNullOrEmpty(providerName))
{
providerName = _DefaultProviderName;
}
CheckWrapperExist(providerName, wResponse);
Boolean wExecuteOndispatcher = true;
//Si no ocurrio algun error
if (wResponse.Error == null)
{
IServiceContract res = null;
IRequest req = (IRequest)pRequest;
if (string.IsNullOrEmpty(req.ContextInformation.AppId))
{
req.ContextInformation.AppId = _WraperPepository[providerName].AppId;
}
if (String.IsNullOrEmpty(req.ContextInformation.ProviderNameWithCultureInfo))
{
req.ContextInformation.ProviderNameWithCultureInfo = _WraperPepository[providerName].ConfigProviderNameWithCultureInfo;
}
if (String.IsNullOrEmpty(req.ContextInformation.Culture))
{
req.ContextInformation.Culture = Thread.CurrentThread.CurrentCulture.Name;
}
#region Caching del servicio.
if (req.CacheSettings != null && req.CacheSettings.CacheOnClientSide) //--------------------------------------->>> Implement the cache factory
{
try
{
res = ServiceCacheMannager.Get(req);
wResponse = (TResponse)res;
//Si estaba en la cache no es necesario llamar al despachador de servicio
if (wResponse != null)
{
wExecuteOndispatcher = false;
}
}
catch (System.Security.SecurityException)
{
}
}
#endregion
if (wExecuteOndispatcher)
{
try
{
wResponse = _WraperPepository[providerName].ExecuteService <TRequest, TResponse>(pRequest);
}
catch (TechnicalException te)
{
if (te.ErrorId.Equals("7201"))
{
wResponse.Error = ProcessConnectionsException.Process(
new TechnicalException(
String.Format(Fwk.Bases.Properties.Resources.Wrapper_ServiceMetadataProviderName_NotExist,
_WraperPepository[providerName].ProviderName, te)));
}
else
{
wResponse.Error = ProcessConnectionsException.Process(te);
}
}
catch (Exception ex)
{
wResponse.Error = ProcessConnectionsException.Process(ex);
}
//Si aplica cache y se llamo a la ejecucion se debe almacenar en cache para proxima llamada
if (req.CacheSettings != null && req.CacheSettings.CacheOnClientSide)
{
//Es posible que la ejecucion produzca algun error y por lo tanto no se permitira
//su almacen en cache
if (wResponse.Error == null)
{
ServiceCacheMannager.Add(req, wResponse);
}
}
}
}
return(wResponse);
}