/// <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)"));
}
}
}
/// <summary>
/// Devueleve lo que queda por facturar de un pedido de suscripción, excluyendo
/// la factura pasada
/// </summary>
/// <param name="pedido">Pedido de suscripción</param>
/// <param name="factura">Factura de referencia</param>
/// <param name="ctx">Contexto OpenAccess</param>
/// <returns>Importe pendiente o cero si no se puede facturar.</returns>
public static decimal PedidoSuscripcionImporteFacturable(Pedido pedido, CabFactura factura, PortalProContext ctx)
{
decimal r = 0;
DateTime fecha = (DateTime)factura.FechaEmision;
// si no es un pedido de suscripción no lo tratamos.
if (pedido.TipoPedido != "SUSCRIPCION")
return r;
// si hemos superado la fecha límite, tampoco facturamos
// solo comprobamos si la fecha no es nula
if (pedido.FechaLimite != null && (fecha > pedido.FechaLimite))
return r;
// calcular el primer y último dia del mes
DateTime primerDiaDelMes = new DateTime(fecha.Year, fecha.Month, 1);
DateTime ultimoDiaDelMes = primerDiaDelMes.AddMonths(1).AddDays(-1);
// comprobar el total facturado contra ese pedido
// en ese mes
var rs = from lf in ctx.LinFacturas
where lf.NumeroPedido == pedido.NumPedido &&
(lf.FechaEmision >= primerDiaDelMes && lf.FechaEmision <= ultimoDiaDelMes)
&& lf.CabFactura.CabFacturaId != factura.CabFacturaId
select lf;
decimal totalFacturado = rs.AsEnumerable().Sum(x => x.Importe);
decimal totalPedido = pedido.TotalPedido;
// ahora la comprobación devolvemos pendiente
if (totalFacturado < totalPedido)
r = (totalPedido - totalFacturado);
return r;
}
/// <summary>
/// Obtiene la solicitud cuyo ID corresponde con el pasado
/// </summary>
/// <param name="id">Identificador únicode la solicitud</param>
/// <param name="tk">Código del tique de autorización (Véase "Login")</param>
/// <returns></returns>
public virtual SolicitudProveedor Get(int id, string tk)
{
using (PortalProContext ctx = new PortalProContext())
{
if (CntWebApiSeguridad.CheckTicket(tk, ctx))
{
SolicitudProveedor solProveedor = (from sp in ctx.SolicitudProveedors
where sp.SolicitudProveedorId == id
select sp).FirstOrDefault<SolicitudProveedor>();
if (solProveedor != null)
{
solProveedor = ctx.CreateDetachedCopy<SolicitudProveedor>(solProveedor, x => x.GrupoProveedor, x => x.SolicitudStatus, x => x.SolicitudStatus, x => x.ActividadPrincipal1, x => x.Pais1, x => x.Comunidad1, x => x.Provincia1);
return solProveedor;
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No hay una solicitud con el id proporcionado (Solicitudes proveedores)"));
}
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Solicitudes proveedores)"));
}
}
}
/// <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)"));
}
}
}
/// <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>
/// 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;
}
}
// este método se ejecutará de manera asíncrona.
public string LaunchPedido(out int threadId)
{
threadId = Thread.CurrentThread.ManagedThreadId;
int numreg = 0;
int totreg = 0;
PortalProContext ctx = new PortalProContext();
EntitiesModel con = new EntitiesModel();
var rs = (from cp in con.Cau_PortalPro_VCabPedidos
select cp);
totreg = rs.Count();
foreach (Cau_PortalPro_VCabPedido cp1 in rs)
{
numreg++;
// Buscamos si ese pedido ya existe
Pedido p2 = (from p in ctx.Pedidos
where p.NumPedido == cp1.PURCHID
select p).FirstOrDefault<Pedido>();
if (p2 == null)
{
p2 = new Pedido();
p2.NumPedido = cp1.PURCHID;
p2.FechaAlta = cp1.CREATEDDATE;
// buscamos al proveedor
p2.Proveedor = (from pr in ctx.Proveedors
where pr.CodAx == cp1.INVOICEACCOUNT
select pr).FirstOrDefault<Proveedor>();
p2.TotalPedido = 0;
p2.TotalFacturado = 0;
p2.Estado = cp1.ESTADO;
p2.DocumentoPdf = null;
p2.DocumentoXml = null;
p2.TipoPedido = cp1.TIPO;
// buscar la empresa
p2.Empresa = (from e in ctx.Empresas
where e.CodAx == cp1.DATAAREAID
select e).FirstOrDefault<Empresa>();
p2.FechaLimite = cp1.FECHALIMITE;
p2.FechaRecepcion = cp1.FECHARECEPCION;
}
else
{
}
// 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 = numreg;
progreso.TotReg = totreg;
ctx.SaveChanges();
}
}
return "";
}
/// <summary>
/// Retorna un vector con parejas de nombre y valor
/// que reflejan una serie de indicadores:
/// n_solPro = Número de solicitudes de proveedores
/// n_solProA = Núemro de solicitudes aceptadas.
/// n_solProR = Número de solicitudes rechazadas
/// </summary>
/// <param name="tk">Tique de autorización (ver Login)</param>
/// <returns></returns>
public virtual IEnumerable<Indicador> Get(string tk)
{
IList<Indicador> lindi = new List<Indicador>();
Indicador indi = null;
using (PortalProContext ctx = new PortalProContext())
{
if (CntWebApiSeguridad.CheckTicket(tk, ctx))
{
// Se van obteniendo uno a uno y aplciando a lista
// Número solicitudes de proveedor
int n_solPro = (from p in ctx.SolicitudProveedors
select p).Count();
indi = new Indicador()
{
id = "n_solPro",
valor = (decimal)n_solPro
};
lindi.Add(indi);
// Número de solicitudes aprobadas
int n_solProA = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 2
select p).Count();
indi = new Indicador()
{
id = "n_solProA",
valor = (decimal)n_solProA
};
lindi.Add(indi);
// Número de solicitudes rechazadas
int n_solProR = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 3
select p).Count();
indi = new Indicador()
{
id = "n_solProR",
valor = (decimal)n_solProR
};
lindi.Add(indi);
int n_solProP = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 1
select p).Count();
indi = new Indicador()
{
id = "n_solProP",
valor = (decimal)n_solProP
};
lindi.Add(indi);
return lindi;
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (SolicitudLogs)"));
}
}
}
// 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 "";
}
static void CargarEmpresas(PortalProContext ctx, SqlConnection con)
{
string sql = "SELECT * FROM [PortalProTest].[dbo].[Cau_PortalPro_VEmpresas]";
SqlCommand command = new SqlCommand(sql,con);
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
string idEmpresa = reader["IDEMPRESA"].ToString();
string nombre = reader["NOMBRE"].ToString();
Console.WriteLine("ID:{0} N:{1}", idEmpresa, nombre);
}
reader.Close();
}
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;
}
static void Main(string[] args)
{
// abrir conexiones
PortalProContext ctx = new PortalProContext();
string strConnect = ConfigurationManager.ConnectionStrings["PortalProTestConnection"].ConnectionString;
SqlConnection con = new SqlConnection(strConnect);
con.Open();
Console.WriteLine("Cargar empresas --------------");
CargarEmpresas(ctx, con);
Console.ReadLine();
Console.WriteLine("Cargar poveedores --------------");
CargarProveedores(ctx, con);
Console.ReadLine();
}
/// <summary>
/// Obtiene todos las Parametros 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<Parametro> Get(string tk)
{
using (PortalProContext ctx = new PortalProContext())
{
if (CntWebApiSeguridad.CheckTicket(tk, ctx))
{
IEnumerable<Parametro> parametros = (from pl in ctx.Parametros1
select pl).ToList<Parametro>();
parametros = ctx.CreateDetachedCopy<IEnumerable<Parametro>>(parametros);
return parametros;
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Parametros)"));
}
}
}
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>();
// 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;
}
foreach (Documento d in docs)
{
d.DescargaUrl = PortalProWebUtility.CargarUrlDocumento(application, d, tk);
}
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>
/// Obtiene una Parametro cuyo ID corresponde con el pasado
/// en este caso no necesita tique porque es para solicitudes.
/// </summary>
/// <param name="id">Identificador único de la Parametro</param>
/// <returns></returns>
public virtual Parametro Get(int id)
{
using (PortalProContext ctx = new PortalProContext())
{
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)"));
}
}
}
public virtual IEnumerable<ActividadPrincipal> Get(string tk)
{
using (PortalProContext ctx = new PortalProContext())
{
if (CntWebApiSeguridad.CheckTicket(tk, ctx) || tk == "solicitud")
{
IEnumerable<ActividadPrincipal> actividadesPrincipales = (from ai in ctx.ActividadPrincipals
orderby ai.Nombre
select ai).ToList<ActividadPrincipal>();
actividadesPrincipales = ctx.CreateDetachedCopy<IEnumerable<ActividadPrincipal>>(actividadesPrincipales);
return actividadesPrincipales;
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (Actividades principales)"));
}
}
}