C# Factory.Execute方法代码示例

		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<PedidoItem> Get(this PedidoItem request,Factory factory,
                                           IAuthSession authSession)
        {
            try{
            var data = factory.Execute(proxy=>{
                var visitor = ReadExtensions.CreateExpression<PedidoItem>();
                visitor.Where(r=>r.IdPedido==request.IdPedido);
                return proxy.Get(visitor);
            });
                        
            return new Response<PedidoItem>(){
                Data=data

            };
            }
            catch(Exception e){
                ResponseStatus rs = new ResponseStatus(){
                    Message= e.Message,
                    StackTrace=e.StackTrace,
                    ErrorCode= e.ToString()
                };
                return new Response<PedidoItem>(){
                    ResponseStatus=rs
                };
            }
        }

        public static Response<Pedido> Get(this Pedido request,
		                                   Factory factory,
		                                   IHttpRequest httpRequest)
        {

            var paginador= new Paginador(httpRequest);
            var queryString= httpRequest.QueryString;
			long? totalCount=null;

			ResponseStatus rs=null;
            
            var data = factory.Execute(proxy=>{

				try
				{
					int id;
	                if(int.TryParse(queryString["Id"], out id)){
						if(id!=default(int)) return proxy.Get<Pedido>(r=>r.Id==id);
					}

					var predicate = PredicateBuilder.True<Pedido>();

					string compania= queryString["NombreCompania"];
	            	if(!compania.IsNullOrEmpty()) 
					{
						predicate= predicate.AndAlso(r=>r.NombreCompania.Contains(compania));
	                }

					var visitor = ReadExtensions.CreateExpression<Pedido>();
					visitor.Where(predicate);
					if(paginador.PageNumber.HasValue)
	                {
						visitor.Select(r=> Sql.Count(r.Id));
						totalCount= proxy.Count(visitor); //proxy.Count(predicate);
	                    int rows= paginador.PageSize.HasValue? paginador.PageSize.Value:BL.PageSize;
						visitor.Select();
	                    visitor.Limit(paginador.PageNumber.Value*rows, rows);
	                }
	               
					visitor.OrderByDescending(r=>r.Id); 
	                return proxy.Get(visitor);
				}
				catch(Exception e)
				{
					rs= new ResponseStatus(){ErrorCode="GetClienteError",Message=e.Message, StackTrace=e.StackTrace};
					return new List<Pedido>();
				}
            });
            
            return new Response<Pedido>(){
                Data=data,
                TotalCount=totalCount,
				ResponseStatus=rs==null? new ResponseStatus():rs
            };
        }

 private static int Main(string[] args)
 {
     try {
     var app = new Factory(new DefaultModuleConfiguration()).Build<IApp>();
     app.Execute(args);
     return 0;
       } catch (Exception e) {
     System.Console.WriteLine(e);
     return 1;
       }
 }

        public static Response<Pedido> Get(this Pedido request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {

            return factory.Execute(proxy=>{

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);
            	
				var visitor = ReadExtensions.CreateExpression<Pedido>();

                var predicate = PredicateBuilder.True<Pedido>();

				if(request.Consecutivo!=default(int))
				{
					predicate= q=>q.Consecutivo==request.Consecutivo;
				}
				else
				{
					visitor.OrderByDescending(f=>f.Consecutivo);

					if(!request.NombreCliente.IsNullOrEmpty()){
						predicate= q=>q.NombreCliente.StartsWith(request.NombreCliente);
						visitor.OrderBy(f=>f.NombreCliente);
					}

					if(!request.NitCliente.IsNullOrEmpty()){
						predicate= predicate.AndAlso(q=>q.NitCliente.StartsWith(request.NitCliente));
						visitor.OrderBy(f=>f.NitCliente);
					}
				}

                
				visitor.Where(predicate);
                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<Pedido>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};

            });
  
        }

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

				long? totalCount=null;

				var paginador= new Paginador(httpRequest);
            	var queryString= httpRequest.QueryString;

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

				if(request.IdCliente!=default(int))
					predicate= q=>q.IdCliente==request.IdCliente;

				else if(!request.Nombre.IsNullOrEmpty()) 
				{
	                predicate= q=>q.Nombre.StartsWith(request.Nombre) ;
					visitor.OrderBy(r=>r.Nombre);
				}


				var qs= queryString["Activo"];
				bool activo;
				if(bool.TryParse(qs,out activo)){
					predicate= predicate.AndAlso(q=>q.Activo==activo);
				}

                
				visitor.Where(predicate);
                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<Contacto>(){
                	Data=proxy.Get(visitor),
                	TotalCount=totalCount
            	};
            });
  
        }

        public static AuthorizationResponse Get(this Authorization request, 
                                                   Factory factory, IRequestContext requestContext){
            
            var httpRequest = requestContext.Get<IHttpRequest>();   
            IAuthSession session = httpRequest.GetSession();
                        
            if (!session.HasRole(RoleNames.Admin))
            {
                request.UserId= int.Parse(session.UserAuthId);
            }
            
            List<AuthRole> roles = new List<AuthRole>();
            List<string> permissions= new List<string>();
            
            List<AuthRoleUser> aur= new List<AuthRoleUser>();
            List<AuthRole> rol = new List<AuthRole>();
            List<AuthPermission> per = new List<AuthPermission>();
            List<AuthRolePermission> rol_per = new List<AuthRolePermission>();
           
            factory.Execute(proxy=>
            {
                aur= proxy.Get<AuthRoleUser>(r=>r.IdUsuario==request.UserId );
                rol= proxy.Get<AuthRole>(); //DAL.GetFromCache<AuthRole>(proxy);
                per= proxy.Get<AuthPermission>(); //DAL.GetFromCache<AuthPermission >(proxy);
                rol_per= proxy.Get<AuthRolePermission>(); //DAL.GetFromCache<AuthRolePermission >(proxy);

            });
                        
            foreach( var r in aur)
            {
                AuthRole ar= rol.First(x=>x.Id== r.IdAuthRole);
                roles.Add(ar);
                rol_per.Where(q=>q.IdAuthRole==ar.Id).ToList().ForEach(y=>{
                    AuthPermission up=  per.First( p=> p.Id== y.IdAuthPermission);
                    if( permissions.IndexOf(up.Name) <0)
                        permissions.Add(up.Name);
                }) ;
            };
                               
            return new AuthorizationResponse(){
                Permissions= permissions,
                Roles= roles

            };
        }

		public static Response<Infante> Get(this Infante request, Factory factory, IHttpRequest httpRequest)
        {
			long? totalCount=null;

			var paginador= new Paginador(httpRequest);
            var queryString= httpRequest.QueryString;

            var predicate=PredicateBuilder.True<Infante>();

			var documento = queryString["Documento"];
			if(! documento.IsNullOrEmpty())
			{
				predicate= predicate.AndAlso(q=>q.Documento.StartsWith(documento));
			}

			var nombres= queryString["Nombres"];
			if(!nombres.IsNullOrEmpty())
				predicate= predicate.AndAlso(q=>q.Nombres.Contains(nombres));

			var apellidos= queryString["Apellidos"];
			if(!apellidos.IsNullOrEmpty())
				predicate= predicate.AndAlso(q=>q.Apellidos.Contains(apellidos));

			var visitor = ReadExtensions.CreateExpression<Infante>();
			visitor.Where(predicate);

			return factory.Execute(proxy=>{
				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.PageSize;
	                visitor.Limit(paginador.PageNumber.Value*rows, rows);
	            }
	                                
				visitor.OrderByDescending(r=> new { r.Nombres, r.Apellidos});

				return new Response<Infante>{
					Data=proxy.Get(visitor),
					TotalCount= totalCount
				};
			});
            
		}

		public static Response<Curso> Get(this Curso request, Factory factory, IHttpRequest httpRequest)
		{
			long? totalCount=null;

			var paginador= new Paginador(httpRequest);
            var queryString= httpRequest.QueryString;

            var predicate=PredicateBuilder.True<Curso>();

			var qv = queryString["Fecha"];
			if(! qv.IsNullOrEmpty())
			{
				DateTime fecha;
				if (DateTime.TryParse(qv, out fecha) )
				{
					var inicio= fecha.AddDays(-40);
					var fin = fecha.AddDays(40);
					predicate= predicate.AndAlso(q=>q.FechaInicio>=inicio &&
					                             q.FechaInicio<=fin);
				}
			}


			var visitor = ReadExtensions.CreateExpression<Curso>();
			visitor.Where(predicate);

			return factory.Execute(proxy=>{
				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.PageSize;
	                visitor.Limit(paginador.PageNumber.Value*rows, rows);
	            }
	                                
				visitor.OrderByDescending(r=> r.FechaInicio );

				return new Response<Curso>{
					Data=proxy.Get(visitor),
					TotalCount= totalCount
				};
			});
       
		}

		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<Contacto> Post(this Contacto request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			if(request.IdCliente==default(int))
				throw HttpError.Unauthorized("Debe Indicar el IdCliente");

			if(request.Nombre.IsNullOrEmpty() || request.Nombre.Trim()=="")
			throw HttpError.Unauthorized("Debe Indicar el Nombre del Contacto");

			factory.Execute(proxy=>{
				proxy.Create(request);
			});

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

		public static Response<Clase> Get(this Clase request, Factory factory, IHttpRequest httpRequest)
		{
			long? totalCount=null;

			var paginador= new Paginador(httpRequest);
            var queryString= httpRequest.QueryString;

            var predicate=PredicateBuilder.True<Clase>();

			var qv = queryString["Activo"];
			if(! qv.IsNullOrEmpty())
			{
				bool activo;
				if (bool.TryParse(qv, out activo) )
					predicate= predicate.AndAlso(q=>q.Activo==activo);
			}


			var visitor = ReadExtensions.CreateExpression<Clase>();
			visitor.Where(predicate);

			return factory.Execute(proxy=>{
				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.PageSize;
	                visitor.Limit(paginador.PageNumber.Value*rows, rows);
	            }
	                                
				visitor.OrderByDescending(r=> r.Nombre );

				return new Response<Clase>{
					Data=proxy.Get(visitor),
					TotalCount= totalCount
				};
			});
       
		}

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

				var session = httpRequest.GetSession();

				request.IdCreadoPor= int.Parse(session.UserAuthId);
				request.Id=0;
				request.FechaAceptacion=null;
				request.FechaEnvio=null;
				request.FechaAnulado=null;
				request.FechaCreacion=DateTime.Today;
				request.FechaActualizacion=request.FechaCreacion;
				request.IdAceptadoPor=null;
				request.IdAnuladoPor=null;
				request.IdEnviadoPor=null;

				var fp = proxy.CheckExistAndActivo<FormaPago>(request.IdFormaPago, f=>f.Descripcion);
				request.DescripcionFormaPago= fp.Descripcion;

				var contacto = proxy.CheckExistAndActivo<Contacto>(request.IdContacto, f=>f.Nombre);
				request.NombreContacto= contacto.Nombre;

				var ciudad = CheckCiudad(proxy, request);
				request.NombreCiudad= ciudad.Nombre;
				request.CodigoCiudad= ciudad.Codigo;

				var cliente= proxy.CheckExistAndActivo<Cliente>(contacto.IdCliente, f=>f.Nombre);
				request.NitCliente=cliente.Nit;
				request.NombreCliente= cliente.Nombre;

				using (proxy.AcquireLock(Consecutivo.GetLockKey(BL.Cotizacion), BL.LockSeconds))
                {
					proxy.BeginDbTransaction();
					request.Consecutivo= proxy.GetNext(BL.Cotizacion).Valor;
					proxy.Create(request);
					proxy.CommitDbTransaction();
				}

			});

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

        public static Response<Pedido> Patch(this Pedido request,
		                                              Factory factory,
		                                              IHttpRequest httpRequest)
        {
			List<string> actions = new List<string>(new string[]{"ENVIAR","ACEPTAR","ANULAR"});

			var action= httpRequest.PathInfo.Substring(httpRequest.PathInfo.LastIndexOf("/")+1).ToUpper();

			if(actions.IndexOf(action)<0)
				throw HttpError.Unauthorized(string.Format("Operacion: '{0}' no autorizada en Ofertas", action));

			var session = httpRequest.GetSession();

			factory.Execute(proxy=>{

				using (proxy.AcquireLock(request.GetLockKey(), BL.LockSeconds))
                {

					var old = proxy.FirstOrDefaultById<Pedido>(request.Id);

					var userSesssion= httpRequest.GetSession();

					if(!(old.IdCreadoPor== int.Parse(userSesssion.UserAuthId)
					   || userSesssion.HasRole(BL.RoleCoordinador)))

						throw HttpError.Unauthorized(string.Format("Usuario '{0}' No puede  ejecutar '{1}' en las ofertas creadas por:'{2}' ",
						                                           userSesssion.UserName,action, old.NombreCreadoPor));


					if( old==default(Pedido)){
						throw HttpError.NotFound(string.Format("No existe Oferta con Id: '{0}'", request.Id));
					}

					if(old.FechaAnulado.HasValue){
						throw HttpError.Unauthorized(string.Format("Operacion:'{0}' No permitida. Oferta '{1}' Id:'{2} se encuentra anulada",action, request.Consecutivo, request.Id));
					}




					request.PopulateWith(old);

					if(action=="ENVIAR")
					{
						if(old.FechaEnvio.HasValue)
							throw HttpError.Conflict("Oferta ya se encuentra en estado Enviada");
						request.FechaEnvio=DateTime.Today;
						request.IdEnviadoPor= int.Parse(session.UserAuthId);
					}
					else if (action=="ACEPTAR")
					{
						if(old.FechaAceptacion.HasValue)
							throw HttpError.Conflict("Oferta ya se encuentra en estado Aceptada");

						if(!old.FechaEnvio.HasValue)
							throw HttpError.Conflict("La Oferta primero debe ser enviada");

						request.FechaAceptacion=DateTime.Today;
						request.IdAceptadoPor= int.Parse(session.UserAuthId);
					}
					else
					{
						request.FechaAnulado= DateTime.Today;
						request.IdAnuladoPor= int.Parse(session.UserAuthId);
					}

					proxy.Update(request, ev=>ev.Update(
						f=> new {
						f.FechaEnvio,f.FechaAceptacion,f.FechaAnulado, f.VigenteHasta,
						f.IdAceptadoPor, f.IdAnuladoPor, f.IdEnviadoPor
					}).Where(q=>q.Id==request.Id));
				}

			});

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

        public static Response<Egreso> Put(this Egreso request,
                                              Factory factory,
                                              IAuthSession authSession)                                
        {

            // TODO :  si cambio cambiar el Tercero y si el  Nro. Dto viene vacio traer Numero del nuevo Tercero...

            request.ValidateAndThrowHttpError(Definiciones.CheckRequestBeforeUpdate);
            var idUsuario = int.Parse(authSession.UserAuthId);

            factory.Execute(proxy=>{
                using(proxy.AcquireLock(request.GetLockKey(), Definiciones.LockSeconds))
                {
                    Egreso oldData= DAL.GetEgresoById(proxy, request.Id);
                    oldData.AssertExists(request.Id);
                    CheckOldAndNew(oldData, request, proxy, idUsuario );
                    request.Update(proxy);

                    //Action<DALProxy> action=(p)=>request.Update(p);
                    //Action<DALProxy> action= request.Update;
                    //proxy.ExecuteUpdate(action,request,oldData); // me permite ejecutar con  o sin triggers
                }
            });

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