C# PortalProContext.Add方法代码示例

 /// <summary>
 /// Comprueba que los ficheros necesarios para rellenar a la solicitud están.
 /// Asocia esos ficheros como documentos a la solicitud de que se trate.
 /// </summary>
 /// <param name="webRoot">Directorio de subida de ficheros</param>
 /// <param name="tk">Tique de autorización (caso especial "solicitud")</param>
 /// <param name="solProveedor">Solicitud de proveedor a procesar</param>
 /// <param name="ctx">Contexto para acceso a la base de datos (OpenAccess)</param>
 /// <returns></returns>
 public static string ComprobarCargarFicherosProveedor(string webRoot, string tk, SolicitudProveedor solProveedor, PortalProContext ctx)
 {
     string mens = ""; // mensaje que devoveremos, si vacío todo OK
     string[] listaFicheros; // lista de los ficheros contenidos en el directorio de carga
     // lo primero de todo que no ha habido un error en el directorio 
     if (!Directory.Exists(webRoot))
     {
         return "No existe el directorio de carga";
     }
     else
     {
         // cargamos la lista de ficheros del directorio de carga
         listaFicheros = Directory.GetFiles(webRoot);
     }
     // comprobamos si existe el parámetro que define donde esta el repositorio
     string repo = ConfigurationManager.AppSettings["PortalProRepositorio"];
     if (repo == null || repo == "")
     {
         return "No existe o está vació el parámetro de ubicación del repositorio en el Web.config";
     }
     // comprobamos que el directorio físicamente existe (si no lo creamos);
     if (!Directory.Exists(repo))
     {
         Directory.CreateDirectory(repo);
     }
     // por cada tipo de fichero asociado al grupo de proveedores al que pertenecerá este
     // comprbamos que existe el fichero correspondiente en el directorio de carga.
     foreach (TipoDocumentoGrupoProveedor tdgp in solProveedor.GrupoProveedor.TipoDocumentoGrupoProveedors)
     {
         TipoDocumento td = tdgp.TipoDocumento;
         string buscador = String.Format("{0}#{1}#", tk, td.TipoDocumentoId);
         string fichero = (from f in listaFicheros
                           where f.Contains(buscador)
                           select f).FirstOrDefault<string>();
         if (fichero == null)
         {
             return "Faltan ficheros asociados a este proveedor";
         }
         // creamos el documento correspondiente asignando un nuevo nombre que empieza por el NIF
         Documento d = new Documento();
         d.TipoDocumento = td;
         d.SolicitudProveedor = solProveedor;
         int posFich = fichero.LastIndexOf("#");
         int posExten = fichero.LastIndexOf(".");
         d.NomFichero = String.Format("{0}_{1}_{2}", solProveedor.Nif, td.TipoDocumentoId, fichero.Substring(posFich + 1));
         d.Extension = fichero.Substring(posExten + 1);
         // copiamos al repositorio
         File.Copy(fichero, Path.Combine(repo, d.NomFichero));
         ctx.Add(d);
     }
     // si llegamos aquí podemos borrar los ficheros del directorio de carga
     var rs = (from f in listaFicheros
               where f.Contains(String.Format("{0}#", tk))
               select f);
     foreach (string f in rs)
     {
         File.Delete(f);
     }
     return mens;
 }

 // este método se ejecutará de manera asíncrona.
 public string LaunchResponsable(out int threadId)
 {
     threadId = Thread.CurrentThread.ManagedThreadId;
     // abrir conexiones 
     PortalProContext ctx = new PortalProContext();
     string strConnect = ConfigurationManager.ConnectionStrings["PortalProTestConnection"].ConnectionString;
     SqlConnection con = new SqlConnection(strConnect);
     con.Open();
     string sql = "SELECT COUNT(*) FROM [PortalProTest].[dbo].[Cau_PortalPro_VResponsable]";
     SqlCommand cmd = new SqlCommand(sql, con);
     int totreg = (int)cmd.ExecuteScalar();
     int numreg = 0;
     sql = @"SELECT  
                 [ID]
                 ,[NAME]
                 ,[EMAIL]
             FROM [PortalProTest].[dbo].[Cau_PortalPro_VResponsable]";
     cmd = new SqlCommand(sql, con);
     SqlDataReader dr = cmd.ExecuteReader();
     while (dr.Read())
     {
         numreg++;
         string codax = dr.GetString(0);
         // Buscamos si esa empresa existe
         Responsable res2 = (from e2 in ctx.Responsables
                         where e2.CodAx == codax
                         select e2).FirstOrDefault<Responsable>();
         if (res2 == null)
         {
             res2 = new Responsable();
             ctx.Add(res2);
         }
         res2.CodAx = codax;
         res2.Nombre = dr.GetString(1);
         res2.Email = dr.GetString(2);
         ctx.SaveChanges();
         // Actualizar los registros de proceso
         Progresos progreso = (from p in ctx.Progresos
                               where p.ProgresoId == 5
                               select p).FirstOrDefault<Progresos>();
         if (progreso != null)
         {
             progreso.NumReg = numreg;
             progreso.TotReg = totreg;
             ctx.SaveChanges();
         }
     }
     dr.Close();
     ctx.Dispose();
     con.Close();
     con.Dispose();
     return "";
 }

 /// <summary>
 /// Tras comprobar que un usuario con el login y password dados 
 /// existe, crea un tique que devuelve en el cuerpo del mensaje
 /// </summary>
 /// <param name="login">Login del usuario</param>
 /// <param name="password">Contraseña del usuario</param>
 /// <returns>Un objeto que representa un tique</returns>
 /// <remarks>Este es un comentario adicional</remarks>
 public virtual WebApiTicket GetLogin(string login, string password)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         WebApiTicket tk = CntWebApiSeguridad.Login(login, password, 30, ctx);
         if (tk == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Nombre de usuario o contraseña incorrecto"));
         }
         else
         {
             // agregamos el tique recién creado
             ctx.Add(tk);
             ctx.SaveChanges();
             tk = ctx.CreateDetachedCopy<WebApiTicket>(tk, x => x.Usuario);
             return tk;
         }
     }
 }

 /// <summary>
 /// Genera una factura de una sola linea con el importe
 /// pasado y a partir del pedido indicado.
 /// </summary>
 /// <param name="pedido">Pedido para el que se genera la factura</param>
 /// <param name="importe">Importe a facturar</param>
 /// <param name="ctx">Contexto OpenAccess</param>
 /// <returns></returns>
 public static CabFactura PedidoSuscripcionGenerarFactura(Pedido pedido, decimal importe, PortalProContext ctx)
 {
     CabFactura factura = null;
     // evitamos que se cuele un importe a 0
     if (importe == 0) return factura;
     // el pedido debe tener lineas
     if (pedido.LinPedidos.Count < 1) return factura;
     // creamos la factura.
     factura = new CabFactura();
     factura.FechaAlta = DateTime.Now;
     factura.TotalFactura = importe;
     factura.Estado = "RECIBIDA";
     factura.Generada = true;
     factura.Proveedor = pedido.Proveedor;
     factura.Empresa = pedido.Empresa;
     factura.Responsable = pedido.Responsable;
     ctx.Add(factura);
     ctx.SaveChanges();
     // creamos una línea única con el importe
     LinFactura lfactura = new LinFactura();
     lfactura.CabFactura = factura;
     lfactura.NumeroPedido = pedido.NumPedido;
     lfactura.Importe = importe;
     // usamos la primera línea que obtengamos del pedido
     // como modelo
     LinPedido lpedido = pedido.LinPedidos[0];
     lfactura.Descripcion = lpedido.Descripcion;
     lfactura.PorcentajeIva = lpedido.PorcentajeIva;
     lfactura.NumeroPedido = lpedido.NumPedido;
     lfactura.NumLineaPedido = lpedido.NumLinea;
     lpedido.Facturado += importe;
     if (factura.FechaEmision != null)
         lfactura.FechaEmision = (DateTime)factura.FechaEmision;
     ctx.Add(lfactura);
     ctx.SaveChanges();
     return factura;
 }

 // este método se ejecutará de manera asíncrona.
 public string LaunchPedido(out int threadId)
 {
     threadId = Thread.CurrentThread.ManagedThreadId;
     // abrir conexiones 
     PortalProContext ctx = new PortalProContext();
     // Actualizar los registros de proceso
     Progresos progreso = (from p in ctx.Progresos
                           where p.ProgresoId == 3
                           select p).FirstOrDefault<Progresos>();
     if (progreso != null)
     {
         progreso.NumReg = 0;
         progreso.TotReg = 1;
         ctx.SaveChanges();
     }
     string strConnect = ConfigurationManager.ConnectionStrings["PortalProTestConnection"].ConnectionString;
     SqlConnection con = new SqlConnection(strConnect);
     con.Open();
     string sql = "SELECT COUNT(*) FROM [dbo].[Cau_PortalPro_VCabPedido]";
     SqlCommand cmd = new SqlCommand(sql, con);
     int totreg = (int)cmd.ExecuteScalar();
     int numreg = 0;
     sql = @"SELECT  
                 [PURCHID]
                 ,[INVOICEACCOUNT]
                 ,[DATAAREAID]
                 ,[ESTADO]
                 ,[TIPO]
                 ,[CODCONTACTO]
                 ,[CONTACTO]
                 ,[CREATEDDATE]
                 ,[FECHARECEPCION]
                 ,[FECHALIMITE]
             FROM [dbo].[Cau_PortalPro_VCabPedido]";
     cmd = new SqlCommand(sql, con);
     SqlDataReader dr = cmd.ExecuteReader();
     while (dr.Read())
     {
         numreg++;
         string numpedido = dr.GetString(0);
         // Buscamos si esa empresa existe
         Pedido ped2 = (from p2 in ctx.Pedidos
                         where p2.NumPedido == numpedido
                         select p2).FirstOrDefault<Pedido>();
         if (ped2 == null)
         {
             ped2 = new Pedido();
             ctx.Add(ped2);
         }
         ped2.NumPedido = numpedido;
         ped2.Proveedor = (from pr in ctx.Proveedors
                           where pr.CodAx == dr.GetString(1)
                           select pr).FirstOrDefault<Proveedor>();
         ped2.Empresa = (from e in ctx.Empresas
                             where e.CodAx == dr.GetString(2)
                             select e).FirstOrDefault<Empresa>();
         ped2.Actualizado = DateTime.Now;
         if (!dr.IsDBNull(3))
         {
             switch (dr.GetString(3))
             {
                 case "Facturado":
                     ped2.Estado = "FACTURADO";
                     break;
                 case "Pedido Abierto":
                     ped2.Estado = "ABIERTO";
                     break;
                 case "Recibido":
                     ped2.Estado = "RECIBIDO";
                     break;
                 case "Cancelado":
                     ped2.Estado = "CANCELADO";
                     break;
             }
         }
         if (!dr.IsDBNull(4))
         {
             switch (dr.GetString(4))
             {
                 case "Pedido de Compra":
                     ped2.TipoPedido = "COMPRA";
                     break;
                 case "Suscripción":
                     ped2.TipoPedido = "SUSCRIPCION";
                     break;
                 case "Solicitud de Compra":
                     ped2.TipoPedido = "SOLICITUD";
                     break;
             }
         }
         ped2.Responsable = (from r in ctx.Responsables
                             where r.CodAx == dr.GetString(5)
                             select r).FirstOrDefault<Responsable>();
         ped2.FechaAlta = dr.GetDateTime(7);
         if (!dr.IsDBNull(8)) ped2.FechaRecepcion = dr.GetDateTime(8);
         if (!dr.IsDBNull(9)) 
         { 
             ped2.FechaLimite = dr.GetDateTime(9);
             // hay que controlar le fecha nula AX (01/01/1900)
//.........这里部分代码省略.........

 // este método se ejecutará de manera asíncrona.
 public string LaunchFactura(out int threadId)
 {
     threadId = Thread.CurrentThread.ManagedThreadId;
     // abrir conexiones 
     PortalProContext ctx = new PortalProContext();
     string strConnect = ConfigurationManager.ConnectionStrings["PortalProTestConnection"].ConnectionString;
     SqlConnection con = new SqlConnection(strConnect);
     con.Open();
     string sql = "SELECT COUNT(*) FROM [PortalProTest].[dbo].[Cau_PortalPro_VCabFactura]";
     SqlCommand cmd = new SqlCommand(sql, con);
     int totreg = (int)cmd.ExecuteScalar();
     int numreg = 0;
     sql = @"SELECT  
                 [ACCOUNTNUM]
                 ,[IDEMPRESA]
                 ,[INVOICEID]
                 ,[INVOICEDATE]
                 ,[INVOICEAMOUNT]
                 ,[FECHAPAGO]
                 ,[ESTADI]
                 ,[FECHAVENCIMIENTO]
             FROM [PortalProTest].[dbo].[Cau_PortalPro_VCabFactura]";
     cmd = new SqlCommand(sql, con);
     SqlDataReader dr = cmd.ExecuteReader();
     while (dr.Read())
     {
         numreg++;
         string codAxProveedor = dr.GetString(0);
         string numFactura = dr.GetString(2);
         DateTime fechaFactura = dr.GetDateTime(3);
         Proveedor proveedor = (from pr in ctx.Proveedors
                                where pr.CodAx == codAxProveedor
                                select pr).FirstOrDefault<Proveedor>();
         // Buscamos si la fcatura ya existe
         CabFactura fac = (from f in ctx.CabFacturas
                           where f.NumFactura == numFactura &&
                                 f.FechaEmision == fechaFactura
                           select f).FirstOrDefault<CabFactura>();
         if (fac == null)
         {
             fac = new CabFactura();
             fac.FechaAlta = DateTime.Now;
             ctx.Add(fac);
         }
         fac.Proveedor = proveedor;
         fac.NumFactura = numFactura;
         fac.FechaEmision = fechaFactura;
         fac.Empresa = (from e in ctx.Empresas
                        where e.CodAx == dr.GetString(1)
                        select e).FirstOrDefault<Empresa>();
         string estado = dr.GetString(6);
         switch (estado)
         {
             case "Pagado":
                 fac.Estado = "PAGADA";
                 break;
             case "Recibido":
                 fac.Estado = "PROCESADA";
                 break;
         }
         fac.TotalFactura = dr.GetDecimal(4);
         if (!dr.IsDBNull(5))
             fac.FechaCobro = dr.GetDateTime(5);
         if (!dr.IsDBNull(7))
             fac.FechaPrevistaCobro = dr.GetDateTime(7);
         try
         {
             ctx.SaveChanges();
         }
         catch (Exception ex)
         {
         }
         // cargar las lineas
         try
         {
             LoadAssociateLines(numFactura, fechaFactura);
         }
         catch (Exception ex)
         {
         }
         // Actualizar los registros de proceso
         Progresos progreso = (from p in ctx.Progresos
                               where p.ProgresoId == 4
                               select p).FirstOrDefault<Progresos>();
         if (progreso != null)
         {
             progreso.NumReg = numreg;
             progreso.TotReg = totreg;
             ctx.SaveChanges();
         }
     }
     dr.Close();
     ctx.Dispose();
     con.Close();
     con.Dispose();
     return "";
 }

 public virtual bool Put(int idPro, IEnumerable<Documento> documentos, string userId, 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 (LinFactura)"));
         }
         // comprobamos que los documentos no son nulos
         if (documentos == null)
         {
             throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
         }
         // primero buscamos si un proveedor con ese id existe
         Proveedor pro = (from p in ctx.Proveedors
                          where p.ProveedorId == idPro
                          select p).FirstOrDefault<Proveedor>();
         if (pro == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay un proveedor con el id proporcionado (Proveedores)"));
         }
         // primero eliminamos los posibles documentos anteriores
         foreach (Documento d in pro.Documentos)
         {
             PortalProWebUtility.EliminarDocumento(d, ctx);
         }
         // La aplicación ahora depende del comienzo del usuario
         string application = "PortalPro";
         switch (userId.Substring(0, 1))
         {
             case "U":
                 application = "PortalPro2";
                 break;
             case "G":
                 application = "PortalPro";
                 break;
         }
         // Ahora cargamos las lineas nuevas
         foreach (Documento doc in documentos)
         {
             if (doc.TipoDocumento != null)
             {
                 TipoDocumento tp = (from t in ctx.TipoDocumentos
                                     where t.TipoDocumentoId == doc.TipoDocumento.TipoDocumentoId
                                     select t).FirstOrDefault<TipoDocumento>();
                 if (tp != null)
                 {
                     string fieldId = String.Format("PDFT{0}", doc.TipoDocumento.TipoDocumentoId);
                     string fpdf = PortalProWebUtility.BuscarArchivoCargado(application, userId, "Proveedor", fieldId);
                     if (fpdf != "")
                     {
                         Documento vDoc = PortalProWebUtility.CrearDocumentoDesdeArchivoCargado(application, fpdf, ctx);
                         vDoc.TipoDocumento = tp;
                         vDoc.Proveedor = pro;
                         ctx.Add(vDoc);
                         ctx.SaveChanges();
                     }
                 }
             }
         }
     }
     return true;
 }

 /// <summary>
 /// Crear un nuevo usuario de proveedor
 /// </summary>
 /// <param name="Usuario">Objeto a crear, el atributo UsuarioPorveedorId lo genera la aplicación y es devuelto en el objeto incluido en la respuesta.</param>
 /// <param name="tk"> Tique de autorización (se debe obtener con la accion Login)</param>
 /// <returns></returns>
 public virtual UsuarioProveedor Post(UsuarioProveedor usuarioProveedor, 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)"));
         }
         // comprobar las precondiciones
         if (usuarioProveedor == null)
         {
             throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
         }
         // controlar la contraseña.
         if (usuarioProveedor.Password != null && usuarioProveedor.Password != "")
         {
             // se guarda la contraseña encriptada
             usuarioProveedor.Password = CntWebApiSeguridad.GetHashCode(usuarioProveedor.Password);
         }
         int proveedorId = 0;
         // Controlamos las propiedades que son en realidad objetos.
         if (usuarioProveedor.Proveedor != null)
         {
             proveedorId = usuarioProveedor.Proveedor.ProveedorId;
             usuarioProveedor.Proveedor = null;
         }
         // dar de alta el objeto en la base de datos y devolverlo en el mensaje
         ctx.Add(usuarioProveedor);
         if (proveedorId != 0)
         {
             usuarioProveedor.Proveedor = (from p in ctx.Proveedors
                                     where p.ProveedorId == proveedorId
                                     select p).FirstOrDefault<Proveedor>();
         }
         ctx.SaveChanges();
         return ctx.CreateDetachedCopy<UsuarioProveedor>(usuarioProveedor, x => x.Proveedor);
     }
 }

 /// <summary>
 /// Cambia el estado de una solicitud y realiza la grabación 
 /// correspondiente en el log
 /// </summary>
 /// <param name="id">Identificador de la solicitud a procesar</param>
 /// <param name="tk">Tique de autorización (ver Login)</param>
 /// <param name="status">Código del estado al que se quiere pasar (2=Aceptada / 3=Rechazada)</param>
 /// <param name="userId">Identificador del usuario que avala el cambio</param>
 /// <param name="comentarios">Comentarios adicionales</param>
 /// <returns></returns>
 public virtual bool PutStatus(int id, string tk, int status, int userId, string comentarios)
 {
     bool res = false;
     using (PortalProContext ctx = new PortalProContext())
     {
         // Comprobamos la solicitud
         SolicitudProveedor solProveedor = (from sp in ctx.SolicitudProveedors
                                            where sp.SolicitudProveedorId == id
                                            select sp).FirstOrDefault<SolicitudProveedor>();
         if (solProveedor == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay una solicitud con el id proporcionado (Solicitudes proveedores)"));
         }
         if (solProveedor.SolicitudStatus == null || solProveedor.SolicitudStatus.SolicitudStatusId != 1)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "La solicitud ya ha sido procesada"));
         }
         // ya nos hemos asegurado que la soilictud existe ahora creamos el registro de procesamiento.
         SolicitudStatus st = (from s in ctx.SolicitudStatus
                               where s.SolicitudStatusId == status
                               select s).FirstOrDefault<SolicitudStatus>();
         if (st == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay una estatus con el id proporcionado (Solicitudes proveedores)"));
         }
         // obtención de los usuarios
         Usuario usu = (from u in ctx.Usuarios
                        where u.UsuarioId == userId
                        select u).FirstOrDefault<Usuario>();
         if (usu == null)
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "El usuario es incorrecto (Solicitudes proveedores)"));
         }
         // y ahora el regsitro de procesamiento
         SolicitudLog slg = new SolicitudLog();
         slg.Sello = DateTime.Now;
         slg.Comentarios = comentarios;
         slg.SolicitudProveedor = solProveedor;
         slg.Usuario = usu;
         slg.SolicitudStatusInicial = solProveedor.SolicitudStatus;
         slg.SolicitudStatusFinal = st;
         ctx.Add(slg);
         // cambiamos el estado de la solicitud
         solProveedor.SolicitudStatus = st;
         // y salvamos todo
         ctx.SaveChanges();
         // una vez hecho esto hay que informar por correo
         // preparamos y enviamos el correo de confirmación por defecto (por si falla la plantilla).
         string asunto = "[PortalPro] Recibida solicitud";
         string cuerpo = String.Format("Su solicitud con ID:{0} ha sido recibida. No responda este mensaje", solProveedor.SolicitudProveedorId);
         // El primer paso es obtener la plantilla en este caso su código coincide con el estatus
         Plantilla plantilla = (from pl in ctx.Plantillas
                                where pl.PlantillaId == status
                                select pl).FirstOrDefault<Plantilla>();
         if (plantilla != null)
         {
             asunto = String.Format(plantilla.Asunto, solProveedor.SolicitudProveedorId, solProveedor.RazonSocial, solProveedor.Direccion, solProveedor.Localidad,
                 solProveedor.CodPostal, solProveedor.Provincia, solProveedor.Comunidad, solProveedor.Pais, solProveedor.Telefono, solProveedor.Fax,
                 solProveedor.Movil, solProveedor.Email, solProveedor.Url, solProveedor.Nif, comentarios);
             cuerpo = String.Format(plantilla.Cuerpo, solProveedor.SolicitudProveedorId, solProveedor.RazonSocial, solProveedor.Direccion, solProveedor.Localidad,
                 solProveedor.CodPostal, solProveedor.Provincia, solProveedor.Comunidad, solProveedor.Pais, solProveedor.Telefono, solProveedor.Fax,
                 solProveedor.Movil, solProveedor.Email, solProveedor.Url, solProveedor.Nif, comentarios);
         }
         PortalProMailController.SendEmail(solProveedor.Email, asunto, cuerpo);
     }
     return res;
 }

        // este método se ejecutará de manera asíncrona.
        public string LaunchActividadPrincipal(out int threadId)
        {
            threadId = Thread.CurrentThread.ManagedThreadId;
            // abrir conexiones 
            PortalProContext ctx = new PortalProContext();
            // Actualizar los registros de proceso para dejar bloqueada la barra
            Progresos progreso = (from p in ctx.Progresos
                                  where p.ProgresoId == 6
                                  select p).FirstOrDefault<Progresos>();
            if (progreso != null)
            {
                progreso.NumReg = 0;
                progreso.TotReg = 1;
                ctx.SaveChanges();
            }

            string strConnect = ConfigurationManager.ConnectionStrings["PortalProTestConnection"].ConnectionString;
            SqlConnection con = new SqlConnection(strConnect);
            con.Open();
            string sql = "SELECT COUNT(*) FROM [dbo].[Cau_PortalProv_LineOfBusiness]";
            SqlCommand cmd = new SqlCommand(sql, con);
            int totreg = (int)cmd.ExecuteScalar();
            int numreg = 0;
            sql = @"SELECT  
                        [LINEOFBUSINESSID]
                        ,[DESCRIPTION]
                    FROM [dbo].[Cau_PortalProv_LineOfBusiness]";
            cmd = new SqlCommand(sql, con);
            SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                numreg++;
                string codax = dr.GetString(0);
                // Buscamos si esa ActividadPrincipal existe
                ActividadPrincipal emp2 = (from e2 in ctx.ActividadPrincipals
                                where e2.CodAx == codax
                                select e2).FirstOrDefault<ActividadPrincipal>();
                if (emp2 == null)
                {
                    emp2 = new ActividadPrincipal();
                    ctx.Add(emp2);
                }
                emp2.CodAx = codax;
                emp2.Nombre = dr.GetString(1);
                ctx.SaveChanges();
                // Actualizar los registros de proceso
                progreso = (from p in ctx.Progresos
                                      where p.ProgresoId == 6
                                      select p).FirstOrDefault<Progresos>();
                if (progreso != null)
                {
                    progreso.NumReg = numreg;
                    progreso.TotReg = totreg;
                    ctx.SaveChanges();
                }
            }
            dr.Close();
            ctx.Dispose();
            con.Close();
            con.Dispose();
            return "";
        }

 public static Documento CrearDocumentoDesdeArchivoCargado(string application, string fichero, PortalProContext ctx)
 {
     Documento d = null;
     // siempre creamos un nuevo documento
     string portalProRepo = ConfigurationManager.AppSettings["PortalProRepository"];
     string uploadRepo = ConfigurationManager.AppSettings["UploadRepository"];
     switch (application)
     {
         case "PortalPro":
             uploadRepo = ConfigurationManager.AppSettings["UploadRepository"];
             break;
         case "PortalPro2":
             uploadRepo = ConfigurationManager.AppSettings["UploadRepository2"];
             break;
     }
     d = new Documento();
     int pos = fichero.LastIndexOf(".");
     if (pos > -1)
         d.Extension = fichero.Substring(pos + 1);
     pos = fichero.LastIndexOf("-");
     if (pos > 0)
         d.NomFichero = fichero.Substring(pos + 1);
     ctx.Add(d);
     ctx.SaveChanges();
     string nFichero = String.Format("{0:000000}-{1}", d.DocumentoId, d.NomFichero);
     string origen = Path.Combine(uploadRepo, fichero);
     string destino = Path.Combine(portalProRepo, nFichero);
     File.Move(origen, destino);
     ctx.SaveChanges();
     return d;
 }

 /// <summary>
 /// Crear un nuevo Responsables
 /// </summary>
 /// <param name="responsable">Objeto a crear, el atributo ResponsableId lo genera la aplicación y es devuelto en el objeto incluido en la respuesta.</param>
 /// <param name="tk"> Tique de autorzación (se debe obtener con la accion Login)</param>
 /// <returns></returns>
 public virtual Responsable Post(Responsable responsable, 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 (Responsables)"));
         }
         // comprobar las precondiciones
         if (responsable == null)
         {
             throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
         }
         int usuarioId = 0;
         if (responsable.Usuario != null)
         {
             usuarioId = responsable.Usuario.UsuarioId;
             responsable.Usuario = null;
         }
         // dar de alta el objeto en la base de datos y devolverlo en el mensaje
         ctx.Add(responsable);
         if (usuarioId != 0)
         {
             responsable.Usuario = (from u in ctx.Usuarios
                                    where u.UsuarioId == usuarioId
                                    select u).FirstOrDefault<Usuario>();
         }
         ctx.SaveChanges();
         return responsable;
     }
 }

        public virtual Pedido Post(Pedido pedido, string userId, 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 (Pedido)"));
                }
                // comprobar las precondiciones
                if (pedido == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                // La aplicación ahora depende del comienzo del usuario
                string application = "PortalPro";
                switch (userId.Substring(0, 1))
                {
                    case "U":
                        application = "PortalPro2";
                        break;
                    case "G":
                        application = "PortalPro";
                        break;
                }
                // comprobamos si existen los ficheros que necesitamos
                string fPdf = PortalProWebUtility.BuscarArchivoCargado(application, userId, "Pedido", "PDF");
                if (fPdf == "")
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Se necesita un fichero PDF asociado a la pedido (Pedido)"));
                }
                // Controlamos las propiedades que son en realidad objetos.
                int proveedorId = 0;
                if (pedido.Proveedor != null)
                {
                    proveedorId = pedido.Proveedor.ProveedorId;
                    pedido.Proveedor = null;
                }
                int responsableId = 0;
                if (pedido.Responsable != null)
                {
                    responsableId = pedido.Responsable.ResponsableId;
                    pedido.Responsable = null;
                }
                int empresaId = 0;
                if (pedido.Empresa != null)
                {
                    empresaId = pedido.Empresa.EmpresaId;
                    pedido.Empresa = null;
                }
                int documentoXmlId = 0;
                if (pedido.DocumentoXml != null)
                {
                    documentoXmlId = pedido.DocumentoXml.DocumentoId;
                    pedido.DocumentoXml = null;
                }

                int documentoPdfId = 0;
                if (pedido.DocumentoPdf != null)
                {
                    documentoPdfId = pedido.DocumentoPdf.DocumentoId;
                    pedido.DocumentoPdf = null;
                }
                // dar de alta el objeto en la base de datos y devolverlo en el mensaje
                ctx.Add(pedido);
                if (proveedorId != 0)
                {
                    pedido.Proveedor = (from p in ctx.Proveedors
                                        where p.ProveedorId == proveedorId
                                        select p).FirstOrDefault<Proveedor>();
                }
                if (empresaId != 0)
                {
                    pedido.Empresa = (from p in ctx.Empresas
                                      where p.EmpresaId == empresaId
                                      select p).FirstOrDefault<Empresa>();
                }
                if (responsableId != 0)
                {
                    pedido.Responsable = (from p in ctx.Responsables
                                          where p.ResponsableId == responsableId
                                          select p).FirstOrDefault<Responsable>();
                }
                if (documentoXmlId != 0)
                {
                    pedido.DocumentoXml = (from d in ctx.Documentos
                                           where d.DocumentoId == documentoPdfId
                                           select d).FirstOrDefault<Documento>();
                }
                if (documentoPdfId != 0)
                {
                    pedido.DocumentoPdf = (from d in ctx.Documentos
                                           where d.DocumentoId == documentoPdfId
                                           select d).FirstOrDefault<Documento>();
                }
                if (fPdf != "")
                {
                    pedido.DocumentoPdf = PortalProWebUtility.CrearDocumentoDesdeArchivoCargado(application, fPdf, ctx);
                }
                pedido.FechaAlta = DateTime.Now;
