public JsonResult Editar(int id, string campo, string valor)
{
Curso curso = dbCurso.FindOne(cur => cur.idCurso == id);
try
{
switch (campo)
{
case "descricao":
curso.descricao = valor;
break;
case "nome":
curso.nome = valor;
break;
case "status":
curso.status = Convert.ToInt32(valor);
break;
case "valor":
curso.valor = Convert.ToDecimal(valor);
break;
}
dbCurso.Atualizar(curso);
dbCurso.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public T Atualizar(T obj)
{
if (!ExisteRegistro(obj))
{
throw new RegistroNaoEncontradoException();
}
return(_repositorio.Atualizar(obj));
}
public ValidationResult Atualizar(TEntity entity, IDbTransaction transaction = null,
int?commandTimeout = default(int?))
{
if (!ValidationResult.IsValid)
{
return(ValidationResult);
}
var selfValidationEntity = entity as ISelfValidation;
if (selfValidationEntity != null && !selfValidationEntity.IsValid)
{
return(selfValidationEntity.ValidationResult);
}
var atualizar = _repositorio.Atualizar(entity);
if (!atualizar)
{
_validationResult.Add(
new ValidationError(
"A Entidade que você está tentando atualizar está nula, por favor tente novamente! Nome: " +
entity));
}
return(_validationResult);
}
public JsonResult Editar(int id, string campo, string valor)
{
Taxa taxa = dbTaxa.FindOne(cur => cur.idTaxa == id);
try
{
switch (campo)
{
case "descricao":
taxa.descricao = valor;
break;
case "nome":
taxa.nome = valor;
break;
case "valor":
taxa.valor = Convert.ToInt32(valor);
break;
}
dbTaxa.Atualizar(taxa);
dbTaxa.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public JsonResult Editar(int id, string campo, string valor)
{
Cargo cargo = dbCargo.FindOne(car => car.idCargo == id);
try
{
switch (campo)
{
case "descricao":
cargo.descricao = valor;
break;
case "nome":
cargo.nome = valor;
break;
}
dbCargo.Atualizar(cargo);
dbCargo.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> put(int disciplinaId, Disciplina model)
{
try
{
var disciplina = await _repositorioDisciplina.ObterPeloIdAsync(disciplinaId);
if (disciplina == null)
{
return(NotFound());
}
_repositorio.Atualizar(model);
if (await _repositorio.EfetuouAlteracoesAsync())
{
return(Ok(model));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex.Message}"));
}
return(BadRequest());
}
public async Task <IActionResult> put(int alunoId, Aluno aluno)
{
try
{
var alunoCadastrado = await _repositorioAluno.ObterAlunoByIdAsync(alunoId, incluirProfessor : false);
if (alunoCadastrado == null)
{
return(NotFound());
}
_repositorio.Atualizar(aluno);
if (await _repositorio.EfetuouAlteracoesAsync())
{
return(Ok(aluno));
}
}
catch (Exception ex)
{
return(BadRequest($"Ao salvar o aluno ocorreu um erro {ex.Message}"));
}
return(BadRequest());
}
public async Task <IActionResult> put(int professorId, Professor model)
{
try
{
var Professor = await _repositorioProfessor.ObterProfessorPeloIdAsync(professorId, false);
if (Professor == null)
{
return(NotFound());
}
_repositorio.Atualizar(model);
if (await _repositorio.EfetuouAlteracoesAsync())
{
return(Ok(model));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex.Message}"));
}
return(BadRequest());
}
public async Task <IActionResult> Put(int disciplinaId, Disciplina model)
{
try
{
var disciplina = await _repositorioDisciplina.ObterDisciplinaPeloIdAsync(disciplinaId, incluirProfessor : false);
if (disciplina == null)
{
return(NotFound());
}
_repositorio.Atualizar(model);
if (await _repositorio.EfetuouAlteracoesAsync())
{
return(Ok(model));
}
}
catch (Exception ex)
{
return(BadRequest($"Ao editar a disciplina, ocorreu o erro: {ex.Message}"));
}
return(BadRequest());
}
public JsonResult Editar(int id, string campo, string valor)
{
Modulo modulo = dbModulo.FindOne(mod => mod.idModulo == id);
try
{
switch (campo)
{
case "nome":
modulo.nome = valor;
break;
case "tempoDuracao":
modulo.tempoDuracao = Convert.ToInt32(valor);
break;
case "Curso.nome":
modulo.idCurso = Convert.ToInt32(valor);
break;
}
dbModulo.Atualizar(modulo);
dbModulo.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public async Task <CurriculoDisciplina> Atualizar(CurriculoDisciplina entidade)
{
var preRequisitos = await AtualizarPreRequisitos(entidade.Codigo, entidade.CurriculoDisciplinaPreRequisito.ToList());
entidade.CurriculoDisciplinaPreRequisito = null;
entidade = await _repositorio.Atualizar(entidade);
return(entidade);
}
public void AtualizarVisitaMorador(VisitaMorador visitaMorador)
{
var visitaMoradorAtual = repositorioVisitaMorador.Consultar(visitaMorador.Identificador);
visitaMoradorAtual.Entrada = visitaMorador.Entrada;
visitaMoradorAtual.Saida = visitaMorador.Saida;
repositorioVisitaMorador.Atualizar(visitaMoradorAtual);
}
public void Update(Produto produto)
{
try
{
produto.valida();
_produtoRepositorio.Atualizar(produto);
}catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Update(Venda Venda)
{
try
{
Venda.valida();
_vendaRepositorio.Atualizar(Venda);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Salvar(TEntity obj)
{
if (obj.ID > 0)
{
_repo.Atualizar(obj);
}
else
{
_repo.Adicionar(obj);
}
_repo.SalvarModificacoes();
}
public void AtualizarVisitante(Visitante visitante)
{
var visitanteAtual = repositorioVisitante.Consultar(visitante.Identificador);
visitanteAtual.Nome = visitante.Nome;
visitanteAtual.Identidade = visitante.Identidade;
visitanteAtual.Sexo = visitante.Sexo;
visitanteAtual.Foto = visitante.Foto;
visitanteAtual.Estado = visitante.Estado;
visitanteAtual.DataNascimento = visitante.DataNascimento;
repositorioVisitante.Atualizar(visitanteAtual);
}
public JsonResult Editar(int id, string campo, string valor)
{
Endereco endereco = dbEndereco.FindOne(end => end.idEndereco == id);
try
{
switch (campo)
{
case "TipoEndereco.nome":
endereco.idTipoEndereco = Convert.ToInt32(valor);
break;
case "logradouro":
endereco.logradouro = valor;
break;
case "numero":
endereco.numero = Convert.ToInt32(valor);
break;
case "complemento":
endereco.complemento = valor;
break;
case "CEP":
endereco.CEP = valor;
break;
case "bairro":
endereco.bairro = valor;
break;
case "cidade":
endereco.cidade = valor;
break;
case "uf":
endereco.uf = valor;
break;
}
dbEndereco.Atualizar(endereco);
dbEndereco.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public IActionResult Put([FromBody] Categoria entidade)
{
if (entidade == null || !entidade.EstaValidoParaAtualizacao)
{
return(BadRequest());
}
if (!_repositorio.Categorias.ConstaNoBanco(entidade.Id))
{
return(NotFound());
}
_repositorio.Atualizar(entidade);
return(NoContent());
}
public IActionResult Put([FromBody] Cliente cliente)
{
if (!cliente.EstaValidoParaAtualizacao())
{
return(BadRequest(cliente.Notifications));
}
if (!_repositorio.Clientes.ConstaNoBanco(cliente.Id))
{
return(NotFound());
}
_repositorio.Atualizar(cliente);
return(NoContent());
}
public IActionResult Put([FromBody] Produto produto)
{
if (!produto.EstaValidoParaAtualizacao())
{
return(BadRequest(produto.Notifications));
}
if (!_repositorio.Produtos.ConstaNoBanco(produto.Id))
{
return(NotFound());
}
_repositorio.Atualizar(produto);
return(NoContent());
}
public IActionResult Put([FromBody] Periodo periodo)
{
if (periodo == null || !periodo.EstaValidoParaAtualizacao)
{
return(BadRequest());
}
if (!_repositorio.Periodos.ConstaNoBanco(periodo.Id))
{
return(NotFound());
}
_repositorio.Atualizar(periodo);
return(NoContent());
}
public ValidationResult Atualizar(TEntity entity, IDbTransaction transaction = null, int?commandTimeout = default(int?))
{
if (!ValidationResult.IsValid)
{
return(ValidationResult);
}
var selfValidationEntity = entity as ISelfValidation;
if (selfValidationEntity != null && !selfValidationEntity.IsValid)
{
return(selfValidationEntity.ValidationResult);
}
_repositorio.Atualizar(entity, transaction);
return(_validationResult);
}
public IActionResult Atualizar([FromBody] FilmeDTO filmeDTO)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.FromModelState(ModelState)));
}
Filme filme = _mapper.Map <Filme>(filmeDTO);
_repositorio.Atualizar(filme);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ErrorResponse.From(ex)));
}
}
public bool Atualizar(TEntity entity, IDbTransaction transaction)
{
_validationResult.Clear();
if (!entity.EhValido())
{
_validationResult.Add(entity.Validation);
return(false);
}
var atualizar = _repositorio.Atualizar(entity, transaction);
if (!atualizar)
{
_validationResult.Add("A Entidade que você está tentando atualizar está nula, por favor tente novamente! Nome: " + entity + "Atualizar");
}
return(atualizar);;
}
public JsonResult Editar(int id, string campo, string valor)
{
Funcionario funcionario = dbFuncionario.FindOne(fun => fun.idFuncionario == id);
try
{
switch (campo)
{
case "Cargo.nome":
funcionario.idCargo = Convert.ToInt32(valor);
break;
case "Pessoa.nome":
funcionario.idPessoa = Convert.ToInt32(valor);
break;
case "Usuario.login":
Usuario usuario = dbUsuario.FindOne(usu => usu.idUsuario == funcionario.idUsuario);
usuario.login = valor;
funcionario.Usuario = usuario;
break;
case "salario":
funcionario.salario = Convert.ToInt32(valor);
break;
}
dbFuncionario.Atualizar(funcionario);
dbFuncionario.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }, JsonRequestBehavior.AllowGet));
}
}
public Livro EditarLivro(Livro livro)
{
if (livro == null)
{
throw new DominioExcecao("Livro não pode ser vazio.");
}
Livro novoLivro = BuscarLivroPorId(livro.Id);
novoLivro.DataAtualizacao = DateTime.Now;
novoLivro.Ano = livro.Ano;
novoLivro.Autor = livro.Autor;
novoLivro.Editora = livro.Editora;
novoLivro.Titulo = livro.Titulo;
var livroAtualizado = _repositorio.Atualizar(novoLivro);
_repositorio.SalvarAlteracoes();
return(livroAtualizado);
}
public IActionResult Put([FromBody] Folha folha)
{
if (folha == null)
{
return(BadRequest());
}
if (!folha.EstaValidoParaAtualizacao)
{
return(BadRequest());
}
if (!_repositorio.Folhas.ConstaNoBanco(folha.Id))
{
return(NotFound());
}
_repositorio.Atualizar(folha);
return(NoContent());
}
public IActionResult Put([FromBody] Contrato contrato)
{
if (contrato == null)
{
return(BadRequest());
}
if (!contrato.EstaValidoParaAtualizacao)
{
return(BadRequest());
}
if (!_repositorio.Contratos.ConstaNoBanco(contrato.Id))
{
return(NotFound());
}
_repositorio.Atualizar(contrato);
return(NoContent());
}
public async Task <IActionResult> Put(int professorId, Professor professor)
{
try
{
var professorCadastrado = await _repositorioProfessor.ObterProfessorPeloIdAsync(professorId, incluirAluno : false);
if (professorCadastrado == null)
{
return(NotFound());
}
_repositorio.Atualizar(professor);
if (await _repositorio.EfetuouAlteracoesAsync())
{
return(Ok(professor));
}
}
catch (Exception ex)
{
return(BadRequest($"Ao atualizar o professor, ocorreu o erro: {ex.Message}"));
}
return(BadRequest());
}
public async Task <IActionResult> Put(int itemId, Item item)
{
try
{
var itemCadastrado = await _repositorioItem.ObterPeloId(itemId);
if (itemCadastrado == null)
{
return(NotFound());
}
_repositorio.Atualizar(item);
if (await _repositorio.EfetuouAlteracoesAssincronas())
{
return(Ok(item));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro ao tentar atualizar {ex.Message}"));
}
return(BadRequest());
}