//dice si un usuario es valido o no. El validate viene prefijado con esos argumentos.
//Cada evz que alguien me pida algo en el servicio
public override void Validate(string login, string password)
{
try
{
GestionEmpresasEntities db = new GestionEmpresasEntities();
var usr = from usuarios in db.Usuario
where usuarios.login == login
select usuarios;
Usuario usu = usr.First();
db.Dispose();
if (usu != null && usu.password == password)
{
}
else
{
throw new FaultException("ERROR USUARIO NO AUTORIZADO");
}
}
catch
{
throw new FaultException("ERROR USUARIO NO AUTORIZADO");
}
}
/********************************************************************/
/*****************************FIN IVAN*******************************/
/********************************************************************/
/********************************************************************/
/*****************************MIGUEL*********************************/
/********************************************************************/
/// <summary>
/// Método que añade una accion comercial a la base de datos
/// </summary>
/// <param name="accion"> Objeto usuario a añadir en la base de datos</param>
/// <returns>Devuelve true si se ha añadido el registro correctamente. False si no.</returns>
public int addAccionComercial(AccionComercialData accion)
{
if (accion == null) return -1;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
AccionComercial nuevo = new AccionComercial();
nuevo.descripcion = accion.descripcion;
nuevo.comentarios = accion.comentarios;
nuevo.fechaHora = accion.fechaHora;
nuevo.idUsuario = accion.idUsuario;
nuevo.idTipoAccion = accion.idTipoAccion;
nuevo.idEstadoAccion = accion.idEstadoAccion;
nuevo.idEmpresa = accion.idEmpresa;
db.AccionComercial.Add(nuevo);
db.SaveChanges();
return nuevo.idAccion;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Metodo que añade un nuevo contacto a la base de datos a partir de un objeto contacto de tipo ContactoData
/// </summary>
/// <param name="contacto"></param>
/// <returns></returns>
public int AddContacto(ContactoData contacto)
{
if (contacto == null) return -1;
if (contacto.nif == "" || contacto.nombre == "") return -1;
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
Contacto nueva = new Contacto();
nueva.idContacto = contacto.idContacto;
nueva.nif = contacto.nif;
nueva.nombre = contacto.nombre;
nueva.idEmpresa = contacto.idEmpresa;
bd.Contacto.Add(nueva);
bd.SaveChanges();
return nueva.idContacto;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
public bool esUsuario(string login, string password)
{
bool resultado;
try
{
//Using es para no tener que liberar recursos, no hacer el disposing
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from usuario in db.Usuario
where usuario.login == login
select usuario;
Usuario usr = consulta.First();
resultado = (usr != null) && (usr.password == PasswordManager.getMD5(password));
}
return resultado;
}
catch
{
return false;
}
}
/// <summary>
/// Método que elimina un registro empresa de la tabla Empresa
/// </summary>
/// <param name="idEmpresa"></param>
/// <returns></returns>
public bool deleteEmpresa(int idEmpresa)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consult = from emp in db.Empresa
where emp.idEmpresa == idEmpresa
select emp;
Empresa empe = consult.First();
//eliminamos los telefonos, emails y direcciones asociados a la empresa
int tamanoTel=empe.Telefono.Count;
for (int i = 0; i <tamanoTel ; i++)
{
db.Telefono.Remove((empe.Telefono.First()));
}
int tamanoMail = empe.Email.Count;
for (int i = 0; i < tamanoMail; i++)
{
db.Email.Remove((empe.Email.First()));
}
int tamanoDir = empe.Direccion.Count;
for (int i = 0; i < tamanoDir; i++)
{
db.Direccion.Remove((empe.Direccion.First()));
}
// eliminamos los contactos asociados a la empresa y sus respectivos telefonos, emails y direcciones
int numContacto=empe.Contacto.Count;
for (int i = 0; i < numContacto;i++ )
{
int numConTel=empe.Contacto.ElementAt(i).Telefono.Count;
int numConMail = empe.Contacto.ElementAt(i).Email.Count;
int numConDir = empe.Contacto.ElementAt(i).Direccion.Count;
for (int j = 0; j < numConTel; j++)
{
db.Telefono.Remove((empe.Contacto.ElementAt(i).Telefono.First()));
}
for (int k = 0; k < numConMail; k++)
{
db.Email.Remove((empe.Contacto.ElementAt(i).Email.First()));
}
for (int l = 0; l < numConDir; l++)
{
db.Direccion.Remove((empe.Contacto.ElementAt(i).Direccion.First()));
}
db.Contacto.Remove(empe.Contacto.First());
}
/* foreach (Contacto cont in empe.Contacto)
{
int tamanoConTel = cont.Telefono.Count;
int tamanoConMail = cont.Email.Count;
int tamanoConDir = cont.Direccion.Count;
for (int i = 0; i < tamanoConTel; i++)
{
db.Telefono.Remove((cont.Telefono.First()));
}
for (int i = 0; i < tamanoConMail; i++)
{
db.Email.Remove((cont.Email.First()));
}
for (int i = 0; i < tamanoConDir; i++)
{
db.Direccion.Remove((cont.Direccion.First()));
}
}*/
// eliminamos las acciones comerciales asociadas a la empresa
/* for (int i = 0; i < empe.AccionComercial.Count;i++)
{
empe.AccionComercial.Remove(empe.AccionComercial.ElementAt(i));
}
/* foreach (AccionComercial ac in empe.AccionComercial)
{
//deleteAccionComercial(ac.idAccion);
empe.AccionComercial.Remove(ac);
}*/
// eliminamos la empresa
db.Empresa.Remove(empe);
db.SaveChanges();
}
return true;
}
catch (SqlException ex)
{
FaultException fault = new FaultException("EError SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
/***************************************************************
**************************** Fin Sector ************************
****************************************************************/
/***************************************************************
****************** Estado de accion ***************************
****************************************************************/
/// <summary>
/// Metodo que me devuelve todos los sectores de la BD
/// </summary>
/// <returns></returns>
public List<EstadoAccion> GetEstadoAccion()
{
List<EstadoAccion> lst = new List<EstadoAccion>();
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from estadoAccion in db.EstadoDeAccion
select new EstadoAccion()
{
idEstadoAccion = estadoAccion.idEstadoAccion,
descripcion = estadoAccion.descripcion,
};
lst = consulta.ToList();
return lst;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Permite editar un teléfono que exista en la base de datos. Como el teléfono está relacionado obligatoriamente con una empresa o un contacto uno de los dos parámetros será null.
/// </summary>
/// <param name="t">El teléfono a editar.</param>
/// <returns>True si se ha editado.</returns>
public int EditTelefono(TelefonoData t)
{
if (t == null) return -1;
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var data = from telefonos in bd.Telefono
where telefonos.idTelefono == t.idTelefono
select telefonos;
Telefono telefono = data.First();
telefono.numero = t.numero;
bd.SaveChanges();
return telefono.idTelefono;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que edita el campo correo de un registro de la tabla email
/// </summary>
/// <param name="id">Identificador del email a editar po modificar.</param>
/// <param name="correo">Correo a modificar.</param>
/// <returns>Devuelve true si se ha editado correctamente el registro, False si no.</returns>
public bool editEmail(int id, string correo)
{
if (id == null) return false;
if (correo == null) return false;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consult = from co in db.Email
where co.idEmail == id
select co;
if (consult.ToList().Count == 0) return false;
Email mailMod = consult.First();
mailMod.correo = correo;
db.SaveChanges();
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
/// <summary>
/// Metodo que a partir de un objeto e id me edita un contacto
/// </summary>
/// <param name="contacto"></param>
/// <param name="id"></param>
/// <returns></returns>
public int EditContacto(ContactoData contacto, int id)
{
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var consulta = from contact in bd.Contacto
where contact.idContacto == id
select contact;
Contacto nueva = consulta.First();
nueva.idContacto = contacto.idContacto;
nueva.idEmpresa = contacto.idEmpresa;
nueva.nif = contacto.nif;
nueva.nombre = contacto.nombre;
bd.SaveChanges();
return nueva.idContacto;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Método que elimina un registro usuario de la tabla Usuario
/// </summary>
/// <param name="idUsuario">identificador único de un registro usuario</param>
/// <returns>Devuelve true si se ha eliminado correctamente y false si no.</returns>
public bool deleteUsuario(int idUsuario)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from usuario in db.Usuario
where usuario.idUsuario == idUsuario
select usuario;
Usuario u = consulta.First();
db.Usuario.Remove(u);
db.SaveChanges();
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Devuelve el listado de teléfonos perteneciente a una empresa concreta
/// </summary>
/// <param name="idContacto">El id de la empresa cuyos teléfonos queremos obtener</param>
/// <returns>El listado de teléfonos de una empresa</returns>
public List<TelefonoData> GetTelefonosEmpresa(int idEmpresa)
{
try
{
List<TelefonoData> telefonos = new List<TelefonoData>();
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var data = from empresas in bd.Empresa
where empresas.idEmpresa == idEmpresa
select empresas;
foreach (Telefono t in data.First().Telefono)
{
telefonos.Add(new TelefonoData()
{
idTelefono = t.idTelefono,
numero = t.numero
});
}
return telefonos;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/***************************************************************
****************** Fin Estado de accion ***********************
****************************************************************/
/***************************************************************
* Usuario
***************************************************************/
/// <summary>
/// Método que añade un usuario a la base de datos
/// </summary>
/// <param name="usuario"> Objeto usuario a añadir en la base de datos</param>
/// <returns>Devuelve true si se ha añadido el registro correctamente. False si no.</returns>
public int addUsuario(UsuarioData usuario)
{
if (usuario == null) return -1;
if (usuario.login == "" || usuario.password == "") return -1;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
Usuario nuevo = new Usuario();
nuevo.login = usuario.login;
nuevo.nombre = usuario.nombre;
nuevo.password = PasswordManager.getMD5(usuario.password);
db.Usuario.Add(nuevo);
db.SaveChanges();
return nuevo.idUsuario;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/***************************************************************
**************************** Fin Direccion ************************
***************************************************************/
/***************************************************************
***************************** Sector ***************************
***************************************************************/
/// <summary>
/// Metodo que me devuelve todos los sectores de la BD
/// </summary>
/// <returns></returns>
public List<SectorData> GetSector()
{
List<SectorData> lst = new List<SectorData>();
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from sector in db.Sector
select new SectorData()
{
idSector = sector.idSector,
descripcion = sector.descripcion,
};
lst = consulta.ToList();
return lst;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Permite buscar un teléfono por su número.
/// </summary>
/// <param name="numero">El número del teléfono a buscar.</param>
/// <returns>El teléfonobuscado.</returns>
public TelefonoData GetNumeroTelefono(string numero)
{
try
{
List<TelefonoData> t = new List<TelefonoData>();
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var datos = from telefonos in bd.Telefono
where telefonos.numero == numero
select new TelefonoData()
{
idTelefono = telefonos.idTelefono,
numero = telefonos.numero
};
t = datos.ToList();
}
if (t.Count == 0) return null;
else return t.First();
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/******************************************* USUARIO *****************************************/
/// <summary>
/// Devuelve un usuario buscado por su nombre.
/// </summary>
/// <param name="nombre">El nombre de la empresa.</param>
/// <returns>La empresa.</returns>
public UsuarioData GetNombreUsuario(string nombre)
{
try
{
UsuarioData u;
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var data = from usuarios in bd.Usuario
where usuarios.nombre.ToLower() == nombre.ToLower()
select usuarios;
if (data.Count() == 1)
{
return new UsuarioData()
{
idUsuario = data.First().idUsuario,
login = data.First().login,
nombre = data.First().nombre,
password = data.First().password
};
}
return null;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/*/// <summary>
/// Devuelve un listado con todos los tipos de acciones existentes.
/// </summary>
/// <returns>El listado de acciones existentes.</returns>
public List<EstadoAccion> GetAllEstadoAccion()
{
try
{
List<EstadoAccion> listado = new List<EstadoAccion>();
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var datos = from estados in bd.EstadoDeAccion
select estados;
foreach (EstadoDeAccion tipo in datos)
{
EstadoAccion tdata = new EstadoAccion()
{
idEstadoAccion = tipo.idEstadoAccion,
descripcion = tipo.descripcion
};
listado.Add(tdata);
}
}
return listado;
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}*/
///// <summary>
///// Inserta un nuevo tipo de acción.
///// </summary>
///// <param name="tipoAccion">El tipo de acción a insertar.</param>
///// <returns>True si se inserta.</returns>
//public bool AddTipoAccion(TipoDeAccionData tipoAccion)
//{
// if (tipoAccion == null) return false;
// try
// {
// using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
// {
// TipoDeAccion tipo = new TipoDeAccion()
// {
// idTipoAccion = tipoAccion.idTipoAccion,
// descripcion = tipoAccion.descripcion
// };
// bd.TipoDeAccion.Add(tipo);
// bd.SaveChanges();
// }
// return true;
// }
// catch (SqlException ex)
// {
// FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
// throw fault;
// }
// catch (Exception ex)
// {
// FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
// throw fault;
// }
//}
///// <summary>
///// Edita un tipo de acción existente.
///// </summary>
///// <param name="tipoAccion">El tipo de acción a editar.</param>
///// <returns>True si se ha editado.</returns>
//public bool EditTipoAccion(TipoDeAccionData tipoAccion)
//{
// if (tipoAccion == null) return false;
// try
// {
// using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
// {
// var data = from tipos in bd.TipoDeAccion
// where tipos.idTipoAccion== tipoAccion.idTipoAccion
// select tipos;
// TipoDeAccion t = data.First();
// t.descripcion = tipoAccion.descripcion;
// bd.SaveChanges();
// return true;
// }
// }
// catch (SqlException ex)
// {
// FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
// throw fault;
// }
// catch (Exception ex)
// {
// FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
// throw fault;
// }
//}
/*******************************************EMPRESA *****************************************/
/// <summary>
/// Devuelve una empresa buscada por su nombre.
/// </summary>
/// <param name="nombre">El nombre de la empresa.</param>
/// <returns>La empresa.</returns>
public EmpresaData GetNombreEmpresa(string nombre)
{
try
{
EmpresaData e;
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var data = from empresas in bd.Empresa
where empresas.nombreComercial.ToLower() == nombre.ToLower()
select empresas;
if (data.Count() == 1)
{
return new EmpresaData()
{
cif = data.First().cif,
EmpresaID = data.First().idEmpresa,
nombreComercial = data.First().nombreComercial,
razonSocial = data.First().razonSocial,
sector = data.First().Sector.descripcion,
web = data.First().web
};
}
return null;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/******************************************* TIPOS DE ACCION *****************************************/
///// <summary>
///// Elimina un tipo de acción existente.
///// </summary>
///// <param name="idTipoAccion">El id del tipo de acción.</param>
///// <returns>True si se ha eliminado.</returns>
//public bool DeleteTipoAccion(int idTipoAccion)
//{
// try
// {
// using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
// {
// var datos = from tipos in bd.TipoDeAccion
// where tipos.idTipoAccion== idTipoAccion
// select tipos;
// bd.TipoDeAccion.Remove(datos.First());
// bd.SaveChanges();
// return true;
// }
// }
// catch (SqlException ex)
// {
// FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
// throw fault;
// }
// catch (Exception ex)
// {
// FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
// throw fault;
// }
//}
/// <summary>
/// Devuelve un tipo de acción buscando por su id.
/// </summary>
/// <param name="idTipoAccion">El id del tipo de acción.</param>
/// <returns>El tipo de acción buscado.</returns>
public TipoDeAccionData GetIdTipoAccion(int idTipoAccion)
{
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var datos = from tipos in bd.TipoDeAccion
where tipos.idTipoAccion == idTipoAccion
select new TipoDeAccionData()
{
idTipoAccion = tipos.idTipoAccion,
descripcion = tipos.descripcion
};
return datos.First();
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Permite eliminar un teléfono de la base de datos.
/// </summary>
/// <param name="t">El teléfono a eliminar</param>
/// <returns>True si lo elimina, false si no.</returns>
public bool DeleteTelefono(int idTelefono)
{
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var datos = from telefonos in bd.Telefono
where telefonos.idTelefono == idTelefono
select telefonos;
bd.Telefono.Remove(datos.First());
bd.SaveChanges();
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message, new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que busca un usuario por su Login
/// </summary>
/// <param name="login"></param>
/// <returns></returns>
UsuarioData IServicioGestion.getUsuarioLogin(string login)
{
UsuarioData user = new UsuarioData();
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from usuario in db.Usuario
where usuario.login == login
select new UsuarioData()
{
idUsuario = usuario.idUsuario,
login = usuario.login,
nombre = usuario.nombre,
password = usuario.password
};
if (consulta.ToList().Count == 0) return user;
return consulta.First();
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que devuelve el número total de usuarios
/// </summary>
/// <returns></returns>
public int numTotalUsuarios()
{
int numTotal = 0;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from user in db.Usuario
select user;
numTotal = consulta.ToList().Count;
return numTotal;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Método que edita una accion comercial de un registro de la tabla AccionComercial
/// </summary>
/// <param name="idAccion">Identificador de la accion comercial a editar.</param>
/// <param name="action">Objeto accion que contiene los datos a modificar</param>
/// <returns>Devuelve true si se ha modificado el registro correctamente. False si no.</returns>
public int editAccionComercial(AccionComercialData accion)
{
if (accion == null) return -1;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from action in db.AccionComercial
where action.idAccion == accion.idAccion
select action;
if (consulta.ToList().Count == 0)
{
return -1;
}
AccionComercial a = consulta.First();
a.descripcion = accion.descripcion;
a.comentarios = accion.comentarios;
a.fechaHora = accion.fechaHora;
a.idUsuario = accion.idUsuario;
a.idTipoAccion = accion.idTipoAccion;
a.idEstadoAccion = accion.idEstadoAccion;
a.idEmpresa = accion.idEmpresa;
db.SaveChanges();
return a.idAccion;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que elimina un registro accion comercial de la tabla AccionComercial
/// </summary>
/// <param name="idAccion">identificador único de un registro accion comercial</param>
/// <returns>Devuelve true si se ha eliminado correctamente y false si no.</returns>
public bool deleteAccionComercial(int idAccion)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from accion in db.AccionComercial
where accion.idAccion == idAccion
select accion;
AccionComercial a = consulta.First();
db.AccionComercial.Remove(a);
db.SaveChanges();
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Meotodo que a partir de un objeto street de tipo DireccionData y un id me borra un registro de la BD
/// </summary>
/// <param name="street"></param>
/// <param name="id"></param>
/// <returns></returns>
public int EditDireccion(DireccionData street)
{
if (street == null) return -1;
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
var consulta = from calle in bd.Direccion
where calle.idDireccion == street.idDireccion
select calle;
Direccion nueva = consulta.First();
nueva.idDireccion = street.idDireccion;
nueva.domicilio = street.domicilio;
nueva.poblacion = street.poblacion;
nueva.provincia = street.provincia;
nueva.codPostal = street.codPostal;
bd.SaveChanges();
return nueva.idDireccion;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Metodo que elimina un contacto a partir de un objeto contacto de tipo ContactoData y de un id
/// </summary>
/// <returns></returns>
public bool DeleteContacto(ContactoData contacto, int id)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var resultado = from contact in db.Contacto
where (contact.idContacto == id)
select contact;
// eliminamos los telefonos, emails y direcciones asociados al contacto
foreach (Telefono t in resultado.First().Telefono)
{
db.Telefono.Remove(t);
}
foreach (Email e in resultado.First().Email)
{
db.Email.Remove(e);
}
foreach (Direccion d in resultado.First().Direccion)
{
db.Direccion.Remove(d);
}
db.Contacto.Remove(resultado.First()); // Borra el objeto
db.SaveChanges(); // Se guarda los campios realizados
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que edita una empresa
/// </summary>
/// <param name="idEmpresa">Identificador de la empresa a modificar</param>
/// <param name="cif">Cif de la empresa modificada</param>
/// <param name="nombreComercial">Nombre Comercial de la nueva empresa</param>
/// <param name="razon">Razón Social de la nueva empresa</param>
/// <param name="web">Web de la empresa a modificar</param>
/// <param name="idSector">Sector de la empresa a modificar</param>
/// <returns>Devuelve true si se ha modificado correctamente.</returns>
public bool editEmpresa(int idEmpresa, string cif, string nombreComercial, string razon, string web, int idSector)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consult = from em in db.Empresa
where em.idEmpresa == idEmpresa
select em;
Empresa empMod = consult.First();
empMod.idEmpresa = idEmpresa;
empMod.cif = cif;
empMod.nombreComercial = nombreComercial;
empMod.razonSocial = razon;
empMod.web = web;
empMod.idSector = idSector;
db.SaveChanges();
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("EError SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
/// <summary>
/// Método que devuelve una empresa según un id determinado
/// </summary>
/// <param name="id">Identificador</param>
/// <returns>Devuelve un objeto empresa</returns>
public EmpresaData getEmpresaId(int id)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var resulta = from empresa in db.Empresa
where empresa.idEmpresa == id
select empresa;
foreach (Empresa em in resulta)
{
EmpresaData empData = new EmpresaData()
{
EmpresaID = em.idEmpresa,
cif = em.cif,
nombreComercial = em.nombreComercial,
razonSocial = em.razonSocial,
web = em.web,
sector = em.Sector.descripcion
};
return empData;
}
return null;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("EError SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
/// <summary>
/// Método que edita un usuario de un registro de la tabla Usuario
/// </summary>
/// <param name="id">Identificador del usuario a editar.</param>
/// <param name="correo">Objeto usuario que contiene los datos a modificar</param>
/// <returns>Devuelve true si se ha modificado el registro correctamente. False si no.</returns>
public int editUsuario(int idUsuario, UsuarioData user)
{
if (user == null) return -1;
if (idUsuario < 0) return -1;
if (user.login == "" || user.password == "") return -1;
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consulta = from usuario in db.Usuario
where usuario.idUsuario == idUsuario
select usuario;
Usuario u = consulta.First();
u.idUsuario = idUsuario;
u.login = user.login;
u.nombre = user.nombre;
u.password = PasswordManager.getMD5(user.password);
db.SaveChanges();
return u.idUsuario;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("ERROR SQL: " + ex.Message,
new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("ERROR: " + ex.Message,
new FaultCode("GENERAL"));
throw fault;
}
}
/// <summary>
/// Método que elimina un registro email de la tabla Email
/// </summary>
/// <param name="idEmail">identificador único de un registro email</param>
/// <returns>Devuelve true si se ha eliminado correctamente y false si no.</returns>
public bool deleteEmail(int idEmail)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consult = from correo in db.Email
where correo.idEmail == idEmail
select correo;
//si el objeto es nulo
if (idEmail == null) return false;
if (consult.ToList().Count == 0) return false; //si no devuelve ningun resultado.
Email email = consult.First();
db.Email.Remove(email);
db.SaveChanges();
}
return true;
}
catch (SqlException ex)
{
FaultException fault = new FaultException("EError SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
/// <summary>
/// Metodo que a partir de un objeto y un id elimina una direccion.
/// </summary>
/// <param name="street"></param>
/// <param name="id"></param>
/// <returns></returns>
public bool DeleteDireccion(int id)
{
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var resultado = from calle in db.Direccion
where (calle.idDireccion == id)
select calle;
foreach (var calle in resultado) // Un foreach que elimina la fila completa
{
db.Direccion.Remove(calle); // Borra el objeto
}
db.SaveChanges(); // Se guarda los campios realizados
return true;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("Error SQL: " + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
FaultException fault = new FaultException("Error: " + ex.Message, new FaultCode("General"));
throw fault;
}
}
/// <summary>
/// Método que consulta empresa por Sector
/// </summary>
/// <param name="idSector">Identificador del sector para buscar</param>
/// <returns></returns>
public List<EmpresaData> getEmpresaSector(int idSector)
{
List<EmpresaData> datos = new List<EmpresaData>();
try
{
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var resulta = from empresa in db.Empresa
where empresa.idSector == idSector
select empresa;
foreach (Empresa em in resulta)
{
EmpresaData emData = new EmpresaData()
{
cif = em.cif,
nombreComercial = em.nombreComercial,
razonSocial = em.razonSocial,
web = em.web,
sector = em.Sector.descripcion
};
datos.Add(emData);
}
return datos;
}
}
catch (SqlException ex)
{
FaultException fault = new FaultException("EError SQL" + ex.Message, new FaultCode("SQL"));
throw fault;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO LISTADO DE EMAILS"));
}
}
