public static Response<Infante> Post(this Infante request, Factory factory,IHttpRequest httpRequest)
{
request.CheckId(Operaciones.Create);
factory.Execute(proxy=>{
if(request.IdTerceroFactura.HasValue && request.IdTerceroFactura.Value!=default(int))
{
var tercero= proxy.FirstOrDefault<Tercero>(q=>q.Id==request.IdTerceroFactura.Value);
tercero.AssertExists(request.IdTerceroFactura.Value);
request.NombreTercero=tercero.Nombre;
request.DocumentoTercero=tercero.Documento;
request.DVTercero=tercero.DigitoVerificacion;
request.TelefonoTercero= tercero.Telefono;
request.MailTercero= tercero.Mail;
}
proxy.Create<Infante>(request);
});
List<Infante> data = new List<Infante>();
data.Add(request);
return new Response<Infante>(){
Data=data
};
}
public static Response<Matricula> Post(this Matricula request, Factory factory,IHttpRequest httpRequest)
{
request.CheckId(Operaciones.Create);
if( request.IdIngreso.HasValue && request.IdIngreso.Value==default(int)) request.IdIngreso=null;
if( request.IdClase.HasValue && request.IdClase.Value==default(int)) request.IdClase=null;
var mr = new MatriculaResponse ();
var queryString= httpRequest.QueryString;
factory.Execute(proxy=>{
proxy.Create<Matricula>(request);
var data = proxy.Get<Matricula>(q=> q.Id== request.Id);
bool crearItems;
if (bool.TryParse( queryString["CrearItems"], out crearItems) && crearItems){
var tarifas = proxy.Get<Tarifa>(q=>q.IdSucursal== request.IdSucursal &&
q.IdCentro==request.IdCentro &&
q.Activo==true &&
q.IncluirEnMatricula==true);
foreach(Tarifa tarifa in tarifas){
var mi = new MatriculaItem(){
IdMatricula=request.Id,
IdTarifa= tarifa.Id,
Valor= tarifa.Valor,
Descripcion= tarifa.Descripcion
};
proxy.Create<MatriculaItem>(mi);
mr.MatriculaItemList.Add(mi);
}
mr.TarifaList= tarifas;
}
mr.Data=data;
});
return mr;
}
public static Response<ComprobanteEgresoRetencion> Delete(this ComprobanteEgresoRetencion request,
Factory factory,
IAuthSession authSession)
{
request.CheckId(Operaciones.Destroy);
factory.Execute(proxy=>{
using (proxy.AcquireLock(request.IdComprobanteEgreso.GetLockKey<ComprobanteEgreso>(), Definiciones.LockSeconds))
{
ComprobanteEgresoRetencion oldData =
proxy.FirstOrDefaultById<ComprobanteEgresoRetencion>(request.Id);
oldData.AssertExists(request.Id);
ComprobanteEgresoItem cei= proxy.FirstOrDefaultById<ComprobanteEgresoItem>(oldData.IdComprobanteEgresoItem);
cei.AssertExists(request.IdComprobanteEgresoItem);
ComprobanteEgreso ce = DAL.GetComprobanteEgreso(proxy, oldData.IdComprobanteEgreso);
ce.AssertExists(oldData.IdComprobanteEgreso);
ce.CheckPeriodo(proxy);
Egreso egreso= DAL.GetEgresoById(proxy,cei.IdEgreso);
egreso.AssertExists(cei.IdEgreso);
request.ValidateAndThrowHttpError(oldData,ce,
cei,
egreso,
null,
Operaciones.BorrarRetencionEnCE);
ce.Valor+=oldData.Valor;
proxy.BeginDbTransaction();
ce.ActualizarValor(proxy);
proxy.Delete<ComprobanteEgresoRetencion>(q=>q.Id==request.Id);
proxy.CommitDbTransaction();
}
});
List<ComprobanteEgresoRetencion> data = new List<ComprobanteEgresoRetencion>();
data.Add(request);
return new Response<ComprobanteEgresoRetencion>(){
Data=data
};
}
public static Response<ComprobanteIngresoItem> Put(this ComprobanteIngresoItem request,
Factory factory,
IAuthSession authSession)
{
request.CheckId(Operaciones.Update);
factory.Execute(proxy=>{
using (proxy.AcquireLock(request.IdComprobanteIngreso.GetLockKey<ComprobanteIngreso>(), Definiciones.LockSeconds))
{
ComprobanteIngresoItem oldData = proxy.FirstOrDefaultById<ComprobanteIngresoItem>(request.Id);
oldData.AssertExists(request.Id);
var ce = proxy.FirstOrDefaultById<ComprobanteIngreso>(oldData.IdComprobanteIngreso);
ce.AssertExists(oldData.IdComprobanteIngreso);
ce.CheckPeriodo(proxy);
Ingreso ingreso= proxy.FirstOrDefaultById<Ingreso>(oldData.IdIngreso);
ingreso.AssertExists(oldData.IdIngreso);
request.ValidateAndThrowHttpError(oldData, ce,ingreso,Operaciones.ActualizarIngresoEnCI);
request.CheckOldAndNew(oldData,proxy);
if( request.Abono!=oldData.Abono)
{
ce.Valor+=request.Abono-oldData.Abono;
proxy.BeginDbTransaction();
ce.ActualizarValor(proxy);
request.ActualizarValor(proxy);
proxy.CommitDbTransaction();
}
}
});
List<ComprobanteIngresoItem> data = new List<ComprobanteIngresoItem>();
data.Add(request);
return new Response<ComprobanteIngresoItem>(){
Data=data
};
}
public static Response<Asiento> Delete(this Asiento request,
Factory factory,
IRequestContext requestContext,
bool checkSucursal=true,
bool checkPeriodo=false,
Action<IDbCommand,Asiento> runBeforeDeleteDbCommandsFn=null,
Action<IDbCommand,Asiento> runAfterDeleteDbCommandsFn=null)
{
request.CheckId(Operaciones.Destroy);
var httpRequest = requestContext.Get<IHttpRequest>();
string lockKey=request.GetLockKey();
Action block=()=>{
factory.Delete(request,(dbCmd)=>
{
httpRequest.CacheClientExec(cache=>
{
var id = request.Id;
var cacheKey=request.GetCacheKey();
request= cache.Get<Asiento>(cacheKey);
if(request== default(Asiento))
{
request= dbCmd.FirstOrDefault<Asiento>(q=> q.Id==id);
AssertExists(request, id);
}
else
{
cache.Remove(cacheKey);
}
request.ValidateAndThrowHttpError(Operaciones.Destroy);
if(checkSucursal) request.CheckSucursal(factory, httpRequest);
if(checkPeriodo) request.CheckPeriodo(factory,httpRequest);
if(runBeforeDeleteDbCommandsFn!=null) runBeforeDeleteDbCommandsFn(dbCmd, request);
});
},(dbCmd)=>
{
if(runAfterDeleteDbCommandsFn!=null) runAfterDeleteDbCommandsFn(dbCmd,request);
});
};
IRedisClientsManager cm = httpRequest.GetCacheClient() as IRedisClientsManager;
try
{
if( cm != null)
{
cm.Exec(redisClient=>
{
using (redisClient.AcquireLock(lockKey, TimeSpan.FromSeconds(Definiciones.LockSeconds)))
{
block();
}
});
}
else
block();
return new Response<Asiento>(){};
}
catch(Exception e)
{
throw new HttpError(e.Message);
}
}
public static Response<Asiento> Put(this Asiento request,
Factory factory,
IRequestContext requestContext,
bool checkSucursal=true,
bool checkPeriodo=false,
Action<IDbCommand,Asiento> runBeforePutDbCommandsFn=null,
Action<IDbCommand,Asiento> runAfterPutDbCommandsFn=null)
{
request.CheckId(Operaciones.Update);
string lockKey=request.GetLockKey();
var httpRequest = requestContext.Get<IHttpRequest>();
Action block=()=>{
SqlExpressionVisitor<Asiento> ev = OrmLiteConfig.DialectProvider.ExpressionVisitor<Asiento>();
ev.Update( f=> new { f.Descripcion, f.Fecha , f.Periodo, f.IdSucursal, f.CodigoDocumento, f.Documento })
.Where(f=>f.Id==request.Id);
var cacheKey=request.GetCacheKey();
factory.Put(request, ev,
(dbCmd)=>
{
httpRequest.CacheClientExec(cache=>
{
var data=cache.Get<Asiento>(cacheKey);
if(data== default(Asiento))
{
data= dbCmd.FirstOrDefault<Asiento>(q=> q.Id==request.Id);
AssertExists(data, request.Id);
}
if(!request.CodigoDocumento.IsNullOrEmpty() )
data.CodigoDocumento=request.CodigoDocumento;
if(!request.Documento.IsNullOrEmpty())
data.Documento=request.Documento;
data.ValidateAndThrowHttpError(Operaciones.Update,httpRequest, factory);
if(request.IdSucursal!=default(int))
{
data.IdSucursal= request.IdSucursal;
}
if(request.Fecha!=default(DateTime))
{
data.Fecha= request.Fecha;
data.Periodo= data.Fecha.ObtenerPeriodo();
}
if(checkSucursal) data.CheckSucursal(factory, httpRequest);
if(checkPeriodo) data.CheckPeriodo(factory,httpRequest);
if(!request.Descripcion.IsNullOrEmpty()) data.Descripcion=request.Descripcion;
request.PopulateWith(data);
if(runBeforePutDbCommandsFn!=null) runBeforePutDbCommandsFn(dbCmd,request);
});
},
(dbCmd)=>
{
if(runAfterPutDbCommandsFn!=null) runAfterPutDbCommandsFn(dbCmd, request);
httpRequest.CacheClientExec(cache=> cache.Set(cacheKey, request,
TimeSpan.FromDays(Definiciones.DiasEnCache)));
});
};
IRedisClientsManager cm = httpRequest.GetCacheClient() as IRedisClientsManager;
try
{
if( cm != null)
{
cm.Exec(redisClient=>
{
using (redisClient.AcquireLock(lockKey, TimeSpan.FromSeconds(Definiciones.LockSeconds)))
{
block();
}
});
}
else
block();
List<Asiento> data = new List<Asiento>();
data.Add(request);
return new Response<Asiento>(){Data=data};
}
catch(Exception e)
{
throw new HttpError(e.Message);
}
}
public static Response<IngresoItem> Put(this IngresoItem request,
Factory factory,
IAuthSession authSession)
{
request.CheckId(Operaciones.Update);
factory.Execute(proxy=>{
using (proxy.AcquireLock(request.IdIngreso.GetLockKey<Ingreso>(), Definiciones.LockSeconds))
{
IngresoItem oldData = proxy.FirstOrDefaultById<IngresoItem>(request.Id);
oldData.AssertExists(request.Id);
Ingreso ingreso= proxy.FirstOrDefaultById<Ingreso>( oldData.IdIngreso);
ingreso.AssertExists(request.IdIngreso);
CheckOldAndNew(ingreso,request,oldData, proxy, int.Parse(authSession.UserAuthId));
PresupuestoItem pi= Check1(proxy, request, int.Parse(authSession.UserAuthId));
CodigoDocumento cd = proxy.GetCodigoDocumento(ingreso.CodigoDocumento);
cd.AssertExists(ingreso.CodigoDocumento);
cd.AssertEstaActivo();
if(request.TipoPartida!=oldData.TipoPartida || request.Valor!=oldData.Valor)
{
if(oldData.TipoPartida==1)
{
ingreso.Saldo=ingreso.Saldo+oldData.Valor;
}
else
{
ingreso.Valor= ingreso.Valor-oldData.Valor;
ingreso.Saldo= ingreso.Saldo-oldData.Valor;
}
if(request.TipoPartida==1)
{
cd.CheckDebitos(pi.Codigo);
ingreso.Saldo=ingreso.Saldo-request.Valor;
}
else
{
cd.CheckCreditos(pi.Codigo);
ingreso.Valor= ingreso.Valor+request.Valor;
ingreso.Saldo=ingreso.Saldo+request.Valor;
}
proxy.BeginDbTransaction();
ingreso.ActualizarValorSaldo(proxy);
proxy.Update(request);
proxy.CommitDbTransaction();
}
else
proxy.Update(request);
}
});
List<IngresoItem> data = new List<IngresoItem>();
data.Add(request);
return new Response<IngresoItem>(){
Data=data
};
}
public static Response<IngresoItem> Delete(this IngresoItem request,
Factory factory,
IAuthSession authSession)
{
request.CheckId(Operaciones.Destroy);
factory.Execute(proxy=>{
using (proxy.AcquireLock(request.IdIngreso.GetLockKey<Ingreso>(), Definiciones.LockSeconds))
{
IngresoItem oldData = proxy.FirstOrDefaultById<IngresoItem>(request.Id);
oldData.AssertExists(request.Id);
Ingreso egreso= proxy.FirstOrDefaultById<Ingreso>(oldData.IdIngreso);
egreso.AssertExists(request.IdIngreso);
CheckOldAndNew(egreso,request,oldData, proxy, int.Parse(authSession.UserAuthId));
if(oldData.TipoPartida==1)
{
egreso.Saldo=egreso.Saldo+oldData.Valor;
}
else
{
egreso.Valor= egreso.Valor-oldData.Valor;
egreso.Saldo= egreso.Saldo-oldData.Valor;
}
proxy.BeginDbTransaction();
egreso.ActualizarValorSaldo(proxy);
proxy.Delete<IngresoItem>(q=>q.Id==request.Id);
proxy.CommitDbTransaction();
}
});
List<IngresoItem> data = new List<IngresoItem>();
data.Add(request);
return new Response<IngresoItem>(){
Data=data
};
}
public static Response<Infante> Put(this Infante request,Factory factory,IHttpRequest httpRequest)
{
factory.Execute(proxy=>{
request.CheckId(Operaciones.Update);
var oldData= proxy.FirstOrDefault<Infante>(q=>q.Id==request.Id);
oldData.AssertExists(request.Id);
if(request.IdTerceroFactura.HasValue )
{
if(request.IdTerceroFactura.Value==default(int) )
{
request.IdTerceroFactura=null;
request.NombreTercero=string.Empty;
request.DocumentoTercero=string.Empty;
request.DVTercero=string.Empty;
request.TelefonoTercero=string.Empty;
request.MailTercero=string.Empty;
}
else
{
if(!oldData.IdTerceroFactura.HasValue ||
(oldData.IdTerceroFactura.HasValue &&
oldData.IdTerceroFactura.Value!=request.IdTerceroFactura.Value))
{
var tercero= proxy.FirstOrDefault<Tercero>(q=>q.Id==request.IdTerceroFactura.Value);
tercero.AssertExists(request.IdTerceroFactura.Value);
request.NombreTercero=tercero.Nombre;
request.DocumentoTercero=tercero.Documento;
request.DVTercero=tercero.DigitoVerificacion;
request.TelefonoTercero= tercero.Telefono;
request.MailTercero= tercero.Mail;
}
}
}
proxy.Update<Infante>(request);
});
List<Infante> data = new List<Infante>();
data.Add(request);
return new Response<Infante>(){
Data=data
};
}
public static Response<Infante> Delete(this Infante request, Factory factory,IHttpRequest httpRequest)
{
request.CheckId(Operaciones.Destroy);
factory.Execute(proxy=>
{
var oldData= proxy.FirstOrDefault<Infante>(q=>q.Id==request.Id);
oldData.AssertExists(request.Id);
proxy.Delete<Infante>(q=>q.Id==request.Id);
});
List<Infante> data = new List<Infante>();
data.Add(request);
return new Response<Infante>(){
Data=data
};
}
