Exemplo n.º 1
0
        private static void CreateSesiones(MAEUserSession be, byte idAplicacion)
        {
            SesionEntity se = new SesionEntity();

            se.IdUsuario                 = be.IdUsuario;
            se.Ip                        = be.Ip;
            se.FechaInicio               = be.FechaInicio;
            se.FechaFinalizacion         = be.FechaFinalizacion;
            se.IdAplicacion              = be.IdAplicacion;
            se.IdPersona                 = be.IdPersona;
            se.IdSesion                  = Guid.NewGuid();
            se.modifiedOrNew             = true;
            se.Global                    = be.Global;
            se.PrivateKey                = be.PrivateKey;
            se.PublicKey                 = be.PublicKey;
            se.ServerPublic              = be.ServerPublic;
            se.ServerSecret              = be.ServerPublic;
            se.ClientPublic              = be.ClientPublic;
            se.ClientSecret              = be.ClientSecret;
            se.Nonce                     = be.Nonce;
            se.JavascriptAllowedCommands = be.JavascriptAllowedCommands;
            se.PermisosUsuario           = be.PermisosUsuario;
            se.AllowedCommands           = be.AllowedCommands;
            se.ConfiguracionRegional     = be.ConfiguracionRegional;
            PersistSessionHelper.Instance.AddOrUpdate(se);
            be.InternalId = se.IdSesion;
            be.ID         = OrdenesApplication.Instance.GetSessionIdForRequest(se.IdSesion.ToString());
            GetSesionExistente(se.IdSesion, idAplicacion);
        }
        private Response ProcesamientoGenericaParalelo <T>(Func <T, string> accionAEjecutar, List <T> entidad)
        {
            Response resultado = new Response();

            resultado.Resultado = eResult.Ok;
            ConcurrentBag <string> resultadosOk    = new ConcurrentBag <string>();
            ConcurrentBag <string> resultadosError = new ConcurrentBag <string>();

            MAEUserSession sesion = MAEUserSession.Instancia;

            Parallel.ForEach(entidad, item =>
            {
                MAEUserSession.CargarInstancia(sesion);
                try
                {
                    resultadosOk.Add(accionAEjecutar(item));
                }
                catch (M4TraderApplicationException ex)
                {
                    resultadosError.Add(ex.Message);
                    resultado.Resultado = eResult.Error;
                }
                catch (MAESqlException ex)
                {
                    resultadosError.Add(ex.Message);
                    resultado.Resultado = eResult.Error;
                }
            });

            resultado.SetResponse(resultadosOk, resultadosError, entidad);

            return(resultado);
        }
Exemplo n.º 3
0
        public override object ExecuteCommand(InCourseRequest inCourseRequest)
        {
            //InfoCliente infoCliente = new InfoCliente(IP, "WebExterna");
            MAEUserSession session = SessionHelper.GetSesionExistente(sessionId, (byte)TipoAplicacion.WEBEXTERNA);

            return(ExecutionResult.ReturnInmediatelyAndQueueOthers(session));
        }
