public int Criar(CidadeDto model)
{
if (model.Id > 0)
{
return(0);
}
var nomeDuplicado = DbContext.Cidades.Any(x => x.Ativo && (x.Nome.ToUpper() == model.Nome.ToUpper() && x.Uf.ToUpper() == model.Uf.ToUpper()) && x.Id != model.Id);
if (nomeDuplicado)
{
return(0);
}
try
{
var entity = new Cidade()
{
Nome = model.Nome,
Uf = model.Uf,
Ativo = model.Ativo
};
DbContext.Cidades.Add(entity);
DbContext.SaveChanges();
return(entity.Id);
}
catch (System.Exception ex)
{
}
return(0);
}
public int Alterar(CidadeDto model)
{
if (model.Id <= 0)
{
return(0);
}
var entity = DbContext.Cidades.Find(model.Id);
if (entity == null)
{
return(0);
}
try
{
entity.Nome = model.Nome;
entity.Uf = model.Uf;
entity.Ativo = model.Ativo;
DbContext.Cidades.Update(entity);
DbContext.SaveChanges();
return(entity.Id);
}
catch (System.Exception ex)
{
}
return(0);
}
public async Task <OkObjectResult> Put([FromBody] CidadeDto cidadeDto)
{
var resultado = new Retorno <CidadeDto>();
if (cidadeDto == null || !cidadeDto.Id.HasValue)
{
resultado.Mensagens.Add(new MensagemSistemaDto()
{
Titulo = "Alteração", Mensagem = string.Format(" Não foi possível efeturar a alteração!")
});
resultado.Status = ResultadoOperacao.Falha;
return(Ok(resultado));
}
Cidade cidade = await _cidadeService.AlterarAsync(cidadeDto.ToTransferObject());
if (cidade.Id == 0)
{
resultado.Mensagens.Add(new MensagemSistemaDto()
{
Titulo = "Inclusão", Mensagem = string.Format(" Já existe um usuário cadastrado com esse login: {0}", cidade.Descricao)
});
resultado.Status = ResultadoOperacao.Falha;
return(Ok(resultado));
}
resultado.Objeto = new CidadeDto(cidade);
resultado.Status = ResultadoOperacao.Sucesso;
return(Ok(resultado));
}
public async Task <IActionResult> Create()
{
CidadeDto cidade = new CidadeDto();
cidade.estados = await _estadoBll.GetList();
return(View(cidade));
}
public ActionResult SalvarCidade([FromBody] CidadeDto dto)
{
var Cidade = new Cidade(dto.Nome, dto.Estado, dto.Populacao, dto.Latitude, dto.Longitude, 0);
_cidadesCollection.InsertOne(Cidade);
return(StatusCode(201, "Cidade adicionada com sucesso"));
}
internal static Cidade ToEntity(this CidadeDto re)
{
return(new Cidade()
{
Descricao = re.Descricao,
Situacao = (SituacaoEnum)Convert.ToInt32(re.Situacao)
});
}
public IActionResult Edit([Bind] CidadeDto dto)
{
if (ModelState.IsValid)
{
_baseBll.Edit(dto);
return(Ok());
}
return(Ok());
}
public async Task <IActionResult> CriarCidade([FromBody] CidadeDto cidadeDto)
{
Cidade cidades = new Cidade(cidadeDto.Nome);
_dataContext.Add(cidades);
await _dataContext.SaveChangesAsync();
return(Ok(cidades));
}
internal static CidadeTo ToTransferObject(this CidadeDto re)
{
return(new CidadeTo()
{
Id = re.Id,
Descricao = re.Descricao,
Situacao = re.Situacao
});
}
public IActionResult Create([Bind] CidadeDto dto)
{
if (ModelState.IsValid)
{
_baseBll.Insert(dto);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult Create(CidadeDto cidade)
{
try
{
var cliente = new CidadeClient();
cliente.Criar(cidade);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, CidadeDto cidade)
{
try
{
var cidadeCliente = new CidadeClient();
cidadeCliente.Atualizar(cidade);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public ActionResult Delete(int id, CidadeDto cidade)
{
try
{
var cidadeCliente = new CidadeClient();
cidadeCliente.Apagar(id);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Delete(CidadeDto dto)
{
var result = new HttpResult <CidadeDto>(this._logger, this._service);
try
{
await this._service.Remove(dto);
return(result.ReturnCustomResponse(dto));
}
catch (Exception ex)
{
return(result.ReturnCustomException(ex, "Cidade", dto));
}
}
public bool Atualizar(CidadeDto cidade)
{
try
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(CaminhoApi);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.PutAsJsonAsync("cidades/" + cidade.Id, cidade).Result;
return(response.IsSuccessStatusCode);
}
catch
{
return(false);
}
}
public async Task <CidadeDto> Atualizar(CidadeDto cidadeDto)
{
var cidade = _mapper.Map <Cidade>(cidadeDto);
if (cidadeDto.FronteirasIds != null)
{
cidade.AlterarFronteiras(JsonConvert.SerializeObject(cidadeDto.FronteirasIds));
}
cidade = _cidadeRepository.Atualizar(cidade);
await _cidadeRepository.SaveChangesAsync();
return(_mapper.Map <CidadeDto>(cidade));
}
public async Task <CidadeDto> Armazenar(CidadeDto cidadeDto)
{
var cidade = _mapper.Map <Cidade>(cidadeDto);
if (cidadeDto.FronteirasIds != null)
{
cidade.AlterarFronteiras(JsonConvert.SerializeObject(cidadeDto.FronteirasIds));
}
cidade = _cidadeRepository.Adicionar(cidade);
var resultado = await _cidadeRepository.SaveChangesAsync();
if (resultado == false)
{
return(null);
}
return(_mapper.Map <CidadeDto>(cidade));
}
public async Task <OkObjectResult> Post([FromBody] CidadeDto cidadeDto)
{
var resultado = new Retorno <CidadeDto>();
Cidade cidade = await _cidadeService.InserirAsync(cidadeDto.ToEntity());
if (cidade.Id == 0)
{
resultado.Mensagens.Add(new MensagemSistemaDto()
{
Titulo = "Inclusão", Mensagem = string.Format(" Já existe um usuário cadastrado com esse login: {0}", cidade.Descricao)
});
resultado.Status = ResultadoOperacao.Falha;
return(Ok(resultado));
}
resultado.Objeto = new CidadeDto(cidade);
resultado.Status = ResultadoOperacao.Sucesso;
return(Ok(resultado));
}
public async Task <ActionResult <LocalidadeDto> > ObterPorCidade([FromQuery] CidadeDto cidadeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
var result = await _localidadeService.ObterPorCidade(cidadeDto);
if (result != null)
{
return(Ok(result));
}
return(NotFound());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Post([FromServices] IArmazenadorDeCidade armazenadorDeCidade, [FromBody] CidadeDto cidadeDto)
{
if (cidadeDto == null)
{
return(BadRequest());
}
var resultado = await armazenadorDeCidade.Armazenar(cidadeDto);
return(Ok(resultado));
}
public async Task <IActionResult> Put([FromServices] IAtualizadorDeCidade atualizadorDeCidade, [FromBody] CidadeDto cidadeDto)
{
var cidade = await atualizadorDeCidade.Atualizar(cidadeDto);
if (cidade == null)
{
return(BadRequest("Ocorreu um problema ao atualizar."));
}
return(Ok(cidade));
}
public int Alterar(CidadeDto model)
{
return(GetService <ICidadeRepository>().Alterar(model));
}
