C# PortalProContext.CreateDetachedCopy方法代碼示例

 public virtual IEnumerable<CabFactura> GetPorEstado(string estado, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             IEnumerable<CabFactura> facturas = (from f in ctx.CabFacturas
                                                 where f.Estado == estado
                                                 orderby f.FechaEmision descending
                                                 select f).ToList<CabFactura>();
             // fetch estrategy, necesaria para poder devolver el grupo junto con cada usuariuo
             FetchStrategy fs = new FetchStrategy();
             fs.LoadWith<CabFactura>(x => x.Proveedor);
             fs.LoadWith<CabFactura>(x => x.DocumentoPdf);
             fs.LoadWith<CabFactura>(x => x.DocumentoXml);
             fs.LoadWith<CabFactura>(x => x.Empresa);
             fs.LoadWith<CabFactura>(x => x.Responsable);
             facturas = ctx.CreateDetachedCopy<IEnumerable<CabFactura>>(facturas, fs);
             return facturas;
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (CabFactura)"));
         }
     }
 }

 /// <summary>
 /// Devuelve la línea de factura que coincide con el id proporcionado
 /// </summary>
 /// <param name="id">Identificador único de la línea</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual LinFactura Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             LinFactura linea = (from l in ctx.LinFacturas
                                 where l.LinFacturaId == id
                                 select l).FirstOrDefault<LinFactura>();
             if (linea != null)
             {
                 linea = ctx.CreateDetachedCopy<LinFactura>(linea, x => x.CabFactura);
                 return linea;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un linea con el id proporcionado (LinFactura)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (LinFactura)"));
         }
     }
 }

 /// <summary>
 /// Obtiene una Parametro cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único de la Parametro</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual Parametro Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Parametro Parametro = (from pl in ctx.Parametros1
                                              where pl.ParametroId == id
                                              select pl).FirstOrDefault<Parametro>();
             if (Parametro != null)
             {
                 Parametro = ctx.CreateDetachedCopy<Parametro>(Parametro);
                 return Parametro;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un Parametro con el id proporcionado (Parametros)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Parametros)"));
         }
     }
 }

 /// <summary>
 /// Obtiene log de solicitud que corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único del log</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual SolicitudLog Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             SolicitudLog solog = (from u in ctx.SolicitudLogs
                                   where u.SolicitudLogId == id
                                   select u).FirstOrDefault<SolicitudLog>();
             if (solog != null)
             {
                 solog = ctx.CreateDetachedCopy<SolicitudLog>(solog, x => x.Usuario, x => x.SolicitudProveedor, x => x.SolicitudStatusInicial, x => x.SolicitudStatusFinal);
                 return solog;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un log de solcitud con el id proporcionado (SolicitudLogs)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (SolicitudLogs)"));
         }
     }
 }

 /// <summary>
 /// Devuelve las líneas que corresponden a una factura determinada
 /// </summary>
 /// <param name="idFac">Identificador de la factura a la que pertencen las líneas</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual IEnumerable<LinFactura> GetLineas(int idFac, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             // comprobamos si existe la fcatura de referencia.
             CabFactura factura = (from f in ctx.CabFacturas
                                   where f.CabFacturaId == idFac
                                   select f).FirstOrDefault<CabFactura>();
             if (factura != null)
             {
                 IEnumerable<LinFactura> lineas = factura.LinFacturas;
                 FetchStrategy fs = new FetchStrategy();
                 fs.LoadWith<LinFactura>(x => x.CabFactura);
                 lineas = ctx.CreateDetachedCopy<IEnumerable<LinFactura>>(lineas, fs);
                 return lineas;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un factura con el id proporcionado (LinFactura)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (LinFactura)"));
         }
     }
 }

 /// <summary>
 /// Obtiene un Empresas cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único de la empresa</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual Empresa Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Empresa empresa = (from gu in ctx.Empresas
                                          where gu.EmpresaId == id
                                          select gu).FirstOrDefault<Empresa>();
             if (empresa != null)
             {
                 empresa = ctx.CreateDetachedCopy<Empresa>(empresa);
                 return empresa;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un grupo con el id proporcionado (Empresas)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Empresas)"));
         }
     }
 }

 /// <summary>
 /// Obtiene un Responsables cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único de la Responsable</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual Responsable Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Responsable responsable = (from gu in ctx.Responsables
                                          where gu.ResponsableId == id
                                          select gu).FirstOrDefault<Responsable>();
             if (responsable != null)
             {
                 responsable = ctx.CreateDetachedCopy<Responsable>(responsable, x => x.Usuario);
                 return responsable;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un grupo con el id proporcionado (Responsables)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Responsables)"));
         }
     }
 }

 /// <summary>
 /// Obtiene el usuario cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único del grupo</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual Usuario Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Usuario usuario = (from u in ctx.Usuarios
                                where u.UsuarioId == id
                                select u).FirstOrDefault<Usuario>();
             if (usuario != null)
             {
                 usuario = ctx.CreateDetachedCopy<Usuario>(usuario, x => x.GrupoUsuario);
                 return usuario;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un usuario con el id proporcionado (Usuarios)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Usuarios)"));
         }
     }
 }

        /// <summary>
        /// Obtiene todos las solicitudes de la base de datos
        /// </summary>
        /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
        /// <returns></returns>
        public virtual IEnumerable<SolicitudProveedor> Get(string tk)
        {
            using (PortalProContext ctx = new PortalProContext())
            {
                if (CntWebApiSeguridad.CheckTicket(tk, ctx))
                {
                    IEnumerable<SolicitudProveedor> solProveedores = (from pr in ctx.SolicitudProveedors
                                                                      select pr).ToList<SolicitudProveedor>();

                    // fetch estrategy, necesaria para poder devolver el grupo junto con cada usuariuo
                    FetchStrategy fs = new FetchStrategy();
                    fs.LoadWith<SolicitudProveedor>(x => x.GrupoProveedor);
                    fs.LoadWith<SolicitudProveedor>(x => x.SolicitudStatus);
                    fs.LoadWith<SolicitudProveedor>(x => x.ActividadPrincipal1);
                    fs.LoadWith<SolicitudProveedor>(x => x.Pais1);
                    fs.LoadWith<SolicitudProveedor>(x => x.Comunidad1);
                    fs.LoadWith<SolicitudProveedor>(x => x.Provincia1);
                    solProveedores = ctx.CreateDetachedCopy<IEnumerable<SolicitudProveedor>>(solProveedores, fs);
                    return solProveedores;
                }
                else
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Solicitudes proveedores)"));
                }
            }
        }

 public virtual IEnumerable<Pedido> Get(string proveedorId, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             // Comprobamos que hay un proveedor que coincide
             int pId = int.Parse(proveedorId);
             IEnumerable<Pedido> pedidos = (from f in ctx.Pedidos
                                            where f.Proveedor.ProveedorId == pId
                                            orderby f.FechaAlta descending
                                            select f).ToList<Pedido>();
             // fetch estrategy, necesaria para poder devolver el grupo junto con cada usuariuo
             FetchStrategy fs = new FetchStrategy();
             fs.LoadWith<Pedido>(x => x.Proveedor);
             fs.LoadWith<Pedido>(x => x.DocumentoPdf);
             fs.LoadWith<Pedido>(x => x.DocumentoXml);
             fs.LoadWith<Pedido>(x => x.Empresa);
             fs.LoadWith<Pedido>(x => x.Responsable);
             pedidos = ctx.CreateDetachedCopy<IEnumerable<Pedido>>(pedidos, fs);
             return pedidos;
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Pedido)"));
         }
     }
 }

        /// <summary>
        /// Devuelve la lista de los tipos de documentos asociados al grupo de usuarios cuyo id correspone a la cadena pasada
        /// </summary>
        /// <param name="tk">Tique obtienido en el login se puede forzar con el valor "solicitud"</param>
        /// <param name="grupoCode">Identificador de grupo de proveedor pasado como cadena</param>
        /// <returns></returns>
        public virtual IList<TipoDocumento> Get(string tk, string grupoCode)
        {

            using (PortalProContext ctx = new PortalProContext())
            {
                if (CntWebApiSeguridad.CheckTicket(tk, ctx) || tk=="solicitud")
                {
                    int id = 0;
                    bool res = int.TryParse(grupoCode, out id);
                    GrupoProveedor grupoProveedor = (from gp in ctx.GrupoProveedors
                                                     where gp.GrupoProveedorId == id
                                                     select gp).FirstOrDefault<GrupoProveedor>();
                    if (grupoProveedor == null)
                    {
                        throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Debe proporcionar un grupo de proveedores existente"));
                    }
                    IList<TipoDocumento> tiposDocumentos = new List<TipoDocumento>();
                    // cargamos las asociaciones
                    var rs = (from tdgp in ctx.TipoDocumentoGrupoProveedors
                              where tdgp.GrupoProveedor.GrupoProveedorId == grupoProveedor.GrupoProveedorId
                              select tdgp);
                    foreach (TipoDocumentoGrupoProveedor t in rs)
                    {
                        tiposDocumentos.Add(t.TipoDocumento);
                    }
                    tiposDocumentos = ctx.CreateDetachedCopy<IList<TipoDocumento>>(tiposDocumentos);
                    return tiposDocumentos;
                }
                else
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Tipos de documentos)"));
                }
            }
        }

 /// <summary>
 /// Obtiene el proveedor cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único del proveedor</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login")</param>
 /// <returns></returns>
 public virtual Proveedor Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Proveedor proveedor = (from p in ctx.Proveedors
                                where p.ProveedorId == id
                                select p).FirstOrDefault<Proveedor>();
             if (proveedor != null)
             {
                 proveedor = ctx.CreateDetachedCopy<Proveedor>(proveedor, x => x.GrupoProveedor);
                 return proveedor;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un proveedor con el id proporcionado (Proveedores)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Proveedores)"));
         }
     }
 }

 /// <summary>
 /// Obtiene un grupo de proveedores cuyo ID corresponde con el pasado
 /// </summary>
 /// <param name="id">Identificador único del grupo</param>
 /// <param name="tk">Código del tique de autorización (Véase "Login"), admite "solicitud"</param>
 /// <returns></returns>
 public virtual GrupoProveedor Get(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx) || tk == "solicitud")
         {
             GrupoProveedor grupoProveedor = (from gp in ctx.GrupoProveedors
                                              where gp.GrupoProveedorId == id
                                              select gp).FirstOrDefault<GrupoProveedor>();
             if (grupoProveedor != null)
             {
                 grupoProveedor = ctx.CreateDetachedCopy<GrupoProveedor>(grupoProveedor);
                 return grupoProveedor;
             }
             else
             {
                 throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un grupo con el id proporcionado (Grupo de proveedores)"));
             }
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Grupo de proveedores)"));
         }
     }
 }

 public virtual Progresos Get(string proceso, string tk)
 {
     Progresos pgs = null;
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx) || tk == "solicitud")
         {
             int procesoId = 0;
             switch (proceso)
             {
                 case "Empresa":
                     procesoId = 1;
                     break;
                 case "Proveedor":
                     procesoId = 2;
                     break;
                 case "Pedido":
                     procesoId = 3;
                     break;
                 case "Factura":
                     procesoId = 4;
                     break;
                 case "Responsable":
                     procesoId = 5;
                     break;
                 case "ActividadPrincipal":
                     procesoId = 6;
                     break;
                 case "Pais":
                     procesoId = 7;
                     break;
                 case "Comunidad":
                     procesoId = 8;
                     break;
                 case "Provincia":
                     procesoId = 9;
                     break;
             }
             pgs = (from p in ctx.Progresos
                    where p.ProgresoId == procesoId
                    select p).FirstOrDefault<Progresos>();
             pgs = ctx.CreateDetachedCopy<Progresos>(pgs);
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Importar)"));
         }
     }
     return pgs;
 }

 /// <summary>
 /// Obtiene una plantilla cuyo ID corresponde con el pasado
 /// en este caso no necesita tique porque es para solicitudes.
 /// </summary>
 /// <param name="id">Identificador único de la plantilla</param>
 /// <returns></returns>
 public virtual Plantilla Get(int id)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         Plantilla plantilla = (from pl in ctx.Plantillas
                                          where pl.PlantillaId == id
                                          select pl).FirstOrDefault<Plantilla>();
         if (plantilla != null)
         {
             plantilla = ctx.CreateDetachedCopy<Plantilla>(plantilla);
             return plantilla;
         }
         else
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un plantilla con el id proporcionado (Plantillas)"));
         }
     }
 }