/// <summary>
/// Método para agregar una Hora en la BD
/// </summary>
/// <param name="horaEnt">Objeto de la clase HoraEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarHora(Entidad.HoraEnt horaEnt)
{
db_Entities db = new db_Entities();
try
{
hora hora = new hora
{
ape_cliente = horaEnt.ape_cliente,
cel_cliente = horaEnt.cel_cliente,
correo_cliente = horaEnt.correo_cliente,
fecha = horaEnt.fecha,
hora_tomada = horaEnt.hora_tomada,
id_hora = horaEnt.id_hora,
id_local = horaEnt.id_local,
id_servicio = horaEnt.id_servicio,
nom_cliente = horaEnt.nom_cliente,
rut_cliente = horaEnt.rut_cliente
};
db.Hora.Add(hora);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para modificar un objeto de tipo Hora
/// </summary>
/// <param name="horaEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo hora o un nulo en caso de exception</returns>
public Entidad.HoraEnt ModificarHora(Entidad.HoraEnt horaEnt)
{
db_Entities db = new db_Entities();
try
{
hora hora = db.Hora.FirstOrDefault(h => h.id_hora == horaEnt.id_hora);
hora.ape_cliente = horaEnt.ape_cliente;
hora.cel_cliente = horaEnt.cel_cliente;
hora.correo_cliente = horaEnt.correo_cliente;
hora.fecha = horaEnt.fecha;
hora.hora_tomada = horaEnt.hora_tomada;
hora.id_hora = horaEnt.id_hora;
hora.id_local = horaEnt.id_local;
hora.id_servicio = horaEnt.id_servicio;
hora.nom_cliente = horaEnt.nom_cliente;
hora.rut_cliente = horaEnt.rut_cliente;
db.SaveChanges();
return(BuscarHora(hora.id_hora));
}
catch (Exception)
{
return(null);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
Product product = new Product();
product.Description = txtDescription.Text;
product.Price = decimal.Parse(txtPrice.Text);
product.Image = byteBLOBData;
/*this is the line in question*/
product.ProductType = (int)(comboCatagory.SelectedValue);
db.Products.Add(product);
db.SaveChanges();
}
protected void BtnGuardar_Click(object sender, EventArgs e)
{
Parametro par = new Parametro();
par.Nombre = TxtNombre.Text;
par.Valor = TxtValor.Text;
db_Entities context = new db_Entities();
context.Parametros.Add(par);
context.SaveChanges();
TxtNombre.Text = "";
TxtValor.Text = "";
LblMensajes.Text = "Dato guardado";
cargarDatos();
}
/// <summary>
/// Método para eliminar una comuna de la BD
/// </summary>
/// <param name="id_comuna">por medio del id se buscará y eliminará la comuna</param>
/// <returns>si se elimina una comuna enviara un verdadero, si no mandará un falso</returns>
public bool EliminarComuna(int id_comuna)
{
db_Entities db = new db_Entities();
try
{
comuna comunaRes = db.Comuna.FirstOrDefault(c => c.id_comuna == id_comuna);
db.Comuna.Remove(comunaRes);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar una region
/// </summary>
/// <param name="id_region">por medio del id se buscará y eliminará la region</param>
/// <returns>si se elimina una hora enviara un verdadero, si no mandará un falso</returns>
public bool EliminarRegion(int id_region)
{
db_Entities db = new db_Entities();
try
{
region region = db.Region.FirstOrDefault(r => r.id_region == id_region);
db.Region.Remove(region);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar una empresa
/// </summary>
/// <param name="id_empresa">por medio del id se buscará y eliminará la empresa</param>
/// <returns>si se elimina una empresa enviara un verdadero, si no mandará un falso</returns>
public bool EliminarEmpesa(int id_empresa)
{
db_Entities db = new db_Entities();
try
{
empresa empresaRes = db.Empresa.FirstOrDefault(e => e.id_empresa == id_empresa);
db.Empresa.Remove(empresaRes);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar un usuario
/// </summary>
/// <param name="id_usuario">por medio del id se buscará y eliminará el usuario</param>
/// <returns>si se elimina un usuario enviara un verdadero, si no mandará un falso</returns>
public bool EliminarUsuario(int id_usuario)
{
db_Entities db = new db_Entities();
try
{
usuario usuario = db.Usuario.FirstOrDefault(u => u.id_usuario == id_usuario);
db.Usuario.Remove(usuario);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar una Hora
/// </summary>
/// <param name="id_hora">por medio del id se buscará y eliminará la hora</param>
/// <returns>si se elimina una hora enviara un verdadero, si no mandará un falso</returns>
public bool EliminarHora(int id_hora)
{
db_Entities db = new db_Entities();
try
{
hora hora = db.Hora.FirstOrDefault(h => h.id_hora == id_hora);
db.Hora.Remove(hora);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar una especialidad
/// </summary>
/// <param name="id_especialidad">por medio del id se buscará y eliminará la especialidad</param>
/// <returns>si se elimina una especialidad enviara un verdadero, si no mandará un falso</returns>
public bool EliminarEspecialidad(int id_especialidad)
{
db_Entities db = new db_Entities();
try
{
especialidad especialidad = db.Especialidad.FirstOrDefault(e => e.id_especialidad == id_especialidad);
db.Especialidad.Remove(especialidad);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar un local
/// </summary>
/// <param name="id_local">por medio del id se buscará y eliminará el local</param>
/// <returns>si se elimina un local enviara un verdadero, si no mandará un falso</returns>
public bool EliminarLocal(int id_local)
{
db_Entities db = new db_Entities();
try
{
local local = db.Local.FirstOrDefault(l => l.id_local == id_local);
db.Local.Remove(local);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar un servicio
/// </summary>
/// <param name="id_servicio">por medio del id se buscará y eliminará el servicio</param>
/// <returns>si se elimina un servicio enviara un verdadero, si no mandará un falso</returns>
public bool EliminarServicio(int id_servicio)
{
db_Entities db = new db_Entities();
try
{
servicio servicio = db.Servicio.FirstOrDefault(s => s.id_servicio == id_servicio);
db.Servicio.Remove(servicio);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para eliminar un localServ
/// </summary>
/// <param name="id_local">por medio del id se buscará y eliminará el local</param>
/// <param name="id_servicio">por medio del id se buscará y eliminará el local</param>
/// <returns>si se elimina un localServ enviara un verdadero, si no mandará un falso</returns>
public bool EliminarLocal_Serv(int id_local, int id_servicio)
{
db_Entities db = new db_Entities();
try
{
local_serv localserv = db.Local_serv.FirstOrDefault(l => (l.id_local == id_local) && (l.id_servicio == id_servicio));
db.Local_serv.Remove(localserv);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para agregar una Region en la BD
/// </summary>
/// <param name="regionEnt">Objeto de la clase RegionEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarRegion(Entidad.RegionEnt regionEnt)
{
db_Entities db = new db_Entities();
try
{
region region = new region
{
id_region = regionEnt.id_region,
nombre_region = regionEnt.nombre_region
};
db.Region.Add(region);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para modificar un objeto de tipo region
/// </summary>
/// <param name="regionEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo region o un nulo en caso de exception</returns>
public Entidad.RegionEnt ModificarRegion(Entidad.RegionEnt regionEnt)
{
db_Entities db = new db_Entities();
try
{
region region = db.Region.FirstOrDefault(r => r.id_region == regionEnt.id_region);
region.id_region = regionEnt.id_region;
region.nombre_region = regionEnt.nombre_region;
db.SaveChanges();
return(BuscarRegion(region.id_region));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para agregar una LocalServ en la BD
/// </summary>
/// <param name="localservEnt">Objeto de la clase LocalServEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarLocalServ(Entidad.LocalServEnt localservEnt)
{
db_Entities db = new db_Entities();
try
{
local_serv localserv = new local_serv
{
id_local = localservEnt.id_local,
id_servicio = localservEnt.id_servicio
};
db.Local_serv.Add(localserv);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para modificar un objeto de tipo Especialidad
/// </summary>
/// <param name="especialidadEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo especialidad o un nulo en caso de exception</returns>
public Entidad.EspecialidadEnt ModificarEspecialidad(Entidad.EspecialidadEnt especialidadEnt)
{
db_Entities db = new db_Entities();
try
{
especialidad especialidad = db.Especialidad.FirstOrDefault(e => e.id_especialidad == especialidadEnt.id_especialidad);
especialidad.id_especialidad = especialidadEnt.id_especialidad;
especialidad.nom_especialidad = especialidadEnt.nom_especialidad;
db.SaveChanges();
return(BuscarEspecialidad(especialidad.id_especialidad));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para agregar una Especialidad en la BD
/// </summary>
/// <param name="especialidadEnt">Objeto de la clase EspecialidadEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarEspecialidad(Entidad.EspecialidadEnt especialidadEnt)
{
db_Entities db = new db_Entities();
try
{
especialidad especialidad = new especialidad
{
id_especialidad = especialidadEnt.id_especialidad,
nom_especialidad = especialidadEnt.nom_especialidad
};
db.Especialidad.Add(especialidad);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public void AddUser(string username, string password)
{
lock (syncRootAddUser)
{
var user = databaseCachedUsers.Where(u => u.user_name == username).FirstOrDefault();
if (user == null)
{
user = new User()
{
user_name = username
};
string hashedPassword = passwordManager.EncryptPassword(password);
string salt = passwordManager.GenerateSalt();
user.hash = passwordManager.EncryptPassword(hashedPassword, salt);
user.salt = salt;
context.User.Add(user);
context.SaveChanges();
databaseCachedUsers = context.User.ToList();
}
}
}
/// <summary>
/// Método para modificar un objeto de tipo Empresa
/// </summary>
/// <param name="empresaEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo empresa o un nulo en caso de exception</returns>
public Entidad.EmpresaEnt ModificarEmpresa(Entidad.EmpresaEnt empresaEnt)
{
db_Entities db = new db_Entities();
try
{
empresa empresaRes = db.Empresa.FirstOrDefault(e => e.id_empresa == empresaEnt.id_empresa);
empresaRes.id_empresa = empresaEnt.id_empresa;
empresaRes.nom_empresa = empresaEnt.nom_empresa;
empresaRes.rut_empresa = empresaEnt.rut_empresa;
db.SaveChanges();
return(BuscarEmpresa(empresaRes.id_empresa));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para agregar una empresa en la BD
/// </summary>
/// <param name="empresaEnt">Objeto de la clase EmpresaEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarEmpresa(Entidad.EmpresaEnt empresaEnt)
{
db_Entities db = new db_Entities();
try
{
empresa empresa = new empresa
{
id_empresa = empresaEnt.id_empresa,
nom_empresa = empresaEnt.nom_empresa,
rut_empresa = empresaEnt.rut_empresa
};
db.Empresa.Add(empresa);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
{/// <summary>
/// Metodo de Dal para agregar comuna a la BD
/// </summary>
/// <param name="comunaEnt">objeto de la clase ComunaEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception</returns>
public bool AgregarComuna(Entidad.ComunaEnt comunaEnt)
{
db_Entities db = new db_Entities();
try
{
comuna comuna = new comuna
{
id_comuna = comunaEnt.id_comuna,
id_region = comunaEnt.id_region,
nombre_comuna = comunaEnt.nombre_comuna
};
db.Comuna.Add(comuna);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}/// <summary>
/// <summary>
/// Metodo para Modificar un objeto de la clase ComunaEnt
/// </summary>
/// <param name="comunaEnt">objeto llamado de la clase ComunaEnt</param>
/// <returns>retorna el id de la comuna ingresada</returns>
public Entidad.ComunaEnt ModificarComuna(Entidad.ComunaEnt comunaEnt)
{
db_Entities db = new db_Entities();
try
{
comuna comunaRes = db.Comuna.FirstOrDefault(c => c.id_comuna == comunaEnt.id_comuna);
comunaRes.id_comuna = comunaEnt.id_comuna;
comunaRes.id_region = comunaEnt.id_region;
comunaRes.nombre_comuna = comunaEnt.nombre_comuna;
db.SaveChanges();
return(BuscarComuna(comunaRes.id_comuna));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para modificar un objeto de tipo local
/// </summary>
/// <param name="localEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo local o un nulo en caso de exception</returns>
public Entidad.LocalEnt ModificarLocal(Entidad.LocalEnt localEnt)
{
db_Entities db = new db_Entities();
try
{
local local = db.Local.FirstOrDefault(l => l.id_local == localEnt.id_local);
local.id_local = localEnt.id_local;
local.dir_local = localEnt.dir_local;
local.id_comuna = localEnt.id_comuna;
local.id_empresa = localEnt.id_empresa;
db.SaveChanges();
return(BuscarLocal(local.id_local));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para agregar una Local en la BD
/// </summary>
/// <param name="localEnt">Objeto de la clase LocalEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarLocal(Entidad.LocalEnt localEnt)
{
db_Entities db = new db_Entities();
try
{
local local = new local
{
id_local = localEnt.id_local,
dir_local = localEnt.dir_local,
id_comuna = localEnt.id_comuna,
id_empresa = localEnt.id_empresa
};
db.Local.Add(local);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para modificar un objeto de tipo region
/// </summary>
/// <param name="servicioEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo servicio o un nulo en caso de exception</returns>
public Entidad.ServicioEnt ModificarServicio(Entidad.ServicioEnt servicioEnt)
{
db_Entities db = new db_Entities();
try
{
servicio servicio = db.Servicio.FirstOrDefault(s => s.id_servicio == servicioEnt.id_servicio);
servicio.id_servicio = servicioEnt.id_servicio;
servicio.nom_servicio = servicioEnt.nom_servicio;
servicio.desc_servicio = servicioEnt.desc_servicio;
servicio.id_especialidad = servicioEnt.id_especialidad;
db.SaveChanges();
return(BuscarServicio(servicio.id_servicio));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Método para agregar una Region en la BD
/// </summary>
/// <param name="servicioEnt">Objeto de la clase servicioEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarServicio(Entidad.ServicioEnt servicioEnt)
{
db_Entities db = new db_Entities();
try
{
servicio servicio = new servicio
{
id_servicio = servicioEnt.id_servicio,
nom_servicio = servicioEnt.nom_servicio,
desc_servicio = servicioEnt.desc_servicio,
id_especialidad = servicioEnt.id_especialidad
};
db.Servicio.Add(servicio);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para agregar una Usuario en la BD
/// </summary>
/// <param name="usuarioEnt">Objeto de la clase usuarioEnt</param>
/// <returns>retorna un verdadero o un falso en caso de exception para guardar el obj en la BD</returns>
public bool AgregarUsuario(Entidad.UsuarioEnt usuarioEnt)
{
db_Entities db = new db_Entities();
try
{
usuario usuario = new usuario
{
id_usuario = usuarioEnt.id_usuario,
nom_usuario = usuarioEnt.nom_usuario,
con_usuario = usuarioEnt.con_usuario,
tipo_usuario = usuarioEnt.tipo_usuario,
id_empresa = usuarioEnt.id_empresa
};
db.Usuario.Add(usuario);
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Método para modificar un objeto de tipo usuario
/// </summary>
/// <param name="usuarioEnt">obj que trae de la BD</param>
/// <returns>retorna un obj de tipo usuario o un nulo en caso de exception</returns>
public Entidad.UsuarioEnt ModificarUsuario(Entidad.UsuarioEnt usuarioEnt)
{
db_Entities db = new db_Entities();
try
{
usuario usuario = db.Usuario.FirstOrDefault(u => u.id_usuario == usuarioEnt.id_usuario);
usuario.id_usuario = usuarioEnt.id_usuario;
usuario.nom_usuario = usuarioEnt.nom_usuario;
usuario.con_usuario = usuarioEnt.con_usuario;
usuario.tipo_usuario = usuarioEnt.tipo_usuario;
usuario.id_empresa = usuarioEnt.id_empresa;
db.SaveChanges();
return(BuscarUsuario(usuario.id_usuario));
}
catch (Exception)
{
return(null);
}
}