Beispiel #1
0
        /// <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);
            }
        }
Beispiel #2
0
        /// <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);
        }
Beispiel #3
0
        /// <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;
                }
            }
        }
Beispiel #4
0
        /// <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);
        }
Beispiel #5
0
        /// <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);
        }
Beispiel #6
0
        /// <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);
        }