//.........这里部分代码省略.........

 public static string ComprobarLineaFacturaContraPedidoSuscripcion(CabFactura factura, LinFactura l, PortalProContext ctx)
 {
     string m = "";
     // (1) comprobar que el pedido existe
     Pedido p = (from ped in ctx.Pedidos
                 where ped.NumPedido == l.NumeroPedido
                 select ped).FirstOrDefault<Pedido>();
     if (p == null)
     {
         m = String.Format("El pedido {0} no existe.", l.NumeroPedido);
         return m;
     }
     // ahora se compara contra línea, luego hay que buscar la línea correspondiente
     LinPedido lp = (from linped in ctx.LinPedidos
                     where linped.NumPedido == l.NumeroPedido
                     && linped.NumLinea == l.NumLineaPedido
                     select linped).FirstOrDefault<LinPedido>();
     if (lp == null)
     {
         m = String.Format("El linea {0} del pedido {1} no existe.", l.NumLineaPedido, l.NumeroPedido);
         return m;
     }
     // Obtener parámetros y datos de proveedor para verificar márgenes
     Parametro parametro = (from par in ctx.Parametros1
                            where par.ParametroId == 1
                            select par).FirstOrDefault<Parametro>();
     Proveedor proveedor = p.Proveedor;
     // comprobamos las reglas para pedido de suscripcion
     decimal importeAFacturar = PedidoSuscripcionImporteFacturable(p, factura, ctx);
     if (importeAFacturar == 0)
     {
         m = String.Format("NO se puede facturar con esta fecha e importe contra el pedido de suscripción {0}", p.NumPedido);
         return m;
     }
     l.NumeroPedido = p.NumPedido;
     l.NumLineaPedido = lp.NumLinea;
     l.Importe = importeAFacturar;
     l.Descripcion = lp.Descripcion;
     l.PorcentajeIva = lp.PorcentajeIva;
     // actualizar empresa y responsables
     factura.Empresa = p.Empresa;
     factura.Responsable = p.Responsable;
     factura.TotalFactura += l.Importe;
     l.CabFactura = factura;
     // antes de salir conmprobamos si el total facturado supera
     // el margen de control PDF
     if (factura.TotalFactura > parametro.MaxImportePdf)
     {
         factura.Estado = "RECIBIDA2";
         factura.Historial += String.Format("{0:dd/MM/yyyy hh:mm:ss} La factura {1} pasa a estado INCIDENCIA debido a que su total {2} supera al margen de control PDF {4} <br/>",
             DateTime.Now, factura.NumFactura, factura.TotalFactura, factura.Estado, parametro.MaxImportePdf);
     }
     ctx.Add(l);
     ctx.SaveChanges();
     return m;
 }

 public virtual CabFactura Post(CabFactura factura, string userId, 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)"));
         }
         // comprobar las precondiciones
         if (factura == null)
         {
             throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
         }
         // comprobamos que no hay una factura para el mismo proveedor en ese año y con
         // el mismo número de factura
         CabFactura f = PortalProWebUtility.YaExisteUnaFacturaComoEsta(factura, ctx);
         if (f != null)
         {
             string m = String.Format("Ya hay una factura del proveedor para este año {0:yyyy} con el mismo número {1}", f.FechaEmision, f.NumFactura);
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, m));
         }
         // La aplicación ahora depende del comienzo del usuario
         string application = "PortalPro";
         switch (userId.Substring(0, 1))
         {
             case "U":
                 application = "PortalPro2";
                 break;
             case "G":
                 application = "PortalPro";
                 break;
         }
         // comprobamos si existen los ficheros que necesitamos
         string fPdf = PortalProWebUtility.BuscarArchivoCargado(application, userId, "Factura", "PDF");
         if (fPdf == "")
         {
             throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Se necesita un fichero PDF asociado a la factura (CabFactura)"));
         }
         // el archivo Xml no es obligatorio, pero si lo han subido cargamos el fichero
         string fXml = PortalProWebUtility.BuscarArchivoCargado(application, userId, "Factura", "XML");
         // Controlamos las propiedades que son en realidad objetos.
         int proveedorId = 0;
         if (factura.Proveedor != null)
         {
             proveedorId = factura.Proveedor.ProveedorId;
             factura.Proveedor = null;
         }
         int documentoPdfId = 0;
         if (factura.DocumentoPdf != null)
         {
             documentoPdfId = factura.DocumentoPdf.DocumentoId;
             factura.DocumentoPdf = null;
         }
         int documentoXmlId = 0;
         if (factura.DocumentoXml != null)
         {
             documentoXmlId = factura.DocumentoXml.DocumentoId;
             factura.DocumentoXml = null;
         }
         int empresaId = 0;
         if (factura.Empresa != null)
         {
             empresaId = factura.Empresa.EmpresaId;
             factura.Empresa = null;
         }
         int responsableId = 0;
         if (factura.Responsable != null)
         {
             responsableId = factura.Responsable.ResponsableId;
             factura.Responsable = null;
         }
         // dar de alta el objeto en la base de datos y devolverlo en el mensaje
         factura.Estado = "ACEPTADA";
         ctx.Add(factura);
         if (proveedorId != 0)
         {
             factura.Proveedor = (from p in ctx.Proveedors
                                  where p.ProveedorId == proveedorId
                                  select p).FirstOrDefault<Proveedor>();
         }
         if (documentoPdfId != 0)
         {
             factura.DocumentoPdf = (from d in ctx.Documentos
                                     where d.DocumentoId == documentoPdfId
                                     select d).FirstOrDefault<Documento>();
         }
         if (documentoXmlId != 0)
         {
             factura.DocumentoXml = (from d in ctx.Documentos
                                     where d.DocumentoId == documentoXmlId
                                     select d).FirstOrDefault<Documento>();
         }
         if (fPdf != "")
         {
             factura.DocumentoPdf = PortalProWebUtility.CrearDocumentoDesdeArchivoCargado(application, fPdf, ctx);
         }
         if (fXml != "")
         {
             factura.DocumentoXml = PortalProWebUtility.CrearDocumentoDesdeArchivoCargado(application, fXml, ctx);
//.........这里部分代码省略.........