Exemplo n.º 4
0
        public static void InitSession(InfoCliente infoCliente, UsuarioEntity usuario, TipoAplicacion idAplicacion = TipoAplicacion.ORDENES)
        {
            MAEUserSession userSession            = new MAEUserSession();
            var            configuracionSeguridad = CachingManager.Instance.GetConfiguracionSeguridad();

            userSession.IdPersona             = (int)usuario.IdPersona;
            userSession.IdUsuario             = usuario.IdUsuario;
            userSession.Ip                    = infoCliente.Ip;
            userSession.Dispositivo           = infoCliente.Dispositivo;
            userSession.FechaInicio           = DateTime.Now;
            userSession.FechaFinalizacion     = MAEDateTimeTools.DateTimeAdd(DateTime.Now, configuracionSeguridad.TimeOutInicialSesion, "s");
            userSession.IdAplicacion          = (byte)idAplicacion;
            userSession.UltimaActualizacion   = usuario.UltimaActualizacion;
            userSession.ConfiguracionRegional = usuario.ConfiguracionRegional;

            //AESEncryptor encryptor = new AESEncryptor();
            //userSession.Global = encryptor.GetUniqueKey();
            //SecurityHelper.GetRSAKey(ref userSession);
            var clientKeyPair = PublicKeyBox.GenerateKeyPair();
            var serverKeyPair = PublicKeyBox.GenerateKeyPair();

            userSession.PrivateKey = Convert.ToBase64String(clientKeyPair.PrivateKey);
            userSession.PublicKey  = Convert.ToBase64String(clientKeyPair.PublicKey);

            userSession.ClientPublic              = Convert.ToBase64String(clientKeyPair.PublicKey);
            userSession.ClientSecret              = Convert.ToBase64String(clientKeyPair.PrivateKey);
            userSession.ServerPublic              = Convert.ToBase64String(serverKeyPair.PublicKey);
            userSession.ServerSecret              = Convert.ToBase64String(serverKeyPair.PrivateKey);
            userSession.Nonce                     = Convert.ToBase64String(PublicKeyBox.GenerateNonce());
            userSession.AllowedCommands           = new Dictionary <string, Type>();
            userSession.JavascriptAllowedCommands = new Dictionary <string, string>();
            userSession.PermisosUsuario           = new Dictionary <string, bool>();
            List <Permiso>           PermisosUsuario = CachingManager.Instance.GetAllPermisosByIdUsuario(userSession.IdUsuario);
            Dictionary <string, int> mapeoAcciones   = new Dictionary <string, int>();
            var Acciones = CachingManager.Instance.GetAllAcciones();

            OrdenesApplication.Instance.GetComandosHabilitados(idAplicacion)
            .ForEach(cmd =>
            {
                var k = OrdenesApplication.Instance.Encryptor.DynamicEncryption(cmd.FullName);
                userSession.AllowedCommands.Add(k, cmd.CommandType);
                userSession.JavascriptAllowedCommands.Add(cmd.Key, k);
                mapeoAcciones.Add(k, cmd.IdAccion);
            });
            foreach (KeyValuePair <string, int> kv in mapeoAcciones)
            {
                Permiso p = PermisosUsuario.Find(x => x.IdAccion == kv.Value);
                if (p != null)
                {
                    var  permisoAccion = Acciones.Find(x => x.IdAccion == kv.Value).HabilitarPermisos;
                    bool habilitado    = (p.Permisos & permisoAccion) != 0;
                    userSession.PermisosUsuario.Add(kv.Key, habilitado);
                }
            }
            CreateSesiones(userSession, (byte)idAplicacion);
            InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.InicioSesion, "Inicio de sesión exitoso", (byte)idAplicacion);
        }
        public override ExecutionResult ExecuteCommand(InCourseRequest inCourseRequest)
        {
            MAEUserSession usuarioSession = null;

            if (MAEUserSession.InstanciaCargada)
            {
                usuarioSession = MAEUserSession.Instancia;
            }
            return(ExecutionResult.ReturnInmediatelyAndQueueOthers(ConsultaDeSaldos(usuarioSession.IdPersona)));
        }
