public static ComprobanteIngreso CreateComprobanteIngreso(DALProxy proxy,
                                            int idSucursal, int idCuentaReceptora, int idTercero, 
		                                    decimal valor,
                                            string descripcion,
                                            DateTime? fechaAsentado=null,
                                            bool? externo=false)
        {
			var today= DateTime.Today;
			var periodo= today.Year.ToString() + today.Month.ToString().PadLeft(2,'0');

            ComprobanteIngreso ce = new ComprobanteIngreso(){
                IdSucursal=idSucursal,
                IdCuentaReceptora= idCuentaReceptora,
                Fecha=today,
				Periodo= periodo,
                IdTercero=idTercero,
                Valor=valor,
                Descripcion=descripcion,
                FechaAsentado= fechaAsentado.HasValue?fechaAsentado.Value:fechaAsentado, //UTC ?                Externo= externo.HasValue?externo.Value:false
				Externo= externo.HasValue?externo.Value:false
            };   
            ce.Numero=proxy.GetNextConsecutivo(idSucursal, Definiciones.ComprobranteIngreso).Numero;
            proxy.Create(ce);
            return ce;
        }
        static void ValidateAndThrowHttpError(this ComprobanteIngresoItem request,
                                                       ComprobanteIngresoItem oldData,
                                                       ComprobanteIngreso comprobante,
                                                       Ingreso ingreso,string ruleSet)
        {
            IngresoCI ece= new IngresoCI(){
                Ingreso=ingreso,
                Ce= comprobante,
                Cei= request,
                OldCei= oldData,
            };
            IngresoCIValidator av = new IngresoCIValidator();

            av.ValidateAndThrowHttpError(ece,ruleSet );
        }
 static void ValidateAndThrowHttpError(this ComprobanteIngresoItem request,
                                                ComprobanteIngreso comprobante,
                                                Ingreso ingreso,string ruleSet)
 {
     request.ValidateAndThrowHttpError(new ComprobanteIngresoItem(), comprobante,
                                       ingreso, ruleSet);
 }
        static void CheckBeforePatch(ComprobanteIngreso oldData, ComprobanteIngreso request,
                                             DALProxy proxy,
                                             int idUsuario,
                                             string operacion)
        {
            oldData.ValidateAndThrowHttpError(operacion);
            CIs ces= new CIs(){Nuevo=request, Viejo=oldData};
            CIsValidator ev = new CIsValidator();
            ev.ValidateAndThrowHttpError(ces,operacion);

            oldData.CheckSucursal(proxy,idUsuario);
            oldData.CheckPeriodo(proxy);

            request.PopulateWith(oldData);

        }
        private static void CheckOldAndNew(ComprobanteIngreso oldData, ComprobanteIngreso request,
                                           DALProxy proxy,
                                           int idUsuario)
        {
            oldData.ValidateAndThrowHttpError(Operaciones.Update);

            var cis= new CIs(){Nuevo=request, Viejo=oldData};
            CIsValidator ev = new CIsValidator();
            ev.ValidateAndThrowHttpError(cis,Operaciones.Update);

            oldData.CheckSucursal(proxy, idUsuario);

            var data = new ComprobanteIngreso();
            data.PopulateWith(oldData);

            if( request.Fecha!=default(DateTime) && request.Fecha!=data.Fecha)
            {
                data.Fecha=request.Fecha;
                data.Periodo= data.Fecha.ObtenerPeriodo();
            }

            data.CheckPeriodo(proxy);

            //if(request.IdTercero!=default(int) && request.IdTercero!=data.IdTercero)
            //{
            //    data.IdTercero=request.IdTercero;
            //    data.CheckTercero(proxy);
            //}

            

            if(!request.Descripcion.IsNullOrEmpty() && request.Descripcion!=data.Descripcion)
                data.Descripcion=request.Descripcion;

            bool checkcg=false;

            if(request.IdCuentaReceptora!=default(int) && request.IdCuentaReceptora!=data.IdCuentaReceptora)
            {
                data.IdCuentaReceptora= request.IdCuentaReceptora;
                checkcg=true;
            }


            if((request.IdTerceroReceptora.HasValue && request.IdTerceroReceptora.Value!=default(int)) &&
               ( !data.IdTerceroReceptora.HasValue || 
                    (data.IdTerceroReceptora.HasValue && request.IdTerceroReceptora.Value!=data.IdTerceroReceptora.Value)))
            {
                data.IdTerceroReceptora= request.IdTerceroReceptora;
                checkcg=true;
            }

            if(checkcg){
				var pi = data.CheckUsuarioReceptora(proxy, idUsuario);
				data.CodigoItem= pi.Codigo;
				data.NombreItem = pi.Nombre;
			}

            request.PopulateWith(data);
        }
        public static void ValidateAndThrowHttpError(this ComprobanteIngresoRetencion request, 
                                                     ComprobanteIngresoRetencion oldData,
                                                     ComprobanteIngreso ce,
                                                     ComprobanteIngresoItem cei,
                                                     Ingreso egreso,
                                                     PresupuestoItem pi,
                                                     string ruleSet)
        {
            IngresoCIRet ret = new IngresoCIRet(){
                Ingreso= egreso,
                Cei=cei,
                Ce=ce,
                OldRet= oldData,
                Ret= request,
                Pi=pi
            };

            IngresoCIRetValidator av = new IngresoCIRetValidator();
            av.ValidateAndThrowHttpError(ret, ruleSet);
        }
 public static void ValidateAndThrowHttpError(this ComprobanteIngresoRetencion request, 
                                              ComprobanteIngreso ce,
                                              ComprobanteIngresoItem cei,
                                              Ingreso egreso,
                                              PresupuestoItem pi,
                                              string ruleSet)
 {
     request.ValidateAndThrowHttpError(new ComprobanteIngresoRetencion(),
                                       ce, cei, egreso, pi, ruleSet);
 }