Ejemplo n.º 1
0
        /// <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);
            }
        }
Ejemplo n.º 2
0
        /// <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();
        }
Ejemplo n.º 4
0
    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();
    }
Ejemplo n.º 5
0
        /// <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);
            }
        }
Ejemplo n.º 6
0
        /// <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);
            }
        }
Ejemplo n.º 7
0
        /// <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);
            }
        }
Ejemplo n.º 8
0
        /// <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);
            }
        }
Ejemplo n.º 9
0
        /// <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);
            }
        }
Ejemplo n.º 10
0
        /// <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);
            }
        }
Ejemplo n.º 11
0
        /// <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);
            }
        }
Ejemplo n.º 12
0
        /// <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);
            }
        }
Ejemplo n.º 13
0
        /// <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);
            }
        }
Ejemplo n.º 14
0
        /// <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);
            }
        }
Ejemplo n.º 15
0
        /// <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);
            }
        }
Ejemplo n.º 16
0
        /// <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);
            }
        }
Ejemplo n.º 17
0
        /// <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);
            }
        }
Ejemplo n.º 18
0
        /// <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);
            }
        }
Ejemplo n.º 19
0
 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();
         }
     }
 }
Ejemplo n.º 20
0
        /// <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);
            }
        }
Ejemplo n.º 21
0
        /// <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);
            }
        }
Ejemplo n.º 22
0
    {/// <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>
Ejemplo n.º 23
0
        /// <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);
            }
        }
Ejemplo n.º 24
0
        /// <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);
            }
        }
Ejemplo n.º 25
0
        /// <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);
            }
        }
Ejemplo n.º 26
0
        /// <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);
            }
        }
Ejemplo n.º 27
0
        /// <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);
            }
        }
Ejemplo n.º 28
0
        /// <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);
            }
        }
Ejemplo n.º 29
0
        /// <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);
            }
        }