public List <DTOMercado> GetAllMercados()
{
string keyCache = KEY_ALL_MERCADOS;
List <DTOMercado> mercados = CacheLayer.Get <List <DTOMercado> >(keyCache);
if (mercados == null)
{
List <MercadoEntity> mercadoEntities;
using (var ctx = new OrdenesContext())
{
mercadoEntities = (from d in ctx.Mercado select d).ToList <MercadoEntity>();
}
if (mercadoEntities != null)
{
mercados = new List <DTOMercado>();
foreach (MercadoEntity mercado in mercadoEntities)
{
mercados.Add(new DTOMercado()
{
IdMercado = mercado.IdMercado,
Codigo = mercado.Codigo,
Descripcion = mercado.Descripcion,
EsInterno = mercado.EsInterno,
ProductoHabilitadoDefecto = mercado.ProductoHabilitadoDefecto
});
}
CacheLayer.Add <List <DTOMercado> >(mercados, keyCache);
}
}
return(mercados);
}
public List <DTOPortfolio> GetPortfoliosByIdPersona(int idPersona)
{
string keyCache = KEY_PORTFOLIO_BY_PERSONA + "#" + idPersona;
List <DTOPortfolio> dtoPortfolio = CacheLayer.Get <List <DTOPortfolio> >(keyCache);
if (dtoPortfolio == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
dtoPortfolio = (from p in mc.Portfolios
join pu in mc.PortfoliosUsuario on p.IdPortfolio equals pu.IdPortfolio
join u in mc.Usuario on pu.IdUsuario equals u.IdUsuario
where u.IdPersona == idPersona
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).Distinct().ToList();
}
if (dtoPortfolio != null)
{
CacheLayer.Add(dtoPortfolio, keyCache);
}
}
return(dtoPortfolio);
}
public DTOUsuario GetUsuariosPartiesDTO(Int64 idUsuario)
{
string keyCache = KEY_USUARIOS_PARTIES + "#" + idUsuario;
DTOUsuario usuarioParty = CacheLayer.Get <DTOUsuario>(keyCache);
if (usuarioParty == null)
{
using (OrdenesContext context = new OrdenesContext())
{
usuarioParty = (from d in context.Usuario
where d.IdUsuario == idUsuario
select new DTOUsuario()
{
IdParty = d.IdPersona,
IdUsuario = d.IdUsuario
}
).FirstOrDefault();
}
if (usuarioParty != null)
{
CacheLayer.Add(usuarioParty, keyCache);
}
}
return(usuarioParty);
}
public DTOPortfolio GetPortfolioById(int idPortfolio)
{
string keyCache = PORTFOLIOS_ALL;
List <DTOPortfolio> dtoPortfolios = CacheLayer.Get <List <DTOPortfolio> >(keyCache);
if (dtoPortfolios == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
dtoPortfolios = (from p in mc.Portfolios
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).ToList();
}
if (dtoPortfolios != null)
{
CacheLayer.Add(dtoPortfolios, keyCache);
}
}
return(dtoPortfolios.Find(x => x.IdPortfolio == idPortfolio));
}
public static void CerrarElDia(int idUsuario)
{
using (ReadCommittedTransactionScope scope = new ReadCommittedTransactionScope(TransactionScopeOption.Required))
{
using (OrdenesContext context = new OrdenesContext())
{
int idEstadoSistema = context.EstadoSistema.Where(p1 => p1.IdEstadoSistema != 0).Max(r => r.IdEstadoSistema);
var entidad = context.EstadoSistema.Where(p => p.IdEstadoSistema == idEstadoSistema).FirstOrDefault();
if (entidad != null)
{
EstadoSistemaEntity request = entidad;
request.EjecucionValidacion = true;
request.EstadoAbierto = false;
request.FechaCierre = DateTime.Now;
request.IdUsuarioCierre = idUsuario;
}
if (!entidad.EstadoAbierto)
{
//Si el Dia ya estaba cerrado, no lo vuelvo a cerrar
context.SaveChanges();
}
}
PortfolioHelper.DesAsociarPortfoliosProductosFCE();
scope.Complete();
}
}
public DTOPortfolio GetPortfolioByCodigo(string codigo)
{
string keyCache = KEY_PORTFOLIO_CODIGO + "#" + codigo;
DTOPortfolio dtoPortfolio = CacheLayer.Get <DTOPortfolio>(keyCache);
if (dtoPortfolio == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
dtoPortfolio = (from p in mc.Portfolios
where p.Codigo == codigo
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).FirstOrDefault();
}
if (dtoPortfolio != null)
{
CacheLayer.Add(dtoPortfolio, keyCache);
}
}
return(dtoPortfolio);
}
private static UsuarioEntity ValidateUser(string Username)
{
UsuarioEntity usuario = new UsuarioEntity();
using (OrdenesContext mcc = new OrdenesContext())
{
usuario = (from d in mcc.Usuario where d.Username.Equals(Username) select d).FirstOrDefault();
}
if (usuario == null)
{
SessionHelper.InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.UsuarioInexistente, "Username ingresado: " + Username, (byte)TipoAplicacion.ORDENES);
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_AUTHENTICATEUSUARIO, false);
}
if (usuario.BajaLogica)
{
SessionHelper.InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.UsuarioBajaLogica, null, (byte)TipoAplicacion.ORDENES);
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_AUTHENTICATEUSUARIO, false);
}
if (usuario.Bloqueado)
{
SessionHelper.InsertarLogSeguridad((byte)LogCodigoAccionSeguridad.UsuarioBloqueado, null, (byte)TipoAplicacion.ORDENES);
AdministradorControlErrores.EnviarExcepcion(CodeMensajes.ERR_USUARIOBLOQUEADO, false, usuario.Username);
}
return(usuario);
}
public DTOPortfolio GetPortfolioByIdProducto(int idProducto)
{
string keyCache = PORTFOLIOS_ALL;
List <DTOPortfolio> dtoPortfolios = CacheLayer.Get <List <DTOPortfolio> >(keyCache);
PortfolioComposicionEntity pce = new PortfolioComposicionEntity();
using (OrdenesContext mc = new OrdenesContext())
{
pce = (from pc in mc.PortfoliosComposicion
where pc.IdProducto == idProducto
select pc).FirstOrDefault();
if (dtoPortfolios == null)
{
dtoPortfolios = (from p in mc.Portfolios
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).ToList();
CacheLayer.Add(dtoPortfolios, keyCache);
}
}
return(dtoPortfolios.Find(x => x.IdPortfolio == pce.IdPortfolio));
}
public ConcurrentDictionary <int, List <DTOUsuario> > GetChatsUsuarios()
{
string keyCache = KEY_USUARIOS_CHATS;
ConcurrentDictionary <int, List <DTOUsuario> > dicChatUsuarios = CacheLayer.Get <ConcurrentDictionary <int, List <DTOUsuario> > >(keyCache);
if (dicChatUsuarios == null)
{
dicChatUsuarios = new ConcurrentDictionary <int, List <DTOUsuario> >();
using (OrdenesContext dbContext = new OrdenesContext())
{
List <ChatEntity> chats = (from d in dbContext.Chats
select d).ToList();
foreach (ChatEntity chat in chats)
{
List <DTOUsuario> usuarios = (from d in dbContext.ChatUsuarios
where d.IdChat == chat.IdChat
select new DTOUsuario()
{
IdUsuario = d.IdUsuario
}).ToList();
//TODO validar que se puede hacer si no logra agregarlo
dicChatUsuarios.TryAdd(chat.IdChat, usuarios);
}
}
if (dicChatUsuarios != null)
{
CacheLayer.Add <ConcurrentDictionary <int, List <DTOUsuario> > >(dicChatUsuarios, keyCache);
}
}
return(dicChatUsuarios);
}
public static bool ExistsClaveHistorica(int idUsuario, long cantidadHistoricas, string clave)
{
bool _result = false;
/*** Martin Modificado 20/sept/2004
*** No se valida en caso de no tener seteada la cantidad maxima de password historica **/
if (cantidadHistoricas > 0)
{
using (OrdenesContext context = new OrdenesContext())
{
List <HistoricoPasswordEntity> beCollHistoricoPassword = (from d in context.HistoricoPass
where d.IdUsuario == idUsuario
select d).OrderByDescending(x => x.IdHistoricoPassword).ToList();
if (beCollHistoricoPassword.Count > 0)
{
for (int i = 0; i <= cantidadHistoricas; i++)
{
if (i == beCollHistoricoPassword.Count)
{
break;
}
if ((clave) == beCollHistoricoPassword[i].Pass)
{
_result = true;
break;
}
}
}
}
}
return(_result);
}
public static PartyEntity GetPersona(int idPersona)
{
using (OrdenesContext context = new OrdenesContext())
{
PartyEntity persona = (from d in context.Persona
where d.IdParty == idPersona
select d).FirstOrDefault();
return((persona == null) ? null : persona);
}
}
public static void AbrirElDia(int idUsuario)
{
bool cerrarAntes = false;
//TODO: se lo deshabilito temporalmente porque requiere tener habilitado el servicio MS MSDTC (Distributed Transaction Server)
//using (ReadCommittedTransactionScope scope = new ReadCommittedTransactionScope(TransactionScopeOption.Required))
//{
EstadoSistemaEntity estadoSistema;
using (OrdenesContext context = new OrdenesContext())
{
int idEstadoSistema = context.EstadoSistema.Where(p1 => p1.IdEstadoSistema != 0).Max(r => r.IdEstadoSistema);
estadoSistema = context.EstadoSistema.Where(p => p.IdEstadoSistema == idEstadoSistema).FirstOrDefault();
if (estadoSistema.EstadoAbierto)
{
cerrarAntes = true;
}
if (!cerrarAntes)
{
CleanOfertas_Precios();
CleanLimitesDiarios();
//context.OpenConnection();
EstadoSistemaEntity request = new EstadoSistemaEntity()
{
EjecucionValidacion = false,
EstadoAbierto = true,
FechaCierre = null,
IdUsuarioCierre = null,
FechaApertura = DateTime.Now,
FechaSistema = DateTime.Now,
BajaLogica = false,
IdUsuarioApertura = idUsuario
};
context.Add(request);
context.SaveChanges();
estadoSistema = request;
}
else
{
OrdenHelper.ActualizarOrdenes();
}
}
if (!cerrarAntes)
{
OrdenHelper.InformarMercadoEstado((byte)TipoEstadoSistema.ULTIMO_ABIERTO, "AbrirSistemaCommand");
// scope.Complete();
//}
}
//TODO validar
else if (estadoSistema.FechaSistema.Date != DateTime.Now.Date)
{
CerrarElDiaYAbrirlo(idUsuario);
}
}
public static void BlockUsuarios(int idUsuario, byte codigoAccionSeguridad)
{
using (OrdenesContext context = new OrdenesContext())
{
UsuarioEntity usuario = (from d in context.Usuario
where d.BajaLogica == false &&
d.IdUsuario == idUsuario
select d).FirstOrDefault();
usuario.Bloqueado = true;
context.SaveChanges();
}
}
public static void CreateHistoricoPassword(int IdUsuario, string pass)
{
using (OrdenesContext context = new OrdenesContext())
{
HistoricoPasswordEntity hpe = new HistoricoPasswordEntity();
hpe.Pass = pass;
hpe.Fecha = DateTime.Now;
hpe.IdUsuario = IdUsuario;
context.Add(hpe);
context.SaveChanges();
}
}
public int GetIdPersonaAdministradaById(int idPersona)
{
int IdPersona = 0;
using (OrdenesContext dbContext = new OrdenesContext())
{
IdPersona =
(from d in dbContext.UsuariosAdminitradorParties
where d.IdAdministrador == idPersona
select d).FirstOrDefault().IdParty;
}
return(IdPersona);
}
private static int?IncreaseIntentos(UsuarioEntity user)
{
UsuarioEntity usuario = null;
using (OrdenesContext context = new OrdenesContext())
{
usuario = (from d in context.Usuario
where d.BajaLogica == false &&
d.IdUsuario == user.IdUsuario
select d).FirstOrDefault();
usuario.CantidadIntentos += 1;
context.SaveChanges();
}
return(usuario.CantidadIntentos);
}
public LimitesPorPersonaEntity GetUsuariosLimiteByIdUsuario(int idPersona, string compradorOVendedor)
{
LimitesPorPersonaEntity limite;
using (OrdenesContext context = new OrdenesContext())
{
limite = (from d in context.UsuariosLimites
where d.IdPersona == idPersona && d.TipoOperacion == compradorOVendedor
select d
).FirstOrDefault();
}
return(limite);
}
public UsuariosLimitesDiariosEntity GetUsuariosLimiteDiariosByIdUsuario(int idUsuario)
{
UsuariosLimitesDiariosEntity limiteDiario;
using (OrdenesContext context = new OrdenesContext())
{
limiteDiario = (from d in context.UsuariosLimitesDiarios
where d.IdUsuario == idUsuario &&
d.Fecha.Date == DateTime.Now.Date
select d
).FirstOrDefault();
}
return(limiteDiario);
}
public bool GetConfirmacionManual(int idProducto, int idPersona, byte source)
{
string keyCache = KEY_AUTOCONFIRMA + "#" + idProducto.ToString() + "#" + idPersona.ToString() + "#" + source.ToString();
List <ConfirmacionManualEntity> ConfirmacionManual = CacheLayer.Get <List <ConfirmacionManualEntity> >(keyCache);
if (ConfirmacionManual == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
ConfirmacionManual = (from p in mc.ConfirmacionManual where p.IdProducto == idProducto && p.IdParty == idPersona && p.IdSourceApplication == source select p).ToList();
}
if (ConfirmacionManual != null)
{
CacheLayer.Add <List <ConfirmacionManualEntity> >(ConfirmacionManual, keyCache);
}
}
return(ConfirmacionManual.Count > 0);
}
public EstadoSistemaEntity GetFechaSistema()
{
//string keyCache = KEY_INGRESO_OP_FECHA_SISTEMA;
EstadoSistemaEntity estadoSistema;// = CacheLayer.Get<EstadoSistemaEntity>(keyCache);
//if (estadoSistema == null)
//{
using (OrdenesContext dbContext = new OrdenesContext())
{
int idEstadoSistema = dbContext.EstadoSistema.Where(p1 => p1.IdEstadoSistema != 0).Max(r => r.IdEstadoSistema);
estadoSistema = dbContext.EstadoSistema.Where(p => p.IdEstadoSistema == idEstadoSistema).FirstOrDefault();
//if (estadoSistema != null)
//{
// CacheLayer.Add<EstadoSistemaEntity>(estadoSistema, keyCache);
//}
}
//}
return(estadoSistema);
}
public object Execute(Query query)
{
object result = null;
try
{
using (var ctx = new OrdenesContext())
{
var requestId = query.Filters[0].Value;
result = this.GetById(ctx, requestId);
}
}
catch
{
//TODO: Loguear
throw new FunctionalException((int)CommandStatus.EF_ERROR_GENERIC);
}
return(result);
}
public PartyEntity GetPersonaById(int idPersona)
{
string keyCache = KEY_PERSONA_BY_ID + idPersona;
PartyEntity persona = CacheLayer.Get <PartyEntity>(keyCache);
if (persona == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
persona =
(from d in dbContext.Persona where d.IdParty == idPersona select d).FirstOrDefault();
}
if (persona != null)
{
CacheLayer.Add(persona, keyCache);
}
}
return(persona);
}
public List <TipoOrdenEntity> GetAllTipoOrden()
{
string keyCache = KEY_ALL_TIPOSORDEN;
List <TipoOrdenEntity> TiposOrdenes = CacheLayer.Get <List <TipoOrdenEntity> >(keyCache);
if (TiposOrdenes == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
TiposOrdenes = (from d in dbContext.TiposOrden select d).ToList <TipoOrdenEntity>();
}
if (TiposOrdenes != null)
{
CacheLayer.Add <List <TipoOrdenEntity> >(TiposOrdenes, keyCache);
}
}
return(TiposOrdenes);
}
public PartyEntity GetPersonaByNroCliente(string nroCliente)
{
string keyCache = KEY_PERSONA_BY_NROCLIENTE + nroCliente;
PartyEntity persona = CacheLayer.Get <PartyEntity>(keyCache);
if (persona == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
persona =
(from d in dbContext.Persona where d.MarketCustomerNumber.Equals(nroCliente) select d).FirstOrDefault();
}
if (persona != null)
{
CacheLayer.Add <PartyEntity>(persona, keyCache);
}
}
return(persona);
}
public List <MonedaEntity> GetAllMonedas()
{
string keyCache = KEY_ALL_MONEDAS;
List <MonedaEntity> monedas = CacheLayer.Get <List <MonedaEntity> >(keyCache);
if (monedas == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
monedas = (from d in dbContext.Moneda select d).ToList <MonedaEntity>();
}
if (monedas != null)
{
CacheLayer.Add <List <MonedaEntity> >(monedas, keyCache);
}
}
return(monedas);
}
public MercadoEntity GetMercadoById(byte idMercado)
{
string keyCache = KEY_MERCADO_BY_ID + "#" + idMercado.ToString();
MercadoEntity mercado = CacheLayer.Get <MercadoEntity>(keyCache);
if (mercado == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
mercado = (from p in mc.Mercado where p.IdMercado == idMercado select p).FirstOrDefault();
}
if (mercado != null)
{
CacheLayer.Add <MercadoEntity>(mercado, keyCache);
}
}
return(mercado);
}
public PartyEntity GetPersonaByCBU(string CBU)
{
string keyCache = KEY_PERSONA_BY_CBU + CBU;
PartyEntity persona = CacheLayer.Get <PartyEntity>(keyCache);
if (persona == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
persona =
(from d in dbContext.Persona where d.CBU.Equals(CBU) select d).FirstOrDefault();
}
if (persona != null)
{
CacheLayer.Add <PartyEntity>(persona, keyCache);
}
}
return(persona);
}
public DTOPortfolio GetPortfolioDefaultByIdUsuario(int idUsuario)
{
string keyCache = KEY_PORTFOLIO_DEFAULT_USUARIO + "#" + idUsuario;
DTOPortfolio dtoPortfolio = CacheLayer.Get <DTOPortfolio>(keyCache);
if (dtoPortfolio == null)
{
using (OrdenesContext mc = new OrdenesContext())
{
dtoPortfolio = (from p in mc.Portfolios
join pu in mc.PortfoliosUsuario on p.IdPortfolio equals pu.IdPortfolio
where pu.IdUsuario == idUsuario &&
pu.PorDefecto
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).FirstOrDefault();
if (dtoPortfolio == null)
{
dtoPortfolio = (from p in mc.Portfolios
join pu in mc.PortfoliosUsuario on p.IdPortfolio equals pu.IdPortfolio
where pu.IdUsuario == idUsuario
select new DTOPortfolio()
{
IdPortfolio = p.IdPortfolio,
Nombre = p.Nombre,
Codigo = p.Codigo,
EsDeSistema = p.EsDeSistema
}).FirstOrDefault();
}
}
if (dtoPortfolio != null)
{
CacheLayer.Add(dtoPortfolio, keyCache);
}
}
return(dtoPortfolio);
}
public List <UsuarioEntity> GetAllUsuarios()
{
string keyCache = KEY_GETALLUSUARIOS;
List <UsuarioEntity> usuarios = CacheLayer.Get <List <UsuarioEntity> >(keyCache);
if (usuarios == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
usuarios =
(from d in dbContext.Usuario select d).ToList();
}
if (usuarios != null)
{
CacheLayer.Add <List <UsuarioEntity> >(usuarios, keyCache);
}
}
return(usuarios);
}
public List <RolUsuarioEntity> GetRolesUsuario(int idusuario)
{
string keyCache = KEY_ROLES_USUARIOS + idusuario;
List <RolUsuarioEntity> Roles = CacheLayer.Get <List <RolUsuarioEntity> >(keyCache);
if (Roles == null)
{
using (OrdenesContext dbContext = new OrdenesContext())
{
Roles =
(from d in dbContext.RolUsuario where d.IdUsuario == idusuario select d).ToList();
}
if (Roles != null)
{
CacheLayer.Add <List <RolUsuarioEntity> >(Roles, keyCache);
}
}
return(Roles);
}