Exemplo n.º 6
0
        private List <NovedadTransferenciaEntity> ConsultaNovedadesDeTransferencia()
        {
            MAEUserSession usuarioSession = null;

            if (MAEUserSession.InstanciaCargada)
            {
                usuarioSession = MAEUserSession.Instancia;
            }
            return(NovedadDeTransferenciaHelper.ConsultaNovedadDeTransferencia(usuarioSession.IdPersona, FechaDesde, FechaHasta, IdMoneda, IdEstado, Receptor, Orden));
        }
        public static string get(InCourseRequest inCourseRequest, string WebUrlName)
        {
            DateTime fechaDelSistema = DateTime.Today;
            Guid     guidId          = inCourseRequest.SecurityTokenId;

            SessionHelper.GetSesionExistente(guidId);
            MAEUserSession userSession     = MAEUserSession.Instancia;
            var            beEstadoSistema = CachingManager.Instance.GetFechaSistema();

            if (beEstadoSistema != null)
            {
                fechaDelSistema           = beEstadoSistema.FechaSistema.Date;
                userSession.EstadoSistema = (beEstadoSistema.EstadoAbierto) ? "Abierto" : "Cerrado";
            }
            var          Permissions      = CachingManager.Instance.GetAllPermisosByIdUsuario(userSession.IdUsuario);
            DTOPortfolio DefaultPortfolio = CachingManager.Instance.GetPortfolioDefaultByIdUsuario(userSession.IdUsuario);
            string       CodigoPortfolio  = DefaultPortfolio?.Codigo;

            OrdenesAppContext context = new  OrdenesAppContext()
            {
                UserName                = userSession.UserName.ToString(),
                TipoParticipante        = UserHelper.getNombreTipoPersona(userSession.IdTipoPersona),
                SecurityTokenId         = userSession.ID.ToString(),
                WebUrlName              = WebUrlName,
                MaeAppName              = "Ordenes_v_500",
                EstadoSistema           = beEstadoSistema,
                FechaDelSistema         = fechaDelSistema,
                FormatoFechaCorta       = "dd/MM/yyyy",
                FormatoFechaCortaMoment = "DD/MM/YYYY",
                FormatoFechaHora        = "dd/MM/yyyy HH:mm",
                Global                    = userSession.Global,
                PublicKey                 = userSession.PublicKey,
                IdUsuario                 = userSession.IdUsuario,
                IdPersona                 = userSession.IdPersona,
                IdTipoPersona             = userSession.IdTipoPersona,
                ClientSecret              = userSession.ClientSecret,
                ServerPublic              = userSession.ServerPublic,
                Nonce                     = userSession.Nonce,
                JavascriptAllowedCommands = userSession.JavascriptAllowedCommands,
                PermisosUsuario           = userSession.PermisosUsuario,
                CodigoPortfolio           = CodigoPortfolio,
                LanguageTag               = userSession.ConfiguracionRegional,
                LoginRealizado            = userSession.LoginRealizado
            };



            var s = JsonConvert.SerializeObject(context, new JsonSerializerSettings
            {
                TypeNameHandling = TypeNameHandling.Objects,
                TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
            });

            return(s);
        }
Exemplo n.º 8
0
        public string Encrypt(string text, MAEUserSession user)
        {
            var encrypted = string.Empty;

            var bytes  = Encoding.UTF8.GetBytes(text);
            var eBytes = PublicKeyBox.Create(bytes, Convert.FromBase64String(user.Nonce), Convert.FromBase64String(user.ClientSecret), Convert.FromBase64String(user.ServerPublic));

            encrypted = Convert.ToBase64String(eBytes);

            return(encrypted);
        }
Exemplo n.º 9
0
 public static void UpdateSesionesContext(MAEUserSession be, bool finalizadaPorLogout = false)
 {
     lock (syncSession)
     {
         SesionEntity se = PersistSessionHelper.Instance.GetSessionById(be.InternalId);
         se.FechaFinalizacion   = be.FechaFinalizacion;
         se.IdPersona           = be.IdPersona;
         se.modifiedOrNew       = true;
         se.FinalizadaPorLogout = finalizadaPorLogout;
         PersistSessionHelper.Instance.AddOrUpdate(se);
     }
 }
Exemplo n.º 10
0
        public static void InsertarLogSeguridad(byte codigo, string descripcion, byte IdAplicacion = (byte)TipoAplicacion.ORDENES)
        {
            MAEUserSession     M4TraderUserSession = MAEUserSession.InstanciaCargada ? MAEUserSession.Instancia : null;
            LogSeguridadEntity lse = new LogSeguridadEntity
            {
                IdLogCodigoAccion = codigo,
                Fecha             = DateTime.Now,
                Descripcion       = descripcion,
                IdAplicacion      = IdAplicacion,
                IdUsuario         = M4TraderUserSession?.IdUsuario
            };

            LoggingService.Instance.AgregarLog(lse);
        }
