// 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> 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: 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: 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));
}
}
/// <summary>
/// Constructor for edit EXISTING product
/// </summary>
public ManageProductViewModel(IEnumerable <IdNameModel> categories,
WebApiHttpClient webApiClient, ProductModel product)
{
this._isNew = false;
Init("Edit Product", categories, webApiClient);
this.WorkModel = product;
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
string token = await WebApiHttpClient.Login(model.Email, model.Password);
HttpCookie cookie = new HttpCookie(WebApiHttpClient.TokenCookie);
cookie.Value = token;
Response.Cookies.Add(cookie);
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
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> 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."));
}
}
//[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));
}
}
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));
}
// 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));
}
}
// 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));
}
}
// 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));
}
[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> 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."));
}
}
protected WebApiHttpClient GetWebAPIClient(TenantModel tenant)
{
WebApiHttpClient webApiHttpClient = new WebApiHttpClient(tenant.WebApiClientConfig, tenant.OriginalConfiguration,
(s) => FileLogger.Debug(LogName.WebAPIClientLog, s), _customAuthFunc);
webApiHttpClient.SetEntityODATA <T>();
return(webApiHttpClient);
}
static PaymentServices()
{
if (webApiHttpClient == null)
{
webApiHttpClient = new WebApiHttpClient();
webApiHttpClient.BaseAddress = new Uri(Consts.BankURL);
webApiHttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
}
public override int Count()
{
return(CurrentTenantExecutionWebAPI <Tenant, int>((tenant) =>
{
WebApiHttpClient httpClient = GetWebAPIClient(CurrentTenant);
string result = httpClient.GetAsync <Tenant>().WithRowQuery("/$count").ResponseToString();
return int.Parse(result);
}, nameof(Count)));
}
/// <summary>
/// Applica le espressioni di trasformata del risultato
/// </summary>
public virtual IEnumerable <THeader> SetProjectionsHeaders(WebApiHttpClient httpClient, IODATAQueryManager odataQuery)
{
ODataModel <ICollection <THeader> > foundResults = httpClient.GetAsync <T>().WithRowQuery(odataQuery.Compile()).ResponseToModel <ODataModel <ICollection <THeader> > >();
if (foundResults == null || foundResults.Value == null)
{
return(Enumerable.Empty <THeader>());
}
return(foundResults.Value);
}
private void Init(string title, IEnumerable <IdNameModel> categories, WebApiHttpClient webApiClient)
{
OkCommand = new Command(OnOkCommandExecute, OnOkCommandCanExecute);
CancelCommand = new Command(OnCancelCommandExecute, OnCancelCommandCanExecute);
_webApiClient = webApiClient;
this.Title = GetTitle(title);
this.Categories = categories;
}
public BaseDocumentHandler()
{
try
{
FileLogger.Initialize();
}
catch
{
}
_httpClient = new WebApiHttpClient(new WebAPIClientConfiguration(ADDRESSES_CONFIG_NAME).HttpConfiguration,
new WebAPIClientConfiguration(ADDRESSES_CONFIG_NAME).HttpConfiguration, f => FileLogger.Debug(LogName.WebAPIClientLog, f));
}
/// <summary>
/// Constructor for adding NEW product
/// </summary>
public ManageProductViewModel(IEnumerable <IdNameModel> categories,
WebApiHttpClient webApiClient)
{
_isNew = true;
Init("Create Product", categories, webApiClient);
this.WorkModel = new ProductModel()
{
Id = -1,
// BUG: If we do not set value that is now whole number,
// CATEL wont let one enter the floating point (comma)
Price = 0.1M
};
}
// 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);
}
//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));
}
}
/// <summary>
/// Crea la DoSearchHeader con i metodi standard.
/// Se non implementati, vengono usati quelli standard
/// </summary>
public ICollection <WebAPIDto <THeader> > DoSearchHeader()
{
ICollection <WebAPIDto <THeader> > searchHeaderList = CurrentTenantExecutionWebAPI <THeader>((tenant, results) =>
{
WebApiHttpClient httpClient = GetWebAPIClient(tenant);
IODATAQueryManager odataQuery = GetODataQuery();
odataQuery = DecorateFinder(odataQuery);
if (EnableTopOdata)
{
odataQuery = odataQuery.Top(DocSuiteContext.Current.DefaultODataTopQuery);
}
odataQuery = AttachFilterExpressions(odataQuery);
SetProjectionsHeaders(httpClient, odataQuery).ToList().ForEach(x => results.Add(_headerMapper.TransformDTO(x, tenant)));
return(results);
}, FinalizeDoSearchHeader, "DoSearchHeader");
return(searchHeaderList);
}
public List <WebAPIDto <DossierModel> > GetFromPostMethod()
{
WebApiHttpClient httpClient = GetWebAPIClient(CurrentTenant);
DossierFinderModel.Skip = PageIndex;
DossierFinderModel.Top = (CustomPageIndex + 1) * PageSize;
Dictionary <string, DossierFinderModel> finders = new Dictionary <string, DossierFinderModel>();
finders.Add("finder", DossierFinderModel);
string bodyQuery = JsonConvert.SerializeObject(finders, new StringEnumConverter());
IEnumerable <DossierModel> results = httpClient.PostStringAsync <Dossier>($"/{CommonDefinition.OData.DossierService.FX_GetAuthorizedDossiers}", bodyQuery).ResponseToModel <ODataModel <ICollection <DossierModel> > >().Value;
return(results.Select(dossierModel => new WebAPIDto <DossierModel>
{
Entity = dossierModel,
TenantModel = CurrentTenant
}).ToList());
}
public override int Count()
{
if (!FromFinderModel)
{
return(base.Count());
}
return(CurrentTenantExecutionWebAPI <Fascicle, int>((tenant) =>
{
WebApiHttpClient httpClient = GetWebAPIClient(CurrentTenant);
Dictionary <string, FascicleFinderModel> finders = new Dictionary <string, FascicleFinderModel>();
finders.Add("finder", FascicleFinderModel);
string bodyQuery = JsonConvert.SerializeObject(finders, new StringEnumConverter());
int result = httpClient.PostStringAsync <Fascicle>($"/{CommonDefinition.OData.FascicleService.FX_GetCountAuthorizedFascicles}", bodyQuery).ResponseToModel <ODataModel <int> >().Value;
return result;
}, nameof(Count)));
}
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));
}
}
