C# Factory.Execute方法代码示例

        public static Response<RolePermission> Get(this RolePermission request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);

				var visitor = ReadExtensions.CreateExpression<RolePermission>();
				var predicate = PredicateBuilder.True<RolePermission>();

				predicate= q=>q.AuthRoleId==request.AuthRoleId;
												                
				visitor.Where(predicate).OrderBy(f=>f.Name) ;
                if(paginador.PageNumber.HasValue)
                {
					visitor.Select(r=> Sql.Count(r.Id));
					totalCount= proxy.Count(visitor);
					visitor.Select();
                    int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.ResponsePageSize;
                    visitor.Limit(paginador.PageNumber.Value*rows, rows);
                }
                                
                
				return new Response<RolePermission>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};
            });
  
        }

        public static InfanteInfoResponse Get(this InfanteInfo request, Factory factory, IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{

				var padres = proxy.Get<InfantePadre>(q=>q.IdInfante==request.Id);
				var acudientes =proxy.Get<InfanteAcudiente>(q=>q.IdInfante==request.Id);
				var matriculas = proxy.Get<Matricula>(
					ev=>ev.Where(q=>q.IdInfante==request.Id).OrderByDescending(q=>q.FechaInicio));

				var predicate= PredicateBuilder.False<Pension>();

				foreach( Matricula m in matriculas)
				{
					var idMatricula= m.Id;
					predicate= predicate.OrElse(q=>q.IdMatricula==idMatricula);
				}

				var pensiones = proxy.Get<Pension>(ev=> ev.Where(predicate).OrderByDescending(q=>q.Periodo));

                return new InfanteInfoResponse{
					InfantePadreList= padres,
					InfanteAcudienteList=acudientes,
					MatriculaList=matriculas,
					PensionList= pensiones
                };
            });
        }

        public static Response<Servicio> Get(this Servicio request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);
            	
                var predicate = PredicateBuilder.True<Servicio>();

                var visitor = ReadExtensions.CreateExpression<Servicio>();

				if(!request.Nombre.IsNullOrEmpty()){
					predicate = predicate.AndAlso(q=> q.Nombre.Contains(request.Nombre));
				}

				visitor.Where(predicate).OrderBy(f=>f.Nombre);
                if(paginador.PageNumber.HasValue)
                {
					visitor.Select(r=> Sql.Count(r.Id));
					totalCount= proxy.Count(visitor);
					visitor.Select();
                    int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.ResponsePageSize;
                    visitor.Limit(paginador.PageNumber.Value*rows, rows);
                }
                
				return new Response<Servicio>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};
            });
  
        }

        public static Response<User> Get(this User request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{

				var userSession = httpRequest.GetSession();

				//if(!( userSession.HasRole(RoleNames.Admin) ||
				//   userSession.HasPermission("User.read") ))
				//	throw HttpError.Unauthorized("Usuario no autorizado para leer listado de usuarios");

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);

				var visitor = ReadExtensions.CreateExpression<User>();
				var predicate = PredicateBuilder.True<User>();

				if (userSession.HasRole(RoleNames.Admin))
				{
					if(request.Id!=default(int))
					predicate= q=>q.Id==request.Id;

					if(!request.UserName.IsNullOrEmpty()) 
	                	predicate= q=>q.UserName.StartsWith(request.UserName) ;

					if(userSession.UserName!=BL.AdminUser)
						predicate=predicate.AndAlso(q=>q.UserName!=BL.AdminUser);

				}
				else
				{
					var id = int.Parse(userSession.UserAuthId);
					predicate= q=>q.Id==id;
				}
				                
				visitor.Where(predicate).OrderBy(r=>r.UserName);;
                if(paginador.PageNumber.HasValue)
                {
					visitor.Select(r=> Sql.Count(r.Id));
					totalCount= proxy.Count(visitor);
					visitor.Select();
                    int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.ResponsePageSize;
                    visitor.Limit(paginador.PageNumber.Value*rows, rows);
                }
                                
                
				return new Response<User>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};
            });
  
        }

		public static Response<ComprobanteEgresoRetencion> Get(this ComprobanteEgresoRetencion request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			return factory.Execute(proxy=>
			{
				return new Response<ComprobanteEgresoRetencion>(){
                	Data=proxy.Get<ComprobanteEgresoRetencion>(q=> q.IdComprobanteEgreso ==request.IdComprobanteEgreso),   	
            	};
			});
		}

        public static Response<IngresoItem> Post(this IngresoItem request,
                                            Factory factory,
                                            IAuthSession authSession)
        {


            request.ValidateAndThrowHttpError(Operaciones.Create);

            factory.Execute(proxy=>{

                PresupuestoItem pi= Check1(proxy,request, int.Parse(authSession.UserAuthId));

                // bloquear el Ingreso parent para evitar actualizaciones....
                using(proxy.AcquireLock(request.IdIngreso.GetLockKey<Ingreso>(), Definiciones.LockSeconds))
                {
                    Ingreso ingreso=proxy.FirstOrDefaultById<Ingreso>(request.IdIngreso);
                    ingreso.AssertExists(request.IdIngreso);
                    ingreso.ValidateAndThrowHttpError(Operaciones.Update);
                    ingreso.CheckPeriodo(proxy);
                    request.CheckCentro(proxy, ingreso.IdSucursal,int.Parse(authSession.UserAuthId));

                    CodigoDocumento cd = proxy.GetCodigoDocumento(ingreso.CodigoDocumento);
                    cd.AssertExists(ingreso.CodigoDocumento); 
                    cd.AssertEstaActivo();

                    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.Create(request);
                    proxy.CommitDbTransaction();


                }
            });

            List<IngresoItem> data = new List<IngresoItem>();
            data.Add(request);
            
            return new Response<IngresoItem>(){
                Data=data
            };  
            
        }

        public static Response<Empresa> Get(this Empresa request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{
				                
				request = proxy.GetEmpresa();
				var response =new Response<Empresa>();
				response.Data.Add(request);
				return response;
            });
  
        }

        public static Response<ComprobanteIngresoItem> Post(this ComprobanteIngresoItem request,
                                            Factory factory,
                                            IAuthSession authSession)
        {
            request.ValidateAndThrowHttpError(Operaciones.Create);

            factory.Execute(proxy=>{

                // bloquear el ComprobanteIngreso parent para evitar actualizaciones....
                using(proxy.AcquireLock(request.IdComprobanteIngreso.GetLockKey<ComprobanteIngreso>(), Definiciones.LockSeconds))
                {

                    var ce = proxy.FirstOrDefaultById<ComprobanteIngreso>(request.IdComprobanteIngreso);
                    ce.AssertExists(request.IdComprobanteIngreso);
                    ce.CheckPeriodo(proxy);
                                         
                    var ingreso= proxy.FirstOrDefaultById<Ingreso>(request.IdIngreso);
                    ingreso.AssertExists(request.IdIngreso);

                    request.ValidateAndThrowHttpError(ce,ingreso,Operaciones.InsertarIngresoEnCI);

                    ce.Valor+=request.Abono;

                    proxy.BeginDbTransaction();
                    ce.ActualizarValor(proxy);
                    proxy.Create(request);
                    proxy.CommitDbTransaction();


					request.DiasCredito= ingreso.DiasCredito;
					request.Numero= ingreso.Numero;
					request.Descripcion=ingreso.Descripcion;
					request.Documento=ingreso.Descripcion;
					request.Fecha= ingreso.Fecha;
					request.IdTercero= ingreso.IdTercero;
					request.IdSucursal= ingreso.IdSucursal;
					request.Saldo=ingreso.Saldo;
					request.Valor= ingreso.Valor;
                }
            });

            var data = new List<ComprobanteIngresoItem>();
            data.Add(request);
            
            return new Response<ComprobanteIngresoItem>(){
                Data=data
            };  
            
        }

        public static Response<IngresoItem> Get(this IngresoItem request,
                                            Factory factory,
                                            IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{
            
				var visitor = ReadExtensions.CreateExpression<IngresoItem>();
                 
				visitor.Where(r=>r.IdIngreso==request.IdIngreso).OrderByDescending(r=>r.TipoPartida);

				return new Response<IngresoItem>(){
	                Data= proxy.Get(visitor)
	            };
            });
        }

        public static Response<Empresa> Delete(this Empresa request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			factory.Execute(proxy=>{
				proxy.DeleteEmpresa(request);
			});

			List<Empresa> data = new List<Empresa>();
			data.Add(request);
			
			return new Response<Empresa>(){
				Data=data
			};	
		}

        public static Response<Ciudad> Post(this Ciudad request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			factory.Execute(proxy=>{
				proxy.Create(request);
			});

			List<Ciudad> data = new List<Ciudad>();
			data.Add(request);
			
			return new Response<Ciudad>(){
				Data=data
			};	
		}

        public static Response<AuthPermission> Put(this AuthPermission request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			factory.Execute(proxy=>{
				proxy.DeleteFromCache<AuthPermission>();
				proxy.Update(request);
			});

			List<AuthPermission> data = new List<AuthPermission>();
			data.Add(request);
			
			return new Response<AuthPermission>(){
				Data=data
			};	
		}

        public static Response<AuthRole> Post(this AuthRole request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			factory.Execute(proxy=>{
				proxy.DeleteFromCache<AuthRole>();
				proxy.Create(request);
			});

			List<AuthRole> data = new List<AuthRole>();
			data.Add(request);
			
			return new Response<AuthRole>(){
				Data=data
			};	
		}

        public static Response<Consecutivo> Post(this Consecutivo request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			if(request.Prefijo.IsNullOrEmpty()) request.Prefijo=BL.Prefijo;
			if(request.Documento.IsNullOrEmpty()) request.Documento=BL.Cotizacion;
			factory.Execute(proxy=>{
				proxy.Create(request);
			});

			List<Consecutivo> data = new List<Consecutivo>();
			data.Add(request);
			
			return new Response<Consecutivo>(){
				Data=data
			};	
		}

        public static Response<UserRole> Get(this UserRole request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
            return factory.Execute(proxy=>{

				var userSession = httpRequest.GetSession();

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);

				var visitor = ReadExtensions.CreateExpression<UserRole>();
				var predicate = PredicateBuilder.True<UserRole>();


				if(request.UserId==default(int))
					request.UserId= int.Parse(userSession.UserAuthId);
				else if(!(userSession.HasRole(RoleNames.Admin)) &&
				        request.UserId != int.Parse(userSession.UserAuthId)
				        )
				{
					throw HttpError.Unauthorized("Usuario no puede leer listado de roles de otro usuario");
				}

				predicate= q=>q.UserId==request.UserId;
												                
				visitor.Where(predicate).OrderBy(f=>f.Name);

                if(paginador.PageNumber.HasValue)
                {
					visitor.Select(r=> Sql.Count(r.Id));
					totalCount= proxy.Count(visitor);
					visitor.Select();
                    int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.ResponsePageSize;
                    visitor.Limit(paginador.PageNumber.Value*rows, rows);
                }
                                
                
				return new Response<UserRole>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};
            });
  
        }