C# PortalProModelo.PortalProContext类代码示例

 /// <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>
 /// 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)"));
         }
     }
 }

        public virtual IEnumerable<CabFactura> Get(string proveedorId, string tk)
        {
            using (PortalProContext ctx = new PortalProContext())
            {
                if (CntWebApiSeguridad.CheckTicket(tk, ctx))
                {
                    int pId = int.Parse(proveedorId);
                    IEnumerable<CabFactura> facturas = (from f in ctx.CabFacturas
                                                        where f.Proveedor.ProveedorId == pId
                                                        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>
 /// 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;
 }

 /// <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)"));
         }
     }
 }

 public static WebApiTicket LoginProveedor(string login, string password, int minutes, PortalProContext ctx)
 {
     WebApiTicket tk = null;
     // Primero comprobar si exite un usuario con ese login y contraseña
     UsuarioProveedor usuario = (from u in ctx.UsuarioProveedors
                        where u.Login == login
                        select u).FirstOrDefault<UsuarioProveedor>();
     if (usuario != null)
     {
         // User exists. Does the password match?
         if (usuario.Password == GetHashCode(password))
         {
             // Go to get the ticket
             string code = GenerateTicket();
             tk = new WebApiTicket()
             {
                 Codigo = code,
                 Inicio = DateTime.Now,
                 UsuarioProveedor = usuario
             };
             tk.Fin = tk.Inicio.AddMinutes(minutes);
         }
     }
     return tk;
 }

 /// <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 IEnumerable<Documento> GetDocumentos(int idPro, string userId, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             Proveedor proveedor = (from p in ctx.Proveedors
                                    where p.ProveedorId == idPro
                                    select p).FirstOrDefault<Proveedor>();
             if (proveedor != null)
             {
                 IEnumerable<Documento> docs = (from d in ctx.Documentos
                                                where d.Proveedor.ProveedorId == idPro
                                                select d).ToList<Documento>();
                 FetchStrategy fs = new FetchStrategy();
                 fs.LoadWith<Documento>(x => x.TipoDocumento);
                 IEnumerable<Documento> documentos = ctx.CreateDetachedCopy<IEnumerable<Documento>>(docs, fs);
                 return documentos;
             }
             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>
        /// 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 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)"));
         }
     }
 }

        public virtual bool Post(string proceso, string tk)
        {
            using (PortalProContext ctx = new PortalProContext())
            {
                if (CntWebApiSeguridad.CheckTicket(tk, ctx) || tk == "solicitud")
                {
                    switch (proceso)
                    {
                        case "Empresa":
                            CntAxapta.ImportarEmpresas();
                            break;
                        case "Proveedor":
                            CntAxapta.ImportarProveedors();
                            break;
                        case "Responsable":
                            CntAxapta.ImportarResponsables();
                            break;
                        case "Pedido":
                            CntAxapta.ImportarPedidos();
                            break;
                        case "Factura":
                            CntAxapta.ImportarFacturas();
                            break;
                    }

                }
                else
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Importar)"));
                }
            }
            return true;
        }

 /// <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)"));
         }
     }
 }

 public virtual IEnumerable<Pedido> GetResponsable(string responsable, string tk)
 {
     using (PortalProContext ctx = new PortalProContext())
     {
         if (CntWebApiSeguridad.CheckTicket(tk, ctx))
         {
             // Comprobamos que hay un proveedor que coincide
             int pId = int.Parse(responsable);
             IEnumerable<Pedido> pedidos = (from f in ctx.Pedidos
                                            where f.Responsable.ResponsableId == 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)"));
         }
     }
 }