Example #1
0
        public IHttpActionResult PutProtocoloDetalleImpresion(ProtocoloDetalleImpresion protocoloDetalleImpresion)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }


            if (protocoloDetalleImpresion.ultimoUsr == null || protocoloDetalleImpresion.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            protocoloDetalleImpresion.ultimaFec       = DateTime.Now;
            db.Entry(protocoloDetalleImpresion).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ProtocoloDetalleImpresionExists(protocoloDetalleImpresion.idProtocoloDetImpresion))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(protocoloDetalleImpresion));
        }
        public IHttpActionResult PutSEC_TipoUsuario(SEC_TipoUsuario sEC_TipoUsuario)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            sEC_TipoUsuario.ultimaFecha     = DateTime.Now;
            db.Entry(sEC_TipoUsuario).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SEC_TipoUsuarioExists(sEC_TipoUsuario.idTipoUsuario))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok());
        }
        public IHttpActionResult PutLargoSinFuelles(LargoSinFuelles largoSinFuelles)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (largoSinFuelles.ultimoUsr == null || largoSinFuelles.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            largoSinFuelles.ultimaFec = DateTime.Now;

            db.Entry(largoSinFuelles).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LargoSinFuellesExists(largoSinFuelles.idLargoSinFuelles))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(largoSinFuelles));
        }
        public IHttpActionResult PutSEC_PermisoConTipoUsuario(SEC_PermisoConTipoUsuario sEC_PermisoConTipoUsuario)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }


            db.Entry(sEC_PermisoConTipoUsuario).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SEC_PermisoConTipoUsuarioExists(sEC_PermisoConTipoUsuario.idPermisoConTipoUsuario))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Example #5
0
        public IHttpActionResult PutTipoTermoencogible(TipoTermoencogible tipoTermoencogible)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (tipoTermoencogible.ultimoUsr == null || tipoTermoencogible.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            tipoTermoencogible.ultimaFec = DateTime.Now;

            db.Entry(tipoTermoencogible).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TipoTermoencogibleExists(tipoTermoencogible.idTipoTermoE))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(tipoTermoencogible));
        }
Example #6
0
        public IHttpActionResult PutMaterial(Material material)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (material.ultimoUsr == null || material.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            material.ultimaFec = DateTime.Now;

            db.Entry(material).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!MaterialExists(material.idMaterial))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(material));
        }
        public IHttpActionResult PutEspecificacionImpresion(EspecificacionImpresion especificacionImpresion)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (especificacionImpresion.ultimoUsr == null || especificacionImpresion.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            especificacionImpresion.ultimaFec       = DateTime.Now;
            db.Entry(especificacionImpresion).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!EspecificacionImpresionExists(especificacionImpresion.idEspecificacionImpresion))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(especificacionImpresion));
        }
Example #8
0
        public IHttpActionResult PutCalibre2Caras(Calibre2Caras calibre2Caras)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (calibre2Caras.ultimoUsr == null || calibre2Caras.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            calibre2Caras.ultimaFec = DateTime.Now;

            db.Entry(calibre2Caras).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!Calibre2CarasExists(calibre2Caras.idCalibre2Caras))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(calibre2Caras));
        }
        public IHttpActionResult PutTratadoCorona(TratadoCorona tratadoCorona)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (tratadoCorona.ultimoUsr == null || tratadoCorona.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            tratadoCorona.ultimaFec = DateTime.Now;

            db.Entry(tratadoCorona).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TratadoCoronaExists(tratadoCorona.idTratadoCorona))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }
            return(Ok(tratadoCorona));
        }
Example #10
0
        public IHttpActionResult PutUnidadMedida(UnidadMedida unidadMedida)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            if (unidadMedida.ultimoUsr == null || unidadMedida.ultimoUsr == 0)
            {
                return(BadRequest("no hay usuario para guardar"));
            }
            unidadMedida.ultimaFec = DateTime.Now;

            db.Entry(unidadMedida).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UnidadMedidaExists(unidadMedida.idUnidadMedida))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(Ok(unidadMedida));
        }