/********************************************************************/
/*****************************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;
}
}
/// <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 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>
/// 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;
}
}
/********************************************************************/
/*******************************LUISMI*******************************/
/********************************************************************/
/***************************************************************
****Métodos tabla Email.
*AddEmail -- Añadir ,
*getAllEmail -- Devuelve todos los registros
*getEmail -- Devuelve un registro concreto de la tabla Email
*deleteEmail -- Elimina un registro de la tabla según su identificador
*editEmail -- Modificacion de un registro concreto
***************************************************************/
/// <summary>
/// /// Permite insertar un email que no exista en la base de datos. Como el Email está relacionado obligatoriamente con una empresa o un contacto uno de los dos parámetros será null.
/// </summary>
/// <param name="correo"></param>
/// <param name="empData"></param>
/// <param name="conData"></param>
/// <returns></returns>
public int addEmail(string correo, EmpresaData empData, ContactoData conData)
{
int indice = -1;
if (correo == "" || correo == null || empData == null && conData == null) return -1;
try
{
Email p = new Email();
p.correo = correo;
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
if (empData != null)
{
var datos = from empresas in db.Empresa
where empresas.idEmpresa == empData.EmpresaID
select empresas;
p.Empresa.Add(datos.First());
}
else
{
var datos = from contactos in db.Contacto
where contactos.idContacto == conData.idContacto
select contactos;
p.Contacto.Add(datos.First());
}
db.Email.Add(p);
db.SaveChanges();
indice = p.idEmail;
return indice;
}
}
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>
/// 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 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 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;
}
}
/***************************************************************
****************** 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;
}
}
/// <summary>
/// Permite insertar un teléfono que no 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">Teléfono a insertar.</param>
/// <param name="empData">Empresa a la que pertenece el teléfono a insertar.</param>
/// <param name="conData">Contacto al que pertenece el teléfono a insertar.</param>
/// <returns>True si se ha insertado.</returns>
public int AddTelefono(TelefonoData t, EmpresaData empData, ContactoData conData)
{
if (t == null) return -1;
if (empData == null && conData == null) return -1;
if (empData != null && conData != null) return -1;
try
{
int id;
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
Telefono telefono = new Telefono()
{
idTelefono = t.idTelefono,
numero = t.numero,
};
if (empData != null)
{
var datos = from empresas in bd.Empresa
where empresas.idEmpresa == empData.EmpresaID
select empresas;
telefono.Empresa.Add(datos.First());
}
else
{
var datos = from contactos in bd.Contacto
where contactos.idContacto == conData.idContacto
select contactos;
telefono.Contacto.Add(datos.First());
}
bd.Telefono.Add(telefono);
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;
}
}
/***************************************************************
*******************************FIN EMAIL************************
***************************************************************/
/// <summary>
/// Método que añade un nuevo registro en la tabla Empresa
/// </summary>
/// <param name="cif">Cif de la empresa a insertar</param>
/// <param name="nombreComercial">Nombre Comercial de la empresa a insertar</param>
/// <param name="razon">Razón Social de la empresa a insertar</param>
/// <param name="web">Página Web de la empresa a insertar</param>
/// <param name="sector">Identificador de sector de la empresa a insertar</param>
/// <returns>Devuelve True, si se ha insertado correctamente. Devuelve False si no.</returns>
public int addEmpresa(string cif, string nombreComercial, string razon, string web, int sector)
{
int indice = -1;
if (cif == "" || nombreComercial == "" || razon == "" || sector == -1) return -1;
try
{
Empresa emp = new Empresa();
emp.cif = cif;
emp.nombreComercial = nombreComercial;
emp.razonSocial = razon;
emp.web = web;
emp.idSector = sector;
using (GestionEmpresasEntities db = new GestionEmpresasEntities())
{
var consult = from sect in db.Sector
where sect.idSector == sector
select sect;
//si no existe el sector
if (consult.ToList().Count == 0) return -1;
db.Empresa.Add(emp);
db.SaveChanges();
indice = emp.idEmpresa;
}
return indice;
}
catch (Exception ex)
{
throw new FaultException(ex.Message, new FaultCode("ERROR SERVICIO AÑADIR EMAIL"));
}
}
/// <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>
/// 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>
/// 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>
/// 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>
/// 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 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"));
}
}
/// <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;
}
}
/***************************************************************
*******************************FIN EMAIL-CONTACTO********************
***************************************************************/
/********************************************************************/
/*******************************FIN LUISMI***************************/
/********************************************************************/
/********************************************************************/
/*******************************JORGE********************************/
/********************************************************************/
/***************************************************************
**************************** Direccion ************************
***************************************************************/
/// <summary>
/// Metodo que añade un objeto street de tipo DireccionData a la bd
/// </summary>
/// <param name="street"></param>
/// <returns></returns>
public int AddDireccion(DireccionData t, EmpresaData empData, ContactoData conData)
{
if (t == null) return -1;
if (empData == null && conData == null) return -1;
if (empData != null && conData != null) return -1;
try
{
using (GestionEmpresasEntities bd = new GestionEmpresasEntities())
{
Direccion nueva = new Direccion();
nueva.idDireccion = t.idDireccion;
nueva.domicilio = t.domicilio;
nueva.poblacion = t.poblacion;
nueva.provincia = t.provincia;
nueva.codPostal = t.codPostal;
if (empData != null)
{
var datos = from empresas in bd.Empresa
where empresas.idEmpresa == empData.EmpresaID
select empresas;
nueva.Empresa.Add(datos.First());
}
else
{
var datos = from contactos in bd.Contacto
where contactos.idContacto == conData.idContacto
select contactos;
nueva.Contacto.Add(datos.First());
}
bd.Direccion.Add(nueva);
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;
}
}