// GET: Meteorologias/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
string token = Request.Cookies.Get(WebApiHttpClient.TokenCookie).Value;
var client = WebApiHttpClient.GetClient(token);
HttpResponseMessage response = await client.GetAsync("api/Meteorologias/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var meteos = JsonConvert.DeserializeObject <Meteorologia>(content);
if (meteos == null)
{
return(HttpNotFound());
}
return(View(meteos));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
public async Task <ActionResult> Edit([Bind(Include = "SugerirPoiID,Nome,Descricao,LocalID,CategoriaID,duracaoVisita,UserID")] SugerirPOI sugerirPOI)
{
try
{
var client = WebApiHttpClient.GetClient();
string editoraJSON = JsonConvert.SerializeObject(sugerirPOI);
HttpContent content = new StringContent(editoraJSON,
System.Text.Encoding.Unicode, "application/json");
var response =
await client.PutAsync("api/SugerirPOIs/" + sugerirPOI.SugerirPoiID, content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
public async Task <ActionResult> Edit([Bind(Include = "LocalID,DataHoraLeitura,Temp,Vento,Humidade,Pressao,NO,NO2,CO2")] Meteorologia meteorologia)
{
try
{
string token = Request.Cookies.Get(WebApiHttpClient.TokenCookie).Value;
var client = WebApiHttpClient.GetClient(token);
string meteoJSON = JsonConvert.SerializeObject(meteorologia);
HttpContent content = new StringContent(meteoJSON,
System.Text.Encoding.Unicode, "application/json");
var response =
await client.PutAsync("api/Meteorologias/" + meteorologia.MetereologiaID, content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
// GET: Produtos/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Produtos/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var produto = JsonConvert.DeserializeObject <Produto>(content);
if (produto == null)
{
return(HttpNotFound());
}
return(View(produto));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var data = new
{
Email = model.Email,
Password = model.Password,
ConfirmPassword = model.Password
};
try
{
var client = WebApiHttpClient.GetClient();
string dataJSON = JsonConvert.SerializeObject(data);
HttpContent content = new StringContent(dataJSON,
System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("api/Account/Register", content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Create(
[Bind(Include = "ProdutoId,Nome,Descricao")] Produto produto)
{
try
{
var client = WebApiHttpClient.GetClient();
string produtoJSON = JsonConvert.SerializeObject(produto);
HttpContent content = new StringContent(produtoJSON,
System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("api/Produtos", content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
// GET: Consulta/usuario/id
public async Task <ActionResult> BuscarUsuarioId(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("consulta/usuario/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var usuario = JsonConvert.DeserializeObject <UsuarioModel>(content);
if (usuario == null)
{
return(HttpNotFound());
}
return(Json(new { usuario }, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = 503;
return(Json(new { message = "Erro ao buscar os dados do usuário." }, JsonRequestBehavior.AllowGet));
}
}
//[ValidateAntiForgeryToken]
public async Task <ActionResult> InserirUsuario(
[Bind(Include = "NmUsuario, DtNascimento, Email")] UsuarioModel usuario)
{
try
{
var client = WebApiHttpClient.GetClient();
string usuarioJSON = JsonConvert.SerializeObject(usuario);
HttpContent content = new StringContent(usuarioJSON,
System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("insere/usuario", content);
if (response.IsSuccessStatusCode)
{
return(Json(new { }, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = 503;
return(Json(new { message = "Erro ao inserir o usuário." }, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new { message = "Erro ao inserir o usuário." }, JsonRequestBehavior.AllowGet));
}
}
// GET: Pessoas - Método onde a lista é retornada no back end da aplicação através da chamada cliente/Web Api
public async Task <ActionResult> RecuperarTodos()
{
try
{
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Pessoa");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var pessoas =
JsonConvert.DeserializeObject <IEnumerable <PessoaModel> >(content);
return(Json(new { pessoas }, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = 503;
return(Json(new { message = "Erro ao buscar a lista de pessoas." }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
throw;
}
}
// GET: Usuarios
public async Task <ActionResult> BuscarTodos()
{
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("todos/usuarios");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var usuarios =
JsonConvert.DeserializeObject <IEnumerable <UsuarioModel> >(content);
//return View(usuarios);
List <UsuarioModel> listUsuarios = new List <UsuarioModel>();
foreach (var item in usuarios)
{
UsuarioModel usuario = new UsuarioModel();
usuario.IdUsuario = item.IdUsuario;
usuario.NmUsuario = item.NmUsuario;
usuario.DtNascimento = item.DtNascimento;
usuario.Email = item.Email;
listUsuarios.Add(usuario);
}
return(Json(new { listUsuarios }, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = 503;
return(Json(new { message = "Erro ao buscar os dados de usuários." }, JsonRequestBehavior.AllowGet));
}
}
[AllowAnonymous] //Permite que usuários anônimos acessem o método. Para solicitação do controller via json.
//[ValidateAntiForgeryToken] //Protege a aplicação no caso de solicitações http maliciosas.
public async Task <ActionResult> GeraTokenWebApi()
{
try
{
var client = WebApiHttpClient.GetClient();
HttpContent content = new StringContent(
"username="******"&password="******"&grant_type=password",
System.Text.Encoding.UTF8, "application/x-www-form-urlencoded");
response = client.PostAsync("/Token", content).Result;
if (response.IsSuccessStatusCode)
{
TokenResponse tokenResponse = await response.Content.ReadAsAsync <TokenResponse>();
WebApiHttpClient.storeToken(tokenResponse);
//return RedirectToAction("UsuarioTeste", "Token");
return(Json(new { tokenResponse.AccessToken }, JsonRequestBehavior.AllowGet));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro na geração do token."));
}
}
public async Task <ActionResult> ForgetYourPassword(ForgotPasswordViewModel model)
{
if (!ModelState.IsValid)
{
StringBuilder strB = new StringBuilder(500);
foreach (ModelState modelState in ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
strB.Append(error.ErrorMessage + ".");
}
}
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Content(strB.ToString()));
}
try
{
var client = WebApiHttpClient.GetClient();
string json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var httpResponse = await client.PostAsync("api/auth/ForgetPassword", httpContent);
MessageResponse response = await httpResponse.Content.ReadAsAsync <MessageResponse>();
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Content(response.message));
}
catch (Exception)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Content("Sorry, an error occured."));
}
}
// GET: Percursoes/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Percursoes/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var percurso = JsonConvert.DeserializeObject <Percurso>(content);
if (percurso == null)
{
return(HttpNotFound());
}
HttpResponseMessage responsePois = await client.GetAsync("api/POIs");
string contentPois = await responsePois.Content.ReadAsStringAsync();
var pois = JsonConvert.DeserializeObject <IEnumerable <POI> >(contentPois);
ViewBag.POI = new SelectList(pois, "PoiID", "Nome");
return(View(percurso));
}
return(Content("Ocorreu um erro: " + response.StatusCode));
}
// GET: Hashtags
public async Task<ActionResult> Index()
{
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Hashtags");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var hash =
JsonConvert.DeserializeObject<IEnumerable<Hashtag>>(content);
return View(hash);
}
else
{
return Content("Ocorreu um erro: " + response.StatusCode);
}
}
public async Task <ActionResult> Login(LoginViewModel model)
{
if (!ModelState.IsValid)
{
StringBuilder strB = new StringBuilder(500);
foreach (ModelState modelState in ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
strB.Append(error.ErrorMessage + ".");
}
}
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content(strB.ToString()));
}
try
{
var client = WebApiHttpClient.GetClient();
string json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var httpResponse = await client.PostAsync("api/auth/login", httpContent);
if (httpResponse.IsSuccessStatusCode)
{
TokenResponse tokenResponse = await httpResponse.Content.ReadAsAsync <TokenResponse>();
WebApiHttpClient.storeToken(tokenResponse);
// return Content(tokenResponse.AccessToken);
return(RedirectToAction("Index", "Home"));
}
else
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
MessageResponse json2 = await httpResponse.Content.ReadAsAsync <MessageResponse>();
return(Content("" + json2.message));
}
}
catch (Exception ee)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Content("Sorry, an error occured." + ee.Message));
}
}
// GET: Hashtags/Edit/5
public async Task<ActionResult> Edit(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Hashtags/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var hash = JsonConvert.DeserializeObject<Hashtag>(content);
if (hash == null) return HttpNotFound();
return View(hash);
}
return Content("Ocorreu um erro: " + response.StatusCode);
}
public async Task <ActionResult> SearchByPoi()
{
string token = HttpContext.Request.Cookies.Get(WebApiHttpClient.TokenCookie).Value;
var client = WebApiHttpClient.GetClient(token);
HttpResponseMessage response = await client.GetAsync("api/PointsOfInterest");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var pois = JsonConvert.DeserializeObject <IEnumerable <PointOfInterest> >(content);
return(View(pois));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
//SearchByDatetime
public async Task <ActionResult> ResultsByDateTime(string datetime)
{
string token = HttpContext.Request.Cookies.Get(WebApiHttpClient.TokenCookie).Value;
var client = WebApiHttpClient.GetClient(token);
HttpResponseMessage response = await client.GetAsync("api/Meteorologias?datetime=" + datetime);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var meteos = JsonConvert.DeserializeObject <IEnumerable <Meteorologia> >(content);
return(View(meteos));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
public async Task<ActionResult> DeleteConfirmed(int id)
{
try
{
var client = WebApiHttpClient.GetClient();
var response = await client.DeleteAsync("api/Hashtags/" + id);
if (response.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
else
{
return Content("Ocorreu um erro: " + response.StatusCode);
}
}
catch
{
return Content("Ocorreu um erro.");
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var client = WebApiHttpClient.GetClient();
string username = model.Email;
string password = model.Password;
HttpContent content = new StringContent(
"grant_type=password&username="******"&password="******"application/x-www-form-urlencoded");
var response = await client.PostAsync("/Token", content);
if (response.IsSuccessStatusCode)
{
//string contentResponse = await response.Content.ReadAsStringAsync();
//return Content(contentResponse);
TokenResponse tokenResponse =
await response.Content.ReadAsAsync <TokenResponse>();
WebApiHttpClient.storeToken(tokenResponse);
//return Content(tokenResponse.AccessToken);
return(RedirectToAction("Index", "Home"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
// GET: SugerirPOIs/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/SugerirPOIs/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var sugPoi = JsonConvert.DeserializeObject <SugerirPOI>(content);
if (sugPoi == null)
{
return(HttpNotFound());
}
return(View(sugPoi));
}
return(Content("Ocorreu um erro: " + response.StatusCode));
}
//[ValidateAntiForgeryToken]
public async Task <ActionResult> DeletarUsuario(int id)
{
try
{
var client = WebApiHttpClient.GetClient();
var response = await client.DeleteAsync("deleta/usuario/" + id);
if (response.IsSuccessStatusCode)
{
return(Json(new { }, JsonRequestBehavior.AllowGet));
}
else
{
Response.StatusCode = 503;
return(Json(new { message = "Erro ao deletar o usuário." }, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new { message = "Erro ao deletar o usuário." }, JsonRequestBehavior.AllowGet));
}
}
public async Task <ActionResult> Create([Bind(Include = "idVisita,data,descrição,horaInicio,idPercurso,idUser")] Visita visita)
{
try
{
var client = WebApiHttpClient.GetClient();
string visitaJSON = JsonConvert.SerializeObject(visita);
HttpContent content = new StringContent(visitaJSON, System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("api/Visitas", content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}catch
{
return(Content("Ocorreu um erro."));
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
try
{
string token = Request.Cookies.Get(WebApiHttpClient.TokenCookie).Value;
var client = WebApiHttpClient.GetClient(token);
var response = await client.DeleteAsync("api/Meteorologias/" + id);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
// GET: SugerirPOIs/Create
public async Task <ActionResult> Create()
{
var client = WebApiHttpClient.GetClient();
HttpResponseMessage responseLocals = await client.GetAsync("api/Locals");
string contentLocals = await responseLocals.Content.ReadAsStringAsync();
var locals = JsonConvert.DeserializeObject <IEnumerable <Local> >(contentLocals);
ViewBag.LocalID = new SelectList(locals, "LocalID", "Nome");
HttpResponseMessage responseCategorias = await client.GetAsync("api/Categorias");
string contentCategorias = await responseCategorias.Content.ReadAsStringAsync();
var categorias = JsonConvert.DeserializeObject <IEnumerable <Categoria> >(contentCategorias);
ViewBag.CategoriaID = new SelectList(categorias, "CategoriaID", "nome");
return(View());
}
// public ActionResult LogOff()
public async Task <ActionResult> LogOff()
{
// AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
try
{
var client = WebApiHttpClient.GetClient();
var response = await client.PostAsync("api/Account/Logout", null);
if (response.IsSuccessStatusCode)
{
HttpContext.Session["token"] = null;
return(RedirectToAction("Index", "Home"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
public async Task<ActionResult> Create([Bind(Include = "ID,Nome")] Hashtag hashtag)
{
try
{
var client = WebApiHttpClient.GetClient();
string hashJSON = JsonConvert.SerializeObject(hashtag);
HttpContent content = new StringContent(hashJSON,
System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("api/Hashtags", content);
if (response.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
else
{
return Content("Ocorreu um erro: " + response.StatusCode);
}
}
catch
{
return Content("Ocorreu um erro.");
}
}
// GET: SugerirPOIs/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/SugerirPOIs/" + id);
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var sugPoi = JsonConvert.DeserializeObject <SugerirPOI>(content);
if (sugPoi == null)
{
return(HttpNotFound());
}
HttpResponseMessage responseLocals = await client.GetAsync("api/Locals");
string contentLocals = await responseLocals.Content.ReadAsStringAsync();
var locals = JsonConvert.DeserializeObject <IEnumerable <Local> >(contentLocals);
ViewBag.LocalID = new SelectList(locals, "LocalID", "Nome", sugPoi.LocalID);
HttpResponseMessage responseCategorias = await client.GetAsync("api/Categorias");
string contentCategorias = await responseCategorias.Content.ReadAsStringAsync();
var categorias = JsonConvert.DeserializeObject <IEnumerable <Categoria> >(contentCategorias);
ViewBag.CategoriaID = new SelectList(categorias, "CategoriaID", "nome");
return(View(sugPoi));
}
return(Content("Ocorreu um erro: " + response.StatusCode));
}
public async Task <ActionResult> Create([Bind(Include = "LocalID,DataDeLeitura,HoraDeLeitura,Temperatura,Vento,Humidade,Pressao,NO,NO2,CO")] Meteorologia meteorologia)
{
try
{
var client = WebApiHttpClient.GetClient();
string meteorologiaJSON = JsonConvert.SerializeObject(meteorologia);
HttpContent content = new StringContent(meteorologiaJSON,
System.Text.Encoding.Unicode, "application/json");
var response = await client.PostAsync("api/Meteorologias", content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
catch
{
return(Content("Ocorreu um erro."));
}
}
//private ApplicationDbContext db = new ApplicationDbContext();
// GET: Meteorologias
public async Task <ActionResult> Index(String NomeLocal, String DataDeLeitura, String HoraDeLeitura)
{
var client = WebApiHttpClient.GetClient();
HttpResponseMessage response = await client.GetAsync("api/Meteorologias");
HttpResponseMessage responsePOI = await client.GetAsync("api/POIS");
if (response.IsSuccessStatusCode && responsePOI.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
var meteorologias = JsonConvert.DeserializeObject <IEnumerable <Meteorologia> >(content);
var meteorologiasdto = JsonConvert.DeserializeObject <IEnumerable <MeteorologiaDTO> >(content);
string contentpois = await responsePOI.Content.ReadAsStringAsync();
var poisdto = JsonConvert.DeserializeObject <IEnumerable <POIDTO> >(contentpois);
var lstPOI = new List <String>();
var lstDate = new List <DateTime>();
var lstHora = new List <TimeSpan>();
foreach (var loc in poisdto)
{
lstPOI.Add(loc.NomePonto);
}
foreach (var xx in meteorologias)
{
foreach (var cc in meteorologiasdto)
{
if (xx.MeteorologiaID == cc.MeteorologiaID)
{
xx.Local = new Local();
xx.Local.NomeLocal = cc.NomeLocal;
if (!lstDate.Contains(xx.DataDeLeitura))
{
lstDate.Add(xx.DataDeLeitura);
}
if (!lstHora.Contains(xx.HoraDeLeitura))
{
lstHora.Add(xx.HoraDeLeitura);
}
}
}
}
ViewBag.NomeLocal = lstPOI.OrderBy(i => i).Select(r => new SelectListItem {
Text = r
});
ViewBag.DataDeLeitura = lstDate.OrderBy(i => i).Select(r => new SelectListItem {
Text = r.ToShortDateString()
});
ViewBag.HoraDeLeitura = lstHora.OrderBy(i => i).Select(t => new SelectListItem {
Text = t.ToString()
});
var lstFilter = new List <Meteorologia>();
foreach (var meteo in meteorologias)
{
Boolean add = true;
if (!String.IsNullOrEmpty(NomeLocal))
{
foreach (var yy in poisdto)
{
if ((meteo.Local.NomeLocal != yy.NomeLocal) && (NomeLocal == yy.NomePonto))
{
add = false;
}
}
}
if (!String.IsNullOrEmpty(DataDeLeitura))
{
if (DateTime.Compare(meteo.DataDeLeitura, Convert.ToDateTime(DataDeLeitura)) != 0)
{
add = false;
}
}
if (!String.IsNullOrEmpty(HoraDeLeitura))
{
if (meteo.HoraDeLeitura.ToString() != HoraDeLeitura)
{
add = false;
}
}
if (add)
{
lstFilter.Add(meteo);
}
}
return(View(lstFilter.OrderBy(s => s.DataDeLeitura).ThenBy(n => n.HoraDeLeitura)));
}
else
{
return(Content("Ocorreu um erro: " + response.StatusCode));
}
}
