public JsonResult Index()
{
PingModel resp = new PingModel();
resp.success = true;
return(new JsonResult(resp));
}
private bool GiveMeAUserDto_IfThisMotherFuckerHasAGodDamnToken_AKA_WhatWouldHaveBeenMyAuthenticationFilterAttribute(out UserDto user)
{
HttpRequestMessage request = Request;
user = null;
try
{
PingModel pingModel = ParseTokenHeader(request);
user = Auth.Ping(pingModel.Token);
}
catch (Exception x)
{
return(false);
}
if (user == null)
{
return(false);
}
else
{
return(true);
}
}
public Task <HttpResponseMessage> ExecuteAuthorizationFilterAsync(HttpActionContext context, CancellationToken cancellationToken, Func <Task <HttpResponseMessage> > continuation)
{
return(Task.Factory.StartNew(() =>
{
HttpRequestMessage request = context.Request;
UserDto user = null;
try
{
PingModel pingModel = ParseTokenHeader(context);
user = Auth.Ping(pingModel.Token);
}
catch (Exception)
{
return new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized);
}
if (user == null)
{
return new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized);
}
else
{
return new HttpResponseMessage(System.Net.HttpStatusCode.OK);
}
}));
}
private void HandlePing(PingModel ping)
{
_webSocketAdapter.SendJson(new PongModel
{
Id = ping.Id
});
Ping?.Invoke(this, ping);
}
public void SetUp()
{
message = new PingModel
{
Header = new MessageHeader(executionId: Guid.NewGuid(), timestamp: new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds()),
Body = new Ping(),
Footer = new MessageFooter()
};
}
public object SendPing(PingModel dataRequest)
{
var classRequest = PingAbgService.QueryRequestPingAbg(dataRequest);
var xmlRequest = SerializeXmlService.SerializeXml(classRequest);
var soapXmlRequest = PostXmlAbgService.InvokeSoapEnvelopment(xmlRequest, dataRequest.UserId, dataRequest.Password);
var responseXmlPing = PostXmlAbgService.PostXml(dataRequest.Url, soapXmlRequest);
var xmlResponseTreatment = ResponseTreatmentService.ResponseTreatment(responseXmlPing, "OTA_PingRS");
return(DeserializeXmlService.DeserializeXml(xmlResponseTreatment, new OTA_PingRS()));
}
public string Ping()
{
PingModel model = new PingModel();
model.status = Constants.ASTE_PINGSTATUS_SUCCESS;
model.message = "";
var json = JsonConvert.SerializeObject(model);
return(json);
}
public IActionResult Ping(PingModel model = null)
{
model ??= new PingModel();
if (!string.IsNullOrEmpty(model.Ip))
{
var res = HTTP.GetAsync($"{Request.Scheme}://{Request.Host}/api/Ping?ip={model.Ip}");
model.Set(res);
}
return(View(model));
}
public async Task <IActionResult> Post([FromBody] PingModel model)
{
PingCommand command = new PingCommand();
command.VehicleId = model.VehicleId;
command.ReceivedAt = DateTime.UtcNow;
await _busClient.PublishAsync(command);
return(Accepted());
}
public async Task <ActionResult> GetTcpPing()
{
_logger.LogInformation("Iniciando vista GetTcpPing Troubleshooting");
var model = new PingModel {
Uri = string.Empty, Domain = string.Empty, Host = string.Empty
};
ViewBag.Hosts = EntitiesExtensions.GetDropDownItems(EntitiesExtensions.GetHostsList());
ViewBag.Environments = EntitiesExtensions.GetDropDownItems(EntitiesExtensions.GetEnvironmentsList());
ViewBag.Domains = EntitiesExtensions.GetDropDownItems();
return(View(model));
}
public async Task <ApiResponse <PingModel> > VerifyPing()
{
try
{
var data = new PingModel {
Message = "All is good"
};
var response = new ApiResponse <PingModel>(data);
return(response);
}
catch (Exception e)
{
return(HandleErrorAndReturnStatus <ApiResponse <PingModel> >(e));
}
}
private async Task UntilStoppedPingAsync(PingModel pingModel, PingSettings setting, CancellationToken token)
{
while (pingModel.IsWorking)
{
try
{
var newPing = await this.EchoRequestAsync(setting.Host, setting.BufferLength, setting.Ttl, setting.TimeOut, token);
pingModel.Add(newPing);
await Task.Delay(500);
}
catch (OperationCanceledException)
{
break;
}
}
}
private async Task CountPingAsync(PingModel ping, PingSettings setting, CancellationToken token)
{
for (int i = 0; i < setting.RequestNumber && ping.IsWorking; i++)
{
try
{
var newPing = await this.EchoRequestAsync(setting.Host, setting.BufferLength, setting.Ttl, setting.TimeOut, token);
ping.Add(newPing);
await Task.Delay(500);
}
catch (OperationCanceledException)
{
break;
}
}
}
public async Task PingAsync(PingModel ping, PingSettings setting, CancellationToken token)
{
ping.Start();
var workTimer = Stopwatch.StartNew();
if (setting.CanPingUntilStopped)
{
await this.UntilStoppedPingAsync(ping, setting, token);
}
else
{
await this.CountPingAsync(ping, setting, token);
}
workTimer.Stop();
ping.TimeStamp = workTimer.ElapsedMilliseconds;
ping.Finish();
}
public IHttpActionResult Ping([FromBody] PingModel pingModel)
{
if (pingModel == null)
{
return(BadRequest("Ping requires token"));
}
try
{
UserDto user = Authentication.Ping(pingModel.Token);
SetPrincipal(MakePrincipal(user));
return(Ok(user));
}
catch (Exception x)
{
return(BadRequest(x.Message));
}
}
public void TestMethodPingRequest()
{
#region OBJETO
var pingRequest = new PingModel
{
Message = "Mensagem de Teste - Ambiente de Producao",
Version = "1.0",
Vendor = "Avis",
UserId = "***", //INSERIR USUARIO AO WEB SERVICE
Password = "******", //INSERIR SENHA AO WEB SERVICE
Url = "https://qaservices.carrental.com/wsbang/HTTPSOAPRouter/ws9071",
EchoToken = Guid.NewGuid().ToString()
};
#endregion
var rQRSServices = new RQRSServices();
var resultDeserialize = (Service.WebReferenceDirectConnect.OTA_PingRS)rQRSServices.SendPing(pingRequest);
Assert.IsNotNull(resultDeserialize.EchoToken);
}
// GET: Index
public ActionResult Index()
{
#region OBJETO
var pingRequest = new PingModel
{
Message = "Mensagem de Teste - Ambiente de Produção",
Version = "1.0",
Vendor = "Avis",
UserId = "***", //INSERIR USUARIO AO WEB SERVICE
Password = "******", //INSERIR SENHA AO WEB SERVICE
Url = "https://qaservices.carrental.com/wsbang/HTTPSOAPRouter/ws9071",
EchoToken = Guid.NewGuid().ToString()
};
#endregion
var rQRSServices = new RQRSServices();
var resultDeserialize = (PostXML_AvisBudgetGroup.Service.WebReferenceDirectConnect.OTA_PingRS)rQRSServices.SendPing(pingRequest);
return(View(resultDeserialize));
}
public async Task <ActionResult> GetTcpPing(PingModel model)
{
var result = new ServiceResponse();
try
{
if (ModelState.IsValid)
{
result = await _troubleshootingService.TcpPing(model.Environment, model.Host, model.Domain, model.Uri, model.Port);
}
}
catch (Exception e)
{
_logger.LogError(e.InnerException.Message);
result.Code = -1;
result.Message = e.Message;
}
return(Json(result));
}
public void ShouldHandlePingFromServerWithoutId()
{
PingModel ping = new PingModel();
bool wasRaised = false;
EventHandler <PingModel> handler = null;
handler = delegate(object sender, PingModel pingMsg)
{
wasRaised = true;
Assert.IsNull(pingMsg.Id);
_connection.Ping -= handler;
};
_connection.Ping += handler;
_mock.Raise(socket => socket.DdpMessage += null, null, new DdpMessage("ping", JsonConvert.SerializeObject(ping)));
_mock.Verify(socket => socket.SendJson(It.Is <PongModel>(pong => pong.Id == null)));
Assert.IsTrue(wasRaised);
}
public static RequestPing QueryRequestPingAbg(PingModel objectItem)
{
//RequestPing
var requestPing = new RequestPing();
//RequestPing - OTA_PingRQ
var otaPingRq = new OTA_PingRQ();
otaPingRq.EchoToken = Guid.NewGuid().ToString();
otaPingRq.Version = objectItem.Version;
//RequestPing - OTA_PingRQ - EchoData
otaPingRq.EchoData = objectItem.Message;
requestPing.OTA_PingRQ = otaPingRq;
return(requestPing);
}
public void OnAuthorization(AuthorizationContext context)
{
UserDto user = null;
try
{
PingModel pingModel = ParseTokenHeader(context);
user = Auth.Ping(pingModel.Token);
}
catch (Exception x)
{
context.Result = new HttpUnauthorizedResult();
}
if (user == null)
{
context.Result = new HttpUnauthorizedResult();
}
else
{
context.Result = new HttpStatusCodeResult(200);
}
}
private async Task StartPingAsync()
{
if (!this.IsWorking && !string.IsNullOrWhiteSpace(this.Host))
{
this.IsWorking = true;
var settings = PingSettingsProvider.Instance.GetCurrentPingSettings();
settings.Host = this.host;
var newPingModel = new PingModel(settings.Host, settings.BufferLength);
var token = newPingModel.CancellationTokenSource.Token;
this.CurrentPing = newPingModel;
this.Pings.Insert(0, newPingModel);
await PingProvider.Instance.PingAsync(newPingModel, settings, token);
await PingStorageProvider.Instance.AddAsync(newPingModel);
this.RemoveCurrentCommand.RaiseCanExecuteChanged();
this.IsWorking = false;
}
}
public string Ping()
{
PingModel model = new PingModel();
model.status = Constants.ASTE_PINGSTATUS_SUCCESS;
model.message = "";
var json = JsonConvert.SerializeObject(model);
return json;
}
public static PingModel CreatePing()
{
PingModel model = new PingModel();
return(model);
}
public async Task AddAsync(PingModel ping)
{
this.Pings.Insert(0, ping);
await this.SaveAsync();
}
public async Task RemoveAsync(PingModel ping)
{
this.Pings.Remove(ping);
await this.SaveAsync();
}