Exemplo n.º 11
0
 public static void Logout(MAEUserSession be)
 {
     try
     {
         be.FechaFinalizacion = DateTime.Now;
         UsuarioEntity user        = CachingManager.Instance.GetByIdUsuario(be.IdUsuario);
         string        descripcion = CodeMensajes.GetDescripcionMensaje(CodeMensajes.INF_CIERRE_SESION);
         UpdateSesionesContext(be);
         //CachingManager.Instance.ClearSession(be.InternalId);
         //PersistSessionHelper.Instance.DeleteSession(be.ID);
     }
     catch (Exception e)
     {
         throw new M4TraderApplicationException("Error al desloguearse de la aplicación: " + e.Message);
     }
 }
Exemplo n.º 12
0
        public static M4TraderUserSessionLogin Login(string userName, string password, InfoCliente infoCliente, TipoAplicacion tipoAplicacion, string NombreAgencia = null, bool passHashed = false)
        {
            UserValido resultValidacion = new UserValido();

            try
            {
                resultValidacion = ValidateUser(userName, password, infoCliente, tipoAplicacion, NombreAgencia, passHashed);
            }

            catch (SessionException ex)
            {
                resultValidacion.NeedNewPassword = true;
                resultValidacion.IsOK            = false;
                resultValidacion.MensajeError    = ex.Code;
                resultValidacion.TokenGuid       = "";
            }
            MAEUserSession usuarioSession = null;

            if (MAEUserSession.InstanciaCargada)
            {
                usuarioSession = MAEUserSession.Instancia;
            }


            M4TraderUserSessionLogin userSessionLogin = new M4TraderUserSessionLogin()
            {
                Ok = resultValidacion.IsOK,
                DobleAutenticacion        = CachingManager.Instance.GetConfiguracionSeguridad().TieneDobleFactor,
                Message                   = resultValidacion.MensajeError,
                NeedNewPassword           = resultValidacion.NeedNewPassword,
                TokenGuid                 = resultValidacion.TokenGuid,
                SessionId                 = (usuarioSession == null) ? "" : usuarioSession.ID,
                IdUsuario                 = usuarioSession.IdUsuario,
                IdTipoPersona             = usuarioSession.IdTipoPersona,
                UserName                  = (usuarioSession == null) ? "" : usuarioSession.UserName,
                EstadoSistema             = (usuarioSession == null) ? "" : usuarioSession.EstadoSistema,
                TipoPersona               = (usuarioSession == null) ? "" : UserHelper.getNombreTipoPersona(usuarioSession.IdTipoPersona),
                NombrePersona             = (usuarioSession == null) ? "" : UserHelper.GetNombrePersona(usuarioSession.IdPersona),
                FechaSistema              = CachingManager.Instance.GetFechaSistema().FechaSistema,
                FechaFinalizacionSesion   = (usuarioSession == null) ? DateTime.Now : usuarioSession.FechaFinalizacion,
                JavascriptAllowedCommands = (usuarioSession == null) ? new System.Collections.Generic.Dictionary <string, string>() :usuarioSession.JavascriptAllowedCommands,
                PermisosUsuario           = (usuarioSession == null) ? new System.Collections.Generic.Dictionary <string, bool>() : usuarioSession.PermisosUsuario,
                LoginRealizado            = (usuarioSession == null) ? false : usuarioSession.LoginRealizado,
            };

            return(userSessionLogin);
        }
