/// <summary>
/// Obtem um cep e converte em Model
/// </summary>
/// <param name="id"></param>
/// <param name="model"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
private bool ObterCep(Guid id, ref CepModel model, ref string mensagemErro)
{
//Preparar a requisição e o retorno
RetornoObterDto <CepDto> retorno = new RetornoObterDto <CepDto>();
RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
{
Id = id,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Obter(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
mensagemErro = retorno.Mensagem;
return(false);
}
else
{
//Converter para Model
return(model.ConverterDtoParaModel(retorno.Entidade, ref mensagemErro));
}
}
async Task BuscaCep()
{
if (string.IsNullOrWhiteSpace(lblCep.Text))
{
await DisplayAlert("Alerta!", "Digite o Cep para procurar.", "OK");
return;
}
IsBusy = true;
CepService srvCep = new CepService();
CepModel cep = new CepModel();
cep = await srvCep.BuscaCep(lblCep.Text);
IsBusy = false;
if (cep.Cep == null)
{
await DisplayAlert("Alerta!", "Falha ao procurar o Cep.", "OK");
return;
}
else
{
lblEndereco.Text = cep.Logradouro;
lblMunicipio.Text = cep.Localidade;
lblEstado.Text = cep.UF;
lblBairro.Text = cep.Bairro;
lblComplemento.Text = cep.Complemento;
}
}
/// <summary>
/// Valide se o endereço foi preenchido, caso o CEP seja informado
/// </summary>
/// <param name="model"></param>
/// <param name="erros"></param>
/// <returns></returns>
public static bool ValidarEndereco(CepModel model, ref Dictionary <string, string> erros)
{
if (string.IsNullOrWhiteSpace(model.Cep))
{
return(true);
}
bool retorno = true;
if (string.IsNullOrWhiteSpace(model.Logradouro))
{
erros.Add("Endereco.Logradouro", "O logradouro é obrigatório para incluir o endereço.");
retorno = false;
}
if (string.IsNullOrWhiteSpace(model.Bairro))
{
erros.Add("Endereco.Bairro", "O bairro é obrigatório para incluir o endereço.");
retorno = false;
}
if (string.IsNullOrWhiteSpace(model.Cidade))
{
erros.Add("Endereco.Cidade", "A cidade é obrigatória para incluir o endereço.");
retorno = false;
}
return(retorno);
}
public async Task <ActionResult> Buscando(String id)
{
var cepModel = new CepModel();
await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);
Browser browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
//Não mostrar:
Headless = true
//Mostrar:
//Headless = false
});
//Url Correios
string fullUrl = "http://www.buscacep.correios.com.br/sistemas/buscacep/BuscaCepEndereco.cfm";
//Abertura de pagina
var page = await browser.NewPageAsync();
var timeout = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
page.DefaultNavigationTimeout = timeout;
page.DefaultTimeout = timeout;
var options = new NavigationOptions {
Timeout = timeout
};
await page.GoToAsync(fullUrl, options);
//Preenchimento e clique
await page.TypeAsync("[name='relaxation']", id);
await page.ClickAsync("[value='Buscar']");
try
{
//Obter dados
var _obterDados = new ObterDados();
var _logradouro = _obterDados.GetLogradouro(page);
cepModel.logradouro = await _logradouro;
var _bairro = _obterDados.GetBairro(page);
cepModel.bairro = await _bairro;
var _estado = _obterDados.GetEstado(page);
cepModel.estado = await _estado;
await browser.CloseAsync();
cepModel.cep = id;
//Fim Obter dados
}
catch
{
Invalido();
}
return(View(cepModel));
}
public async Task<CepModel> GetCepDetails(string cep)
{
if (_cepApiOptions == null)
throw new ConfigurationErrorsException("Cep API Url setting must be configured!");
ICepClientApiService client = RestService.For<ICepClientApiService>(_cepApiOptions.Url);
CepModel cepDetails = await client.GetAddressAsync(cep);
return cepDetails;
}
public ActionResult Incluir(CepModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converter para DTO
CepDto cepDto = new CepDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref cepDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
cepDto.Id = Guid.NewGuid();
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <CepDto> requisicaoDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Incluir(requisicaoDto, ref retorno);
//Verificar o retorno
if (retorno.Retorno == false)
{
//Se houver erro, exibir na tela de inclusão
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "INCLUIDO";
//Retornar para index
return(RedirectToAction("Index"));
}
public ActionResult Editar(CepModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converte para DTO
CepDto cepDto = new CepDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref cepDto, ref mensagemErro))
{
ViewBag.MensagemErro = mensagemErro;
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <CepDto> requisicaoDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do cep
return(RedirectToAction("Index"));
}
/// <summary>
/// Chama a tela para incluir um cep
/// </summary>
/// <returns></returns>
public ActionResult Incluir()
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Cep a ser incluído
CepModel model = new CepModel()
{
Id = Guid.NewGuid()
};
TempData["Retorno"] = "INCLUINDO";
//Chamar a view
return(View(model));
}
public async Task <CepModel> BuscaCep(string cep)
{
if (string.IsNullOrEmpty(cep))
{
return(null);
}
else
{
var client = new HttpClient();
client.MaxResponseContentBufferSize = 256000;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var uri = new Uri(string.Format("https://viacep.com.br/ws/{0}/json/", cep));
var response = await client.GetAsync(uri);
if (response.StatusCode == HttpStatusCode.NotFound)
{
_cep = new CepModel();
}
else
{
string content = await response.Content.ReadAsStringAsync();
JObject output = JObject.Parse(content);
_cep = new CepModel();
if (output.ToString().Contains("erro"))
{
return(_cep);
}
_cep.Cep = output.SelectToken("cep").ToString()?.Trim();
_cep.Logradouro = output.SelectToken("logradouro").ToString()?.Trim();
_cep.Complemento = output.SelectToken("complemento").ToString()?.Trim();
_cep.Bairro = output.SelectToken("bairro").ToString()?.Trim();
_cep.Localidade = output.SelectToken("localidade").ToString()?.Trim();
_cep.UF = output.SelectToken("uf").ToString()?.Trim();
_cep.Ibge = output.SelectToken("ibge").ToString()?.Trim();
}
return(_cep);
}
}
/// <summary>
/// Chama a tela para editar um cep
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Editar(Guid id)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Model a ser populada
CepModel model = new CepModel();
string mensagemRetorno = "";
//Obtem o cep pelo ID
if (!this.ObterCep(id, ref model, ref mensagemRetorno))
{
ViewBag.MensagemErro = mensagemRetorno;
return(View("Erro"));
}
TempData["Retorno"] = "EDITANDO";
//Chamar a view
return(View(model));
}
public void InsertCep(CepModel Cep)
{
sqliteconnection.Insert(Cep);
}
public void CepMapperTest()
{
var model = new CepModel
{
Id = Guid.NewGuid(),
Cep = Faker.RandomNumber.Next(1, 10000).ToString(),
Logradouro = Faker.Address.StreetName(),
Numero = "",
CreateAt = DateTime.UtcNow,
UpdateAt = DateTime.UtcNow,
MunicipioId = Guid.NewGuid()
};
var listaEntity = new List <CepEntity>();
for (int i = 0; i < 5; i++)
{
var item = new CepEntity
{
Id = Guid.NewGuid(),
Cep = Faker.RandomNumber.Next(1, 10000).ToString(),
Logradouro = Faker.Address.StreetName(),
Numero = Faker.RandomNumber.Next(1, 10000).ToString(),
CreateAt = DateTime.UtcNow,
UpdateAt = DateTime.UtcNow,
MunicipioId = Guid.NewGuid(),
Municipio = new MunicipioEntity
{
Id = Guid.NewGuid(),
Nome = Faker.Address.UsState(),
CodIbge = Faker.RandomNumber.Next(1, 10000),
UfId = Guid.NewGuid(),
Uf = new UfEntity
{
Id = Guid.NewGuid(),
Nome = Faker.Address.UsState(),
Sigla = Faker.Address.UsState().Substring(1, 3)
}
}
};
listaEntity.Add(item);
}
//Model => Entity
var entity = Mapper.Map <CepEntity>(model);
Assert.Equal(entity.Id, model.Id);
Assert.Equal(entity.Logradouro, model.Logradouro);
Assert.Equal(entity.Numero, model.Numero);
Assert.Equal(entity.Cep, model.Cep);
Assert.Equal(entity.CreateAt, model.CreateAt);
Assert.Equal(entity.UpdateAt, model.UpdateAt);
//Entity para Dto
var cepDto = Mapper.Map <CepDto>(entity);
Assert.Equal(cepDto.Id, entity.Id);
Assert.Equal(cepDto.Logradouro, entity.Logradouro);
Assert.Equal(cepDto.Numero, entity.Numero);
Assert.Equal(cepDto.Cep, entity.Cep);
var cepDtoCompleto = Mapper.Map <CepDto>(listaEntity.FirstOrDefault());
Assert.Equal(cepDtoCompleto.Id, listaEntity.FirstOrDefault().Id);
Assert.Equal(cepDtoCompleto.Cep, listaEntity.FirstOrDefault().Cep);
Assert.Equal(cepDtoCompleto.Logradouro, listaEntity.FirstOrDefault().Logradouro);
Assert.Equal(cepDtoCompleto.Numero, listaEntity.FirstOrDefault().Numero);
Assert.NotNull(cepDtoCompleto.Municipio);
Assert.NotNull(cepDtoCompleto.Municipio.uf);
var listaDto = Mapper.Map <List <CepDto> >(listaEntity);
Assert.True(listaDto.Count() == listaEntity.Count());
for (int i = 0; i < listaDto.Count(); i++)
{
Assert.Equal(listaDto[i].Id, listaEntity[i].Id);
Assert.Equal(listaDto[i].Cep, listaEntity[i].Cep);
Assert.Equal(listaDto[i].Logradouro, listaEntity[i].Logradouro);
Assert.Equal(listaDto[i].Numero, listaEntity[i].Numero);
}
var cepDtoCreateResult = Mapper.Map <CepDtoCreateResult>(entity);
Assert.Equal(cepDtoCreateResult.Id, entity.Id);
Assert.Equal(cepDtoCreateResult.Cep, entity.Cep);
Assert.Equal(cepDtoCreateResult.Logradouro, entity.Logradouro);
Assert.Equal(cepDtoCreateResult.Numero, entity.Numero);
Assert.Equal(cepDtoCreateResult.CreateAt, entity.CreateAt);
var cepDtoUpdateResult = Mapper.Map <CepDtoUpdateResult>(entity);
Assert.Equal(cepDtoUpdateResult.Id, entity.Id);
Assert.Equal(cepDtoUpdateResult.Cep, entity.Cep);
Assert.Equal(cepDtoUpdateResult.Logradouro, entity.Logradouro);
Assert.Equal(cepDtoCreateResult.Numero, entity.Numero);
Assert.Equal(cepDtoUpdateResult.UpdateAt, entity.UpdateAt);
//Dto para Model
cepDto.Numero = "";
var cepModel = Mapper.Map <CepModel>(cepDto);
Assert.Equal(cepModel.Id, cepDto.Id);
Assert.Equal(cepModel.Cep, cepDto.Cep);
Assert.Equal(cepModel.Logradouro, cepDto.Logradouro);
Assert.Equal("S/N", cepModel.Numero);
var cepDtoCreate = Mapper.Map <CepDtoCreate>(cepModel);
Assert.Equal(cepDtoCreate.Cep, cepModel.Cep);
Assert.Equal(cepDtoCreate.Logradouro, cepModel.Logradouro);
Assert.Equal(cepDtoCreate.Numero, cepModel.Numero);
var cepDtoUpdate = Mapper.Map <CepDtoUpdate>(cepModel);
Assert.Equal(cepDtoUpdate.Id, cepModel.Id);
Assert.Equal(cepDtoUpdate.Cep, cepModel.Cep);
Assert.Equal(cepDtoUpdate.Logradouro, cepModel.Logradouro);
Assert.Equal(cepDtoUpdate.Numero, cepModel.Numero);
}
public void Teste_Mapper()
{
var model = new CepModel
{
Id = Guid.NewGuid(),
Cep = Faker.RandomNumber.Next(1, 10000).ToString(),
Logradouro = Faker.Address.StreetName(),
Numero = Faker.RandomNumber.Next(1, 10000).ToString(),
MunicipioId = Guid.NewGuid(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
};
var listaEntity = new List <CepEntity>();
for (int i = 0; i < 5; i++)
{
var item = new CepEntity
{
Id = Guid.NewGuid(),
Cep = Faker.RandomNumber.Next(1, 10000).ToString(),
Logradouro = Faker.Address.StreetName(),
Numero = Faker.RandomNumber.Next(1, 10000).ToString(),
MunicipioId = Guid.NewGuid(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
Municipio = new MunicipioEntity()
{
Id = Guid.NewGuid(),
Nome = Faker.Address.City(),
CodIBGE = Faker.RandomNumber.Next(1, 10000),
UfId = Guid.NewGuid(),
Uf = new UfEntity()
{
Id = Guid.NewGuid(),
Nome = Faker.Address.UsState(),
Sigla = Faker.Address.UsState().Substring(1, 3)
}
}
};
listaEntity.Add(item);
}
//Model to Entity
var dtoToEntity = Mapper.Map <CepEntity>(model);
Assert.Equal(dtoToEntity.Id, model.Id);
Assert.Equal(dtoToEntity.Cep, model.Cep);
Assert.Equal(dtoToEntity.Logradouro, model.Logradouro);
Assert.Equal(dtoToEntity.CreateAt, model.CreateAt);
Assert.Equal(dtoToEntity.UpdateAt, model.UpdateAt);
//Entity to DTO
var UfDto = Mapper.Map <CepDto>(dtoToEntity);
Assert.Equal(UfDto.Id, dtoToEntity.Id);
Assert.Equal(UfDto.Cep, dtoToEntity.Cep);
Assert.Equal(UfDto.Logradouro, dtoToEntity.Logradouro);
var listDto = Mapper.Map <List <CepDto> >(listaEntity);
Assert.True(listaEntity.Count == listDto.Count());
for (int i = 0; i < listDto.Count(); i++)
{
Assert.Equal(listDto[i].Id, listaEntity[i].Id);
Assert.Equal(listDto[i].Cep, listaEntity[i].Cep);
Assert.Equal(listDto[i].Logradouro, listaEntity[i].Logradouro);
}
var ufModel = Mapper.Map <CepDto>(dtoToEntity);
}
public void InsertCep(CepModel cep)
{
_databaseHelper.InsertCep(cep);
}
