C# PortalProContext.Delete方法代码示例

 /// <summary>
 /// Elimina el log que coincide con el id pasado. La solicitud a la que pertenece
 /// pasa al estado de pendiente.
 /// </summary>
 /// <param name="id">Identificador del log a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (SolicitudLogs)"));
         }
         // primero buscamos si un grupo con ese id existe
         SolicitudLog slg = (from s in ctx.SolicitudLogs
                             where s.SolicitudLogId == id
                             select s).FirstOrDefault<SolicitudLog>();
         // existe?
         if (slg == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un log con el id proporcionado (SolicitudLogs)"));
         }
         // salvamos la solicitud que habrá que actualizar
         SolicitudProveedor sp = slg.SolicitudProveedor;
         if (sp != null)
         {
             // Estado 1 = Pendiente
             sp.SolicitudStatus = (from s in ctx.SolicitudStatus
                                   where s.SolicitudStatusId == 1
                                   select s).FirstOrDefault<SolicitudStatus>();
         }
         ctx.Delete(slg);
         
         ctx.SaveChanges();
         return true;
     }
 }

 /// <summary>
 /// Elimina el usuario que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador del usuario a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (UsuarioProveedor)"));
         }
         // primero buscamos si un grupo con ese id existe
         UsuarioProveedor usu = (from u in ctx.UsuarioProveedors
                        where u.UsuarioProveedorId == id
                        select u).FirstOrDefault<UsuarioProveedor>();
         // existe?
         if (usu == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un usuario con el id proporcionado (UsuarioProveedor)"));
         }
         ctx.Delete(usu);
         ctx.SaveChanges();
         return true;
     }
 }

 /// <summary>
 /// Elimina el proveedor que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador del proveedor a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
              throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Proveedores)"));
         }
         // primero buscamos si un grupo con ese id existe
         Proveedor pro = (from u in ctx.Proveedors
                        where u.ProveedorId == id
                        select u).FirstOrDefault<Proveedor>();
         // existe?
         if (pro == null)
         {
              throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un grupo con el id proporcionado (Proveedores)"));
         }
         // hay que eliminar los ficheros asociados.
         foreach (Documento d in pro.Documentos)
         {
             PortalProWebUtility.EliminarDocumento(d, ctx);
         }
         ctx.Delete(pro);
         ctx.SaveChanges();
         return true;
     }
 }

 /// <summary>
 /// Elimina el Parametro que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador de la Parametro a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Parametros)"));
         }
         // primero buscamos si un Parametro con ese id existe
         Parametro gu = (from g in ctx.Parametros1
                              where g.ParametroId == id
                              select g).FirstOrDefault<Parametro>();
         // existe?
         if (gu == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un Parametro con el id proporcionado (Parametros)"));
         }
         ctx.Delete(gu);
         ctx.SaveChanges();
         return true;
     }
 }

 /// <summary>
 /// Elimina la factura que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador de la factura a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (CabFactura)"));
         }
         // primero buscamos si una factura con ese id existe
         CabFactura cfac = (from f in ctx.CabFacturas
                            where f.CabFacturaId == id
                            select f).FirstOrDefault<CabFactura>();
         // existe?
         if (cfac == null)
         {
             // ya está eliminada
             return true;
         }
         if (cfac.Estado == "PROCESADA")
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Las facturas procesadas no se pueden borrar (CabFactura)"));
         }
         // primero borarremos todas las líneas (con lo que se actualizan los pedidos asociados)
         PortalProWebUtility.EliminarLineasFactura(cfac.LinFacturas, ctx);
         Documento df = cfac.DocumentoPdf;
         Documento dx = cfac.DocumentoXml;
         ctx.Delete(cfac);
         PortalProWebUtility.EliminarDocumento(df, ctx);
         PortalProWebUtility.EliminarDocumento(dx, ctx);
         ctx.SaveChanges();
         return true;
     }
 }

 public static void EliminarDocumento(Documento d, PortalProContext ctx)
 {
     if (d == null)
         return;
     // eliminamos el fichero físico asociado
     string portalProRepo = ConfigurationManager.AppSettings["PortalProRepository"];
     string fichero = String.Format("{0:000000}-{1}", d.DocumentoId, d.NomFichero);
     string ficheroCompleto = Path.Combine(portalProRepo, fichero);
     ctx.Delete(d);
     File.Delete(ficheroCompleto);
     ctx.SaveChanges();
 }

 public static void EliminarLineasFactura(IList<LinFactura> lineas, PortalProContext ctx)
 {
     foreach (LinFactura l in lineas)
     {
         // antes de eliminar la línea hay que actualizar el total facturado del pedido
         Pedido ped = (from p in ctx.Pedidos
                       where p.NumPedido == l.NumeroPedido
                       select p).FirstOrDefault<Pedido>();
         if (ped != null)
         {
             ped.TotalFacturado = ped.TotalFacturado - l.Importe;
             if (ped.TotalFacturado < 0)
                 ped.TotalFacturado = 0;
         }
         // lo mismo para las lineas
         LinPedido lped = (from lp in ctx.LinPedidos
                           where lp.NumPedido == l.NumeroPedido
                           && lp.NumLinea == l.NumLineaPedido
                           select lp).FirstOrDefault<LinPedido>();
         if (lped != null)
         {
             lped.Facturado = lped.Facturado - l.Importe;
             if (lped.Facturado < 0) lped.Facturado = 0;
         }
         l.CabFactura.TotalFactura = l.CabFactura.TotalFactura - l.Importe;
         ctx.Delete(l);
     }
     ctx.SaveChanges();
 }

 /// <summary>
 /// Elimina el documento que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador del documento a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Documentos)"));
         }
         // primero buscamos si un grupo con ese id existe
         Documento doc = (from u in ctx.Documentos
                          where u.DocumentoId == id
                          select u).FirstOrDefault<Documento>();
         // existe?
         if (doc == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un documento con el id proporcionado (Documentos)"));
         }
         // eliminamos el fichero del repositorio.
         string repo = ConfigurationManager.AppSettings["PortalProRepository"];
         if (repo != null && repo != "")
         {
             string fichero = Path.Combine(repo, "\\", doc.NomFichero);
             File.Delete(fichero);
             ctx.Delete(doc);
             ctx.SaveChanges();
         }
         return true;
     }
 }

 /// <summary>
 /// Se utiliza para cargar los tipos de documentos asociados a un grupo de proveedores
 /// </summary>
 /// <param name="tipos">Vector de enteros con los identificadores de los tipos de documento a asociar</param>
 /// <param name="tk">Tique de autorización (ver Login)</param>
 /// <param name="grupoCode">Identificador del grupo de proveedores</param>
 /// <returns></returns>
 public virtual bool Post(IList<int> tipos, string tk, string grupoCode)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             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"));
             }
             // eliminamos todos os asociados posibles, que serán sustituidos por los nuevos
             ctx.Delete(grupoProveedor.TipoDocumentoGrupoProveedors);
             // vamos a comprobar todos los id pasados
             foreach (int i in tipos)
             {
                 // ya está en la lista de este grupo
                 TipoDocumentoGrupoProveedor tdgp = new TipoDocumentoGrupoProveedor();
                 tdgp.GrupoProveedor = grupoProveedor;
                 TipoDocumento td = (from t in ctx.TipoDocumentos
                                     where t.TipoDocumentoId == i
                                     select t).FirstOrDefault<TipoDocumento>();
                 if (td != null)
                 {
                     tdgp.TipoDocumento = td;
                     ctx.Add(tdgp);
                 }
             }
             ctx.SaveChanges();
         }
     }
     return true;
 }

        public static void EliminarDocumento(Documento d, PortalProContext ctx)
        {
            if (d == null) return;
            if (d.DocumentoId == 0)
            {
                // el documento está vacío
                return;
            }
            // hay que considerar que si eliminamos el documento
            // puede dar error de clave referencial.

            EliminarFicheroDocumento(d);
            ctx.Delete(d);
            ctx.SaveChanges();
        }

 /// <summary>
 /// Elimina la linea que coincide con el id pasado
 /// </summary>
 /// <param name="id">Identificador de la linea a eliminar</param>
 /// <param name="tk">Tique de autorización (Ver 'Login')</param>
 /// <returns></returns>
 public virtual bool Delete(int id, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (LinPedido)"));
         }
         // primero buscamos si un grupo con ese id existe
         LinPedido lin = (from l in ctx.LinPedidos
                          where l.LinPedidoId == id
                          select l).FirstOrDefault<LinPedido>();
         // existe?
         if (lin == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay una linea con el id proporcionado (LinPedido)"));
         }
         ctx.Delete(lin);
         ctx.SaveChanges();
         return true;
     }
 }

 public virtual bool Put(int idPed, IEnumerable<LinPedido> lineas, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         // comprobar el tique
         if (!CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (LinPedido)"));
         }
         // comprobamos que las lineas no son nulas
         if (lineas == null)
         {
             throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
         }
         // comprobamos que la factura a la que se asociarán las líneas existe
         Pedido pedido = (from f in ctx.Pedidos
                           where f.PedidoId == idPed
                           select f).FirstOrDefault<Pedido>();
         if (pedido == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No existe una factura con el id proporcionado (LinPedido)"));
         }
         // eliminamos las líneas de fcatura anteriores para solo dar de alta estas
         ctx.Delete(pedido.LinPedidos);
         // ahora damos de alta las nuevas lineas 
         decimal totalPedido = 0;
         foreach (LinPedido linea in lineas)
         {
             LinPedido l = new LinPedido()
             {
                 Descripcion = linea.Descripcion,
                 Importe = linea.Importe,
                 PorcentajeIva = linea.PorcentajeIva,
                 Pedido = pedido
             };
             totalPedido += linea.Importe;
             ctx.Add(l);
         }
         pedido.TotalPedido = totalPedido;
         ctx.SaveChanges();
     }
     return true;
 }