Exemplo n.º 13
0
        public string Decrypt(string datos, MAEUserSession user)
        {
            // Revisa si el parametro esta encriptado (si la cadena es base64)
            try
            {
                var isEncrypted = Convert.FromBase64String(datos);
            }
            catch (Exception)
            {
                return(datos);
            }

            var bytes  = Convert.FromBase64String(datos);
            var eBytes = PublicKeyBox.Open(bytes, Convert.FromBase64String(user.Nonce), Convert.FromBase64String(user.ServerPublic), Convert.FromBase64String(user.ClientSecret));
            var txt    = Encoding.UTF8.GetString(eBytes);

            return(txt);
        }
        public override ExecutionResult ExecuteCommand(InCourseRequest inCourseRequest)
        {
            MAEUserSession usuarioSession = SessionHelper.GetSesionExistente(inCourseRequest.SecurityTokenId);

            M4TraderUserSessionLogin userSessionLogin = new M4TraderUserSessionLogin()
            {
                SessionId                 = usuarioSession.ID,
                UserName                  = usuarioSession.UserName,
                EstadoSistema             = usuarioSession.EstadoSistema,
                TipoPersona               = UserHelper.getNombreTipoPersona(usuarioSession.IdTipoPersona),
                NombrePersona             = UserHelper.GetNombrePersona(usuarioSession.IdPersona),
                FechaSistema              = CachingManager.Instance.GetFechaSistema().FechaSistema,
                FechaFinalizacionSesion   = usuarioSession.FechaFinalizacion,
                JavascriptAllowedCommands = usuarioSession.JavascriptAllowedCommands,
                PermisosUsuario           = usuarioSession.PermisosUsuario
            };

            return(ExecutionResult.ReturnInmediatelyAndQueueOthers(userSessionLogin));
        }
Exemplo n.º 15
0
        public override ExecutionResult ExecuteCommand(InCourseRequest inCourseRequest)
        {
            Guid           guid           = OrdenesApplication.Instance.GetSessionIdFromRequest(sessionId);
            MAEUserSession usuarioSession = SessionHelper.GetSesionExistente(guid, (byte)TipoAplicacion.WEBEXTERNA);

            MAEUserSessionLogin userSessionLogin = new MAEUserSessionLogin()
            {
                SessionId                 = usuarioSession.ID,
                UserName                  = usuarioSession.UserName,
                EstadoSistema             = usuarioSession.EstadoSistema,
                TipoPersona               = UserHelper.getNombreTipoPersona(usuarioSession.IdTipoPersona),
                NombrePersona             = UserHelper.GetNombrePersona(usuarioSession.IdPersona),
                FechaSistema              = CachingManager.Instance.GetFechaSistema().FechaSistema,
                FechaFinalizacionSesion   = usuarioSession.FechaFinalizacion,
                JavascriptAllowedCommands = usuarioSession.JavascriptAllowedCommands,
                PermisosUsuario           = usuarioSession.PermisosUsuario
            };

            return(ExecutionResult.ReturnInmediatelyAndQueueOthers(userSessionLogin));
        }
Exemplo n.º 16
0
 public static void Logout(string sessionId, byte IdAplicacion = (byte)TipoAplicacion.ORDENES)
 {
     try
     {
         Guid           id          = OrdenesApplication.Instance.GetSessionIdFromRequest(sessionId);
         MAEUserSession userSession = SessionHelper.GetByIDSesiones(id);
         if (userSession != null)
         {
             userSession.FechaFinalizacion = DateTime.Now;
             SessionHelper.InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.CierreSesionExitoso, "usuario: " + userSession.UserName, IdAplicacion);
             UsuarioEntity user = CachingManager.Instance.GetByIdUsuario(userSession.IdUsuario);
             SessionHelper.UpdateSesionesContext(userSession, true);
             //CachingManager.Instance.ClearSession(userSession.InternalId);
         }
     }
     catch (Exception e)
     {
         SessionHelper.InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.CierreSesionNoExitoso, "Error: " + e.Message, IdAplicacion);
         throw new M4TraderApplicationException("Error al desloguearse de la aplicación: " + e.Message);
     }
 }
