public CidadeViewModel(CidadeEntity cidadeEntity)
{
Nome = cidadeEntity.Nome;
Populacao = cidadeEntity.População;
EstadoEntityId = cidadeEntity.EstadoEntityId;
Estado = cidadeEntity.Estado;
}
public async Task <IActionResult> Edit(int id, CidadeEntity cidadeEntity)
{
if (id != cidadeEntity.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _cidadeService.UpdateAsync(cidadeEntity);
}
catch (EntityValidationException erro)
{
ModelState.AddModelError(erro.PropertyName, erro.Message);
return(View(new CidadeViewModel(cidadeEntity)));
}
catch (DbUpdateConcurrencyException)
{
if (await _cidadeService.GetByIdAsync(id) == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(new CidadeViewModel(cidadeEntity)));
}
private void reset()
{
if (gridDados.RowCount > 0)
{
textBoxNome.Text = "";
comboBoxUf.SelectedItem = "Selecione";
gridDados.CurrentRow.Selected = false;
cidade = new CidadeEntity();
setEditarExcluirEnable(false);
gridDados.Enabled = !isSubCadastro;
}
}
public async Task InsertAsync(CidadeEntity cidadeEntity)
{
var uriPath = $"{_estadoHttpOptions.CurrentValue.CidadePath}";
var httpContent = new StringContent(JsonConvert.SerializeObject(cidadeEntity), Encoding.UTF8, "application/json");
var httpResponseMessage = await _httpClient.PostAsync(uriPath, httpContent);
if (!httpResponseMessage.IsSuccessStatusCode)
{
await _signInManager.SignOutAsync();
}
}
public async Task UpdateAsync(CidadeEntity updatedEntity)
{
var pathWithId = $"{_estadoHttpOptions.CurrentValue.CidadePath}/{updatedEntity.Id}";
var httpContent = new StringContent(JsonConvert.SerializeObject(updatedEntity), Encoding.UTF8, "application/json");
var httpResponseMessage = await _httpClient.PutAsync(pathWithId, httpContent);
if (!httpResponseMessage.IsSuccessStatusCode)
{
await _signInManager.SignOutAsync();
}
}
public void Inserir_ValidCidade_DoesntThrowException()
{
var usuario = new CidadeEntity()
{
Nome = "Belo Horizonte",
IdEstado = 1,
IdLoginCadastro = 1,
};
var codigo = new CidadeRepository().Inserir(usuario);
Assert.IsTrue(codigo > 0);
}
private void btnConfirmar_Click(object sender, EventArgs e)
{
bairro.Nome = textBoxNome.Text;
CidadeEntity cidade = (CidadeEntity)searchCidades.Entidade;
if (cidade != null)
{
bairro.IdCidade = cidade.Id;
}
if (controlActions.Status != ControlActions.STAND_BY)
{
if (Validator.validaCampos(new Object[] { textBoxNome, searchCidades.TextField }))
{
bool sucess = false;
if (controlActions.Status == ControlActions.INSERIR)
{
sucess = dao.inserir(bairro);
if (sucess)
{
setFieldsEnable(false);
getDadosTable();
controlActions.setButtonsEnable(true);
reset();
controlActions.Status = ControlActions.STAND_BY;
}
}
else if (controlActions.Status == ControlActions.EDITAR)
{
sucess = dao.editar(bairro);
if (sucess)
{
setFieldsEnable(false);
getDadosTable();
controlActions.setButtonsEnable(true);
reset();
controlActions.Status = ControlActions.STAND_BY;
}
}
else
{
controlActions.Status = ControlActions.STAND_BY;
}
if (isSubCadastro && sucess)
{
this.Close();
}
}
}
}
public async Task <IActionResult> Create(CidadeEntity cidadeEntity)
{
if (ModelState.IsValid)
{
try
{
await _cidadeService.InsertAsync(cidadeEntity);
return(RedirectToAction(nameof(Index)));
}
catch (EntityValidationException erro)
{
ModelState.AddModelError(erro.PropertyName, erro.Message);
}
}
return(View(cidadeEntity));
}
public void CarregarBase_BaseIbge_DoesntThrowException()
{
string path = @"D:\Documents\Git\CostaAlmeidaCobranca\WebSite\js\estados_cidades.json";
Root root;
using (StreamReader r = new StreamReader(path))
{
string json = r.ReadToEnd();
root = JsonConvert.DeserializeObject <Root>(json);
}
var estadoRepository = new EstadoRepository();
var cidadeRepository = new CidadeRepository();
using (var transation = new TransactionScope())
{
foreach (var estado in root.estados)
{
var estadoEntity = new EstadoEntity()
{
IdLoginCadastro = 1,
Nome = estado.nome,
Sigla = estado.sigla
};
var idEstado = estadoRepository.Inserir(estadoEntity);
foreach (var cidade in estado.cidades)
{
var cidadeEntity = new CidadeEntity()
{
IdLoginCadastro = 1,
IdEstado = idEstado,
Nome = cidade
};
cidadeRepository.Inserir(cidadeEntity);
}
}
transation.Complete();
}
}
public override Entity getEntityByIdentificador(int id)
{
CidadeEntity entidade = new CidadeEntity();
var query = from c in DB.cidades
from e in DB.estados
where e.id == c.id_estado
where c.id == id
select new { c.id, c.id_estado, c.nome, e.uf };
foreach (var cid in query)
{
entidade.Id = cid.id;
entidade.Nome = cid.nome;
entidade.IdEstado = cid.id_estado;
entidade.Uf = cid.uf;
}
return(entidade);
}
public async Task <ActionResult <CidadeEntity> > PostCidadeEntity(CidadeEntity cidadeEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await _cidadeService.InsertAsync(cidadeEntity);
return(Ok(cidadeEntity));
}
catch (EntityValidationException e)
{
ModelState.AddModelError(e.PropertyName, e.Message);
return(BadRequest(ModelState));
}
}
public bool editar(CidadeEntity cidadeEntity)
{
var query = from c in DB.cidades where c.id == cidadeEntity.Id select c;
int idEstado = getIdEstadoByString(cidadeEntity.Uf);
foreach (cidade ci in query)
{
ci.nome = cidadeEntity.Nome;
ci.id_estado = idEstado;
}
try {
DB.SubmitChanges();
MessageBox.Show("Cidade editada com sucesso", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(true);
} catch (Exception ex) {
Validator.tratarErrosSql("Cidade", Validator.EDITAR, ex.Message);
DB = new db_entityDataContext();
return(false);
}
}
public bool inserir(CidadeEntity cidadeEntity)
{
cidade cidade = new cidade();
int idEstado = getIdEstadoByString(cidadeEntity.Uf);
cidade.id_estado = idEstado;
cidade.nome = cidadeEntity.Nome;
DB.cidades.InsertOnSubmit(cidade);
try
{
DB.SubmitChanges();
MessageBox.Show("Cidade inserida com sucesso", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
cidadeEntity.Id = cidade.id;
return(true);
}
catch (Exception ex)
{
Validator.tratarErrosSql("Cidade", Validator.INSERIR, ex.Message);
DB = new db_entityDataContext();
return(false);
}
}
public async Task <IActionResult> PutCidadeEntity(int id, CidadeEntity cidadeEntity)
{
if (id != cidadeEntity.Id)
{
return(BadRequest());
}
try
{
await _cidadeService.UpdateAsync(cidadeEntity);
return(Ok());
}
catch (EntityValidationException error)
{
ModelState.AddModelError(error.PropertyName, error.Message);
return(BadRequest(ModelState));
}
catch (RepositoryException error)
{
ModelState.AddModelError(string.Empty, error.Message);
return(BadRequest(ModelState));
}
}
public void Update(CidadeEntity t)
{
throw new NotImplementedException();
}
public CidadeViewModel(CidadeEntity cidadeEntity, IEnumerable <EstadoEntity> estados) : this(cidadeEntity)
{
Estados = ToEstadoSelectListItem(estados);
}
public async Task UpdateAsync(CidadeEntity insertedModel)
{
await _cidadeRepository.UpdateAsync(insertedModel);
}
public async Task InsertAsync(CidadeEntity cidadeEntity)
{
await _cidadeRepository.InsertAsync(cidadeEntity);
}
public int Insert(CidadeEntity t)
{
throw new NotImplementedException();
}