Exemplo n.º 17
0
        public static MAEUserSession GetSesionExistente(Guid idSesion, byte IdAplicacion = (byte)TipoAplicacion.ORDENES)
        {
            MAEUserSession session = GetByIDSesiones(idSesion);

            // OK existe la sesion?

            if (session == null)
            {
                InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.SesionExpirada, null, IdAplicacion);
                throw new SessionException(CodeMensajes.ERR_EXPIRO_SESION);
            }
            //Compara las fechas de las sesiones
            if (session.FechaFinalizacion < DateTime.Now)
            {
                UsuarioEntity u = UserHelper.GetByIDUsuarios(session.IdUsuario);
                if (!u.Proceso)
                {
                    InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.SesionExpirada, null, IdAplicacion);
                    throw new SessionException("La sesión se ha vencido.");
                }
                else
                {
                    var _beSeteos = CachingManager.Instance.GetConfiguracionSeguridad();
                    ExtenderSesion(session, _beSeteos);
                }
            }
            else
            {
                // Intenta extender la pass
                var _beSeteos = CachingManager.Instance.GetConfiguracionSeguridad();
                if (session.FechaFinalizacion <
                    (MAEDateTimeTools.DateTimeAdd(DateTime.Now, _beSeteos.TimeOutInicialSesion + _beSeteos.TimeOutExtensionSesion, "s")))
                {
                    ExtenderSesion(session, _beSeteos);
                }
            }
            MAEUserSession.CargarInstancia(session);
            return(session);
        }
Exemplo n.º 18
0
        private Response ProcesamientoGenericaParalelo <T>(Func <T, string> accionAEjecutar, List <T> entidad)
        {
            Response resultado = new Response();

            resultado.Resultado = eResult.Ok;
            ConcurrentBag <string> resultadosOk    = new ConcurrentBag <string>();
            ConcurrentBag <string> resultadosError = new ConcurrentBag <string>();

            MAEUserSession sesion = MAEUserSession.Instancia;

            Parallel.ForEach(entidad, item =>
            {
                MAEUserSession.CargarInstancia(sesion);
                try
                {
                    resultadosOk.Add(accionAEjecutar(item));
                }
                catch (MAEConcurrencyException ex)
                {
                    resultado.Resultado = eResult.Error;
                    resultadosError.Add(ex.Message);
                }

                catch (M4TraderApplicationException ex)
                {
                    bool teniaCol = false;
                    if (ex.Oks != null && ex.Oks.Count > 0)
                    {
                        teniaCol = true;
                        ex.Oks.ForEach(x => resultadosOk.Add(x));
                        resultado.Resultado = eResult.Ok;
                    }
                    if (ex.Errores != null && ex.Errores.Count > 0)
                    {
                        ex.Errores.ForEach(x => resultadosError.Add(x));
                        if (teniaCol)
                        {
                            resultado.Resultado = eResult.Warning;
                        }
                        else
                        {
                            resultado.Resultado = eResult.Error;
                        }
                        teniaCol = true;
                    }
                    if (!teniaCol)
                    {
                        resultadosError.Add(ex.Message);
                        resultado.Resultado = eResult.Error;
                    }
                }
                catch (MAESqlException ex)
                {
                    resultadosError.Add(ex.Message);
                    resultado.Resultado = eResult.Error;
                }
            });

            resultado.SetResponse(resultadosOk, resultadosError, entidad);

            return(resultado);
        }
Exemplo n.º 19
0
 private static void ExtenderSesion(MAEUserSession session, ConfiguracionSeguridadEntity _beSeteos)
 {
     session.FechaInicio       = DateTime.Now;
     session.FechaFinalizacion = MAEDateTimeTools.DateTimeAdd(DateTime.Now, _beSeteos.TimeOutInicialSesion, "s");
     UpdateSesionesContext(session);
 }
        public override ExecutionResult Execute(InCourseRequest inCourseRequest)
        {
            MAEUserSession result = SessionHelper.GetSesionExistente(SecurityTokenId, (byte)TipoAplicacion.API);

            return(ExecutionResult.ReturnInmediatelyAndQueueOthers(result));
        }
Exemplo n.º 21
0
        private void ProcessXml(TipoXmlAProcesar tipoXml, Guid guid)
        {
            Clock.Stop();
            string subPath    = string.Empty;
            string parentNode = string.Empty;
            string prefix     = string.Empty;


            // Get File Path
            switch (tipoXml)
            {
            case TipoXmlAProcesar.Clientes:
                subPath    = "Clientes";
                parentNode = "BEPersonasParticipantes";
                break;

            case TipoXmlAProcesar.Productos:
                subPath    = "Productos";
                parentNode = "BEProductos";
                break;

            case TipoXmlAProcesar.Saldos:
                subPath    = "Saldos";
                parentNode = "SaldoEntity";
                break;

            default:
                break;
            }

            prefix = parentNode;


            var path = Path.Combine(BasePath, subPath);

            if (!Directory.Exists(path))
            {
                return;
            }

            MAEUserSession.CargarInstancia(OrdenesApplication.Instance.SessionUsuarioProceso);

            var file = Directory.GetFiles(path).FirstOrDefault();

            if (file == null)
            {
                return;
            }

            var         xmldoc = new XmlDocument();
            XmlNodeList xmlnodes;

            var hasErrors = false;
            var filename  = string.Empty;

            try
            {
                using (FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read))
                {
                    xmldoc.Load(fs);
                    xmlnodes = xmldoc.GetElementsByTagName(parentNode);

                    if (xmlnodes.Count > 0)
                    {
                        switch (tipoXml)
                        {
                        case TipoXmlAProcesar.Clientes:
                            var clientes = new List <ClienteXMLEntity>();
                            hasErrors = ReadXmlNodes <ClienteXMLEntity>(xmlnodes, TipoXmlAProcesar.Clientes, clientes, guid);
                            if (hasErrors)
                            {
                                break;
                            }
                            SendXmlToDAL(clientes, TipoXmlAProcesar.Clientes);
                            break;

                        case TipoXmlAProcesar.Productos:
                            var productos = new List <ProductoXMLEntity>();
                            hasErrors = ReadXmlNodes <ProductoXMLEntity>(xmlnodes, TipoXmlAProcesar.Productos, productos, guid);
                            if (hasErrors)
                            {
                                break;
                            }
                            SendXmlToDAL(productos, TipoXmlAProcesar.Productos);
                            break;

                        case TipoXmlAProcesar.Saldos:
                            var saldos = new List <SaldoXMLEntity>();
                            hasErrors = ReadXmlNodes <SaldoXMLEntity>(xmlnodes, TipoXmlAProcesar.Saldos, saldos, guid);
                            if (hasErrors)
                            {
                                break;
                            }
                            SendXmlToDAL(saldos, TipoXmlAProcesar.Saldos);
                            break;

                        default:
                            break;
                        }
                    }
                    var date = DateTime.Now;
                    if (hasErrors)
                    {
                        if (!Directory.Exists(Path.Combine(BasePath, subPath, "NoProcesados")))
                        {
                            Directory.CreateDirectory(Path.Combine(BasePath, subPath, "NoProcesados"));
                        }
                        filename = Path.Combine(BasePath, subPath, "NoProcesados", $"{prefix}{date.Year}{date.Month}{date.Day}{date.Hour}{date.Minute}.xml");
                    }
                    else
                    {
                        if (!Directory.Exists(Path.Combine(BasePath, subPath, "Procesados")))
                        {
                            Directory.CreateDirectory(Path.Combine(BasePath, subPath, "Procesados"));
                        }
                        filename = Path.Combine(BasePath, subPath, "Procesados", $"{prefix}{date.Year}{date.Month}{date.Day}{date.Hour}{date.Minute}.xml");
                        LoggingHelper.Instance.AgregarLog(new LogProcesoEntity(guid, OrdenesApplication.Instance.SessionUsuarioProceso.IdUsuario)
                        {
                            Fecha = DateTime.Now, IdLogCodigoAccion = (byte)LogCodigoAccion.ProcesadoXMLCorrectamente, Descripcion = "Importar: " + tipoXml + ".Nombre Archivo: " + filename, IdUsuario = MAEUserSession.Instancia.IdUsuario
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                hasErrors = true;
                var date = DateTime.Now;
                if (!Directory.Exists(Path.Combine(BasePath, subPath, "NoProcesados")))
                {
                    Directory.CreateDirectory(Path.Combine(BasePath, subPath, "NoProcesados"));
                }
                filename = Path.Combine(BasePath, subPath, "NoProcesados", $"{prefix}{date.Year}{date.Month}{date.Day}{date.Hour}{date.Minute}.xml");
                LoggingHelper.Instance.AgregarLog(new LogProcesoEntity(guid, OrdenesApplication.Instance.SessionUsuarioProceso.IdUsuario)
                {
                    Fecha = DateTime.Now, IdLogCodigoAccion = (byte)LogCodigoAccion.ProcesadoXMLConError, Descripcion = "Importar: " + tipoXml + ".Msg: " + ex.Message, Exception = ex, IdUsuario = MAEUserSession.Instancia.IdUsuario
                });
            }
            finally
            {
                var date = DateTime.Now;
                var dest = Path.Combine(BasePath, subPath, filename);
                File.Copy(file, dest);
                File.Delete(file);
            }
        }
        public List <MenuOrdenesItem> GetMenuOrdenesItems(byte?tipo)
        {
            //List<MenuOrdenesItem> menuAllItems = new List<MenuOrdenesItem>();
            //List<MenuOrdenesItem> menuItemsWithPermissions = new List<MenuOrdenesItem>();

            string subfolder = string.Empty;

            switch (tipo)
            {
            case (byte)TipoAplicacion.WEBEXTERNASECURITY:
                subfolder = "Security/";
                break;

            case (byte)TipoAplicacion.WEBEXTERNA:
                subfolder = "Extranet/";
                break;

            case (byte)TipoAplicacion.MOBILE:
                subfolder = "Mobile/";
                break;

            default:
                break;
            }

            string filePath = string.Empty;

            if (System.Web.Hosting.HostingEnvironment.ApplicationID != null)
            {
                filePath = System.Web.Hosting.HostingEnvironment.MapPath("~/Configuracion/") + subfolder + "Menu.json";
            }
            else
            {
                filePath = System.Environment.CurrentDirectory;
                filePath = Path.Combine(filePath, "Configuracion/", subfolder) + "Menu.json";
            }
            var         jsonString = File.ReadAllText(filePath);
            MenuOrdenes menu       = JsonConvert.DeserializeObject <MenuOrdenes>(jsonString);
            var         topMenu    = menu.top;

            MAEUserSession    M4TraderUserSession = MAEUserSession.Instancia;
            List <MenuAction> actions             = this.DoGetActions();
            List <Permiso>    permissions         = CachingManager.Instance.GetAllPermisosByIdUsuario(M4TraderUserSession.IdUsuario);

            bool allowedAction = false;

            foreach (var menuOrdenesItem in topMenu)
            {
                foreach (var item in menuOrdenesItem.items)
                {
                    List <Permiso> permissionsOfAction = permissions.FindAll(permission => permission.IdAccion == item.actionId);
                    allowedAction = false;
                    if (item.actionId != 0)
                    {
                        if (permissionsOfAction.Count == 1)
                        {
                            if (item.permissionMask != 0)
                            {
                                MenuAction action = actions.FirstOrDefault(a => a.ActionId == item.actionId);
                                if (action != null)
                                {
                                    int calculatedPermissionMask = item.permissionMask &
                                                                   permissionsOfAction[0].Permisos &
                                                                   action.PermisosHabilitados;
                                    if (calculatedPermissionMask == item.permissionMask)
                                    {
                                        allowedAction = true;
                                    }
                                }
                            }
                            else
                            {
                                allowedAction = true;
                            }
                            item.permissionPermitted = permissionsOfAction[0].Permisos;
                        }
                        else if (permissionsOfAction.Count > 1)
                        {
                            throw new M4TraderApplicationException("Error de permisos. Existe mas de un Permission para una acción dada.");
                        }
                    }
                    else
                    {
                        allowedAction = true;
                    }

                    item.allowed = allowedAction;
                }
            }

            foreach (var menuOrdenesItem in topMenu)
            {
                for (var i = 0; i < menuOrdenesItem.items.Count; i++)
                {
                    if (!menuOrdenesItem.items[i].allowed)
                    {
                        menuOrdenesItem.items.RemoveAt(i);
                        i--;
                    }
                }
            }

            return((from p in topMenu
                    where p.items.Any(c => c.allowed == true)
                    select p).ToList <MenuOrdenesItem>());
        }