void UPhilipsHueBridge::HandleLightStateRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
int32 idx = MessageBody.Find("error");
if (idx > 0){
//Send Error;
}
else
{
//Successfully sent!
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
bool PlayFabRequestHandler::DecodeRequest(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, PlayFab::FPlayFabBaseModel& OutResult, PlayFab::FPlayFabError& OutError)
{
PlayFabRequestHandler::pendingCalls -= 1;
FString ResponseStr, ErrorStr;
if (bSucceeded && HttpResponse.IsValid())
{
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
// Create the Json parser
ResponseStr = HttpResponse->GetContentAsString();
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader, JsonObject) && JsonObject.IsValid())
{
if (PlayFabRequestHandler::DecodeError(JsonObject, OutError))
{
return false;
}
const TSharedPtr<FJsonObject>* DataJsonObject;
if (JsonObject->TryGetObjectField(TEXT("data"), DataJsonObject))
{
return OutResult.readFromValue(*DataJsonObject);
}
}
}
else
{
// Create the Json parser
ResponseStr = HttpResponse->GetContentAsString();
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader, JsonObject) && JsonObject.IsValid())
{
if (PlayFabRequestHandler::DecodeError(JsonObject, OutError))
{
return false;
}
}
}
}
// If we get here, we failed to connect meaningfully to the server - Assume a timeout
OutError.HttpCode = 408;
OutError.ErrorCode = PlayFabErrorConnectionTimeout;
// For text returns, use the non-json response if possible, else default to no response
OutError.ErrorName = OutError.ErrorMessage = OutError.HttpStatus = TEXT("Request Timeout or null response");
return false;
}
void FSimplygonRESTClient::UploadAsset_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
FString msg = Response->GetContentAsString();
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Upload asset response: %s"), *msg);
TSharedPtr<FJsonObject> JsonParsed;
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(msg);
if (FJsonSerializer::Deserialize(JsonReader, JsonParsed))
{
SwarmTask->InputAssetId = JsonParsed->GetStringField("AssetId");
UE_LOG(LogSimplygonRESTClient, Log, TEXT("AssetId: %s"), *SwarmTask->InputAssetId);
}
SwarmTask->SetState(SRS_ASSETUPLOADED);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Response: %i"), Response->GetResponseCode());
}
}
void UPhilipsHueBridge::HandleUserIDTestRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
// If HTTP fails client-side, this will still be called but with a NULL shared pointer!
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
int32 idx = MessageBody.Find("unauthorized user");
if (idx > 0){
//Remind push linking
OnPushLinkRequested.Broadcast(Id);
//AquireUserID(false);
}
else
{
Connected = true;
// Successfully tested the user id
OnHueUserAuthorized.Broadcast(ConnectedUser);
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
void UPhilipsHueBridge::HandleUserIDRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
FString userid = "";
// If HTTP fails client-side, this will still be called but with a NULL shared pointer!
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
TSharedRef< TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(*MessageBody);
int32 idx = MessageBody.Find("\"username\"");
if (idx > 0){
userid = MessageBody.Trim();
userid.RemoveFromStart("[{\"success\":{\"username\":\"");
userid.RemoveFromEnd("\"}}]");
ConnectedUser = userid;
SaveUserIDToFile();
OnHueUserAuthorized.Broadcast(userid);
}
else
{
OnPushLinkRequested.Broadcast(Id);
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
void UHeliosGetterProxy_Float::OnHeliosRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded) {
if (!bSucceeded) {
UE_LOG(LogTemp, Error, TEXT("Helios > request failed: %s"), *HttpRequest->GetURL());
OnFail.Broadcast(0);
return;
}
if (!HttpResponse.IsValid()) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid response for request: %s"), *HttpRequest->GetURL());
OnFail.Broadcast(0);
return;
}
FString ContentAsString = HttpResponse->GetContentAsString();
json Content = json::parse(TCHAR_TO_UTF8(*ContentAsString));
if (Content.size() != 1) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid json returned"));
OnFail.Broadcast(0);
return;
}
if (!Content["value"].is_number_float()) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid type returned"));
OnFail.Broadcast(0);
return;
}
float Result = Content["value"];
OnSuccess.Broadcast(Result);
}
bool FCrashUpload::ParseServerResponse(FHttpResponsePtr Response)
{
// Turn the snippet into a complete XML document, to keep the XML parser happy
FXmlFile ParsedResponse(FString(TEXT("<Root>")) + Response->GetContentAsString() + TEXT("</Root>"), EConstructMethod::ConstructFromBuffer);
UE_LOG(CrashReportClientLog, Log, TEXT("Response->GetContentAsString(): '%s'"), *Response->GetContentAsString());
if (!ParsedResponse.IsValid())
{
UE_LOG(CrashReportClientLog, Log, TEXT("Invalid response!"));
return false;
}
if (auto ResultNode = ParsedResponse.GetRootNode()->FindChildNode(TEXT("CrashReporterResult")))
{
UE_LOG(CrashReportClientLog, Log, TEXT("ResultNode->GetAttribute(TEXT(\"bSuccess\")) = %s"), *ResultNode->GetAttribute(TEXT("bSuccess")));
return ResultNode->GetAttribute(TEXT("bSuccess")) == TEXT("true");
}
UE_LOG(CrashReportClientLog, Log, TEXT("Could not find CrashReporterResult"));
return false;
}
void AVictoryPC::HTTPOnResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
FString ResponseStr = "AVictoryPC::HTTPOnResponseReceived>>> Connection Error";
if(bWasSuccessful)
{
ResponseStr = Response->GetContentAsString();
}
this->VictoryPC_GetMyIP_DataReceived(ResponseStr);
}
void FSurveyTitleCdnStorage::ReadFile_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
bool bResult = false;
FString ResponseStr, ErrorStr;
// should have a pending Http request
FPendingFileRequest PendingRequest = FileRequests.FindChecked(HttpRequest.Get());
FileRequests.Remove(HttpRequest.Get());
// Cloud file being operated on
FCloudFile* CloudFile = GetCloudFile(PendingRequest.FileName, true);
CloudFile->AsyncState = EOnlineAsyncTaskState::Failed;
CloudFile->Data.Empty();
if (bSucceeded &&
HttpResponse.IsValid())
{
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
UE_LOG(LogEpicSurvey, Verbose, TEXT("ReadFile request complete. url=%s code=%d"),
*HttpRequest->GetURL(), HttpResponse->GetResponseCode());
// update the memory copy of the file with data that was just downloaded
CloudFile = GetCloudFile(PendingRequest.FileName, true);
CloudFile->AsyncState = EOnlineAsyncTaskState::Done;
CloudFile->Data = HttpResponse->GetContent();
// cache to disk on successful download
SaveCloudFileToDisk(CloudFile->FileName,CloudFile->Data);
bResult = true;
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response. code=%d error=%s"),
HttpResponse->GetResponseCode(), *HttpResponse->GetContentAsString());
}
}
else
{
ErrorStr = TEXT("No response");
}
if (!ErrorStr.IsEmpty())
{
UE_LOG(LogEpicSurvey, Verbose, TEXT("ReadFile request failed. %s"), *ErrorStr);
}
TriggerOnReadFileCompleteDelegates(bResult, PendingRequest.FileName);
}
/**
* Callback for IHttpRequest::OnProcessRequestComplete()
*
* @param Request HTTP request pointer
* @param Response Response pointer
* @param bWasSuccessful Whether the request was successful or not
*
*/
void UJsonFieldData::OnReady(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful) {
if (!bWasSuccessful) {
UE_LOG(LogJson, Error, TEXT("Response was invalid! Please check the URL."));
// Broadcast the failed event
OnFailed.Broadcast();
return;
}
// Process the string
FromString(Response->GetContentAsString());
// Broadcast the result event
OnGetResult.Broadcast();
}
void FSimplygonRESTClient::AccountInfo_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
FString msg = Response->GetContentAsString();
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Account info response: %s"), *msg);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Account info response: %i"), Response->GetResponseCode());
}
}
bool HttpRpcRequest::ParseMessageFromResponse(FHttpResponsePtr response) {
const FString contentType = response->GetContentType();
if (contentType.StartsWith(kContentTypeJson)) {
} else if (contentType.StartsWith(kContentTypeASCII)) {
if (!google::protobuf::TextFormat::ParseFromString(TCHAR_TO_UTF8(*response->GetContentAsString()), callState_.GetResponse())) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("ASCII response parse failed"));
return false;
}
return true;
} else if (contentType.StartsWith(kContentTypeBinary)) {
} else {
UE_LOG(HttpRpcRequestLog, Error, TEXT("Invalid content type '%s'"), *contentType);
}
return false;
}
void FHttpTest::RequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
if (!HttpResponse.IsValid())
{
UE_LOG(LogHttp, Log, TEXT("Test failed. NULL response"));
}
else
{
UE_LOG(LogHttp, Log, TEXT("Completed test [%s] Url=[%s] Response=[%d] [%s]"),
*HttpRequest->GetVerb(),
*HttpRequest->GetURL(),
HttpResponse->GetResponseCode(),
*HttpResponse->GetContentAsString());
}
if ((--TestsToRun) <= 0)
{
HttpRequest->OnProcessRequestComplete().Unbind();
// Done with the test. Delegate should always gets called
delete this;
}
}
/**
* Callback function for MakeRequest. Sets the global response variable.
*
* @param Request
* @param Response Contains the data of the response, including the response code.
* @param bWasSuccessful Contains true if the request was successful. Else it contains false.
*
*/
void CloudyWebAPIImpl::OnGetResponseComplete(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (bWasSuccessful)
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Response Code = %d"), Response->GetResponseCode());
if (Response.IsValid() && EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
HttpResponse = Response->GetContentAsString();
}
else
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Request failed! Response invalid"));
}
}
else
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Request failed! Is the server up?"));
}
}
static bool DeserializeResponseToStruct(void* OutStruct, UStruct& TypeInfo, FHttpResponsePtr HttpResponse)
{
bool bResult = false;
FString ResponseStr = HttpResponse->GetContentAsString();
FText ErrorText;
if (HttpResponse.IsValid())
{
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
// Write string to FMemoryWriter to force unicode
TArray<uint8> InBytes;
FMemoryWriter Writer(InBytes);
Writer.ArForceUnicode = true;
Writer << ResponseStr;
FMemoryReader Reader(InBytes);
// FMemoryWriter writes size of string at beginning, need to ignore this or json parsing errors occur
Reader.Seek(4);
FJsonStructDeserializerBackend Backend(Reader);
bResult = FStructDeserializer::Deserialize(OutStruct, TypeInfo, Backend);
}
else
{
ErrorText = FText::Format(LOCTEXT("InvalidResponse", "Invalid response. code={0} error={1}"), FText::FromString(FString::FromInt(HttpResponse->GetResponseCode())), FText::FromString(ResponseStr));
}
}
if (!bResult)
{
UE_LOG(LogLocalizationService, Warning, TEXT("%s"), *(ErrorText.ToString()));
}
return bResult;
}
void Atlas_impl::RequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
if (!HttpResponse.IsValid())
{
if (bForceQuit)
{
FPlatformMisc::RequestExit(true);
}
return;
}
TSharedRef< TJsonReader<> > Reader = TJsonReaderFactory<>::Create(HttpResponse->GetContentAsString());
TSharedPtr<FJsonObject> Object;
check(FJsonSerializer::Deserialize(Reader, Object));
check(Object.IsValid());
const TSharedPtr<FJsonValue>* Value = Object->Values.Find(TEXT("allowGame"));
check(Value && (*Value)->Type == EJson::Boolean);
const bool allowGame = (*Value)->AsBool();
Value = Object->Values.Find(TEXT("allowEditor"));
check(Value && (*Value)->Type == EJson::Boolean);
const bool allowEditor = (*Value)->AsBool();
if (bForceQuit)
{
if (GIsEditor && !allowEditor)
{
FPlatformMisc::RequestExit(true);
}
else if (!GIsEditor && !allowGame)
{
FPlatformMisc::RequestExit(true);
}
}
}
void FSimplygonRESTClient::GetJob_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
FString msg = Response->GetContentAsString();
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Get job response: %s"), *msg);
TSharedPtr<FJsonObject> JsonParsed;
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(msg);
if (FJsonSerializer::Deserialize(JsonReader, JsonParsed))
{
FString status = JsonParsed->GetStringField("Status");
int32 Progress = JsonParsed->GetNumberField("ProgressPercentage");
if (status == "Processed")
{
SwarmTask->OutputAssetId = JsonParsed->GetStringField("OutputAssetId");
SwarmTask->SetState(SRS_JOBPROCESSED);
}
if (status == "Failed")
{
SwarmTask->SetState(SRS_FAILED);
}
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Status: %s"), *status);
}
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Response: %i"), Response->GetResponseCode());
}
}
void HttpRpcRequest::onHttpRequestCompleted(FHttpRequestPtr request, FHttpResponsePtr response, bool bWasSuccessful) {
if (!bWasSuccessful) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP request failed"));
callState_.GetController()->SetFailed("HTTP request failed");
} else {
const int responseCode = response->GetResponseCode();
if (responseCode != 200) {
if ((responseCode >= 300) && (responseCode < 400)) {
// TODO(san): Handle redirects.
callState_.GetController()->SetFailed("Unsupported redirect");
} else {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP response code %d (%s)"), response->GetResponseCode(), *response->GetContentAsString());
callState_.GetController()->SetFailed("Bad HTTP response code");
}
} else {
// Successful HTTP response.
int requestId = ParseRequestIdFromResponse(response);
if (requestId == -1) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP response missing request id"));
callState_.GetController()->SetFailed("Response missing request id");
// TODO(san): Think about whether we should be strict about this given we have the request handy.
} else if (requestId != FCString::Atoi(*request->GetHeader("X-Request-ID"))) {
// If this happens legitimately then we are most likely inheriting a 'threading issue' from the
// HTTP module - in which case we'll probably need to track outstanding requests ourselves.
UE_LOG(HttpRpcRequestLog, Error, TEXT("Mismatched Request/Response!"));
callState_.GetController()->SetFailed("Mismatched Request/Response ID");
} else {
// Request ID is valid. Extract the protobuf from the HTTP content buffer.
if (!ParseMessageFromResponse(response)) {
UE_LOG(HttpRpcRequestLog, Warning, TEXT("Failed to parse response protobuf"));
callState_.GetController()->SetFailed("Failed to parse response protobuf");
}
}
}
}
Closure* cachedClosure = callState_.GetDone();
delete this;
cachedClosure->Run();
}
void FOnlineIdentityLeet::MeUser_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
UE_LOG_ONLINE(Display, TEXT("FOnlineIdentityLeet::MeUser_HttpRequestComplete"));
bool bResult = false;
FString ResponseStr, ErrorStr;
FUserOnlineAccountLeet User;
FPendingLoginUser PendingRegisterUser = LoginUserRequests.FindRef(HttpRequest.Get());
// Remove the request from list of pending entries
LoginUserRequests.Remove(HttpRequest.Get());
if (bSucceeded &&
HttpResponse.IsValid())
{
ResponseStr = HttpResponse->GetContentAsString();
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
UE_LOG(LogOnline, Verbose, TEXT("RegisterUser request complete. url=%s code=%d response=%s"),
*HttpRequest->GetURL(), HttpResponse->GetResponseCode(), *ResponseStr);
if (User.FromJson(ResponseStr))
{
if (!User.UserId.IsEmpty())
{
// copy and construct the unique id
TSharedRef<FUserOnlineAccountLeet> UserRef(new FUserOnlineAccountLeet(User));
UserRef->UserIdPtr = MakeShareable(new FUniqueNetIdString(User.UserId));
// update/add cached entry for user
UserAccounts.Add(User.UserId, UserRef);
// update the access token
UserRef->AuthTicket = PendingRegisterUser.AccessToken;
// keep track of user ids for local users
UserIds.Add(PendingRegisterUser.LocalUserNum, UserRef->GetUserId());
bResult = true;
}
else
{
ErrorStr = FString::Printf(TEXT("Missing user id. payload=%s"),
*ResponseStr);
}
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response payload=%s"),
*ResponseStr);
}
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response. code=%d error=%s"),
HttpResponse->GetResponseCode(), *ResponseStr);
}
}
else
{
ErrorStr = TEXT("No response");
}
if (!ErrorStr.IsEmpty())
{
UE_LOG(LogOnline, Warning, TEXT("RegisterUser request failed. %s"), *ErrorStr);
}
TriggerOnLoginCompleteDelegates(PendingRegisterUser.LocalUserNum, bResult, FUniqueNetIdString(User.UserId), ErrorStr);
}
/**
* This is a callback function that is called when the "AttemptAuthentication" function
* has completed its request.
*
* @param Request
* @param Response Contains the data of the response, including the response code.
* @param bWasSuccessful Contains true if the request was successful. Else it contains false.
*
*/
void CloudyWebAPIImpl::OnAuthResponseComplete(FHttpRequestPtr Request,
FHttpResponsePtr Response, bool bWasSuccessful)
{
if (bWasSuccessful)
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Response Code = %d"), Response->GetResponseCode());
if (!Response.IsValid())
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Request failed!"));
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject());
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(Response->GetContentAsString());
FJsonSerializer::Deserialize(JsonReader, JsonObject);
Token = JsonObject->GetStringField("token");
UE_LOG(CloudyWebAPILog, Warning, TEXT("Token = %s"), *Token);
}
}
else
{
UE_LOG(CloudyWebAPILog, Error, TEXT("Request failed! Is the server up?"));
}
}
void FCdnNewsFeedTitleFile::EnumerateFiles_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
IHttpRequest* Request;
EnumerateFilesRequests.Dequeue(Request);
bool bResult = false;
FString ResponseStr, ErrorStr;
if (bSucceeded && HttpResponse.IsValid())
{
ResponseStr = HttpResponse->GetContentAsString();
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
UE_LOG(LogEpicStorage, Verbose, TEXT("EnumerateFiles request complete. url=%s code=%d response=%s"),
*HttpRequest->GetURL(), HttpResponse->GetResponseCode(), *ResponseStr);
FileHeaders.Empty();
// Make sure the response is an array
if (!ResponseStr.StartsWith(TEXT("[")))
{
ResponseStr = FString(TEXT("[")) + ResponseStr + FString(TEXT("]"));
}
// Json parser expects arrays to always be wrapped with object
FString ResponseStrJson = FString(TEXT("{\"files\":")) + ResponseStr + FString(TEXT("}"));
// Create the Json parser
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStrJson);
if (FJsonSerializer::Deserialize(JsonReader,JsonObject) &&
JsonObject.IsValid())
{
// Parse the array of file headers
TArray<TSharedPtr<FJsonValue> > JsonFileHeaders = JsonObject->GetArrayField(TEXT("files"));
for (TArray<TSharedPtr<FJsonValue> >::TConstIterator It(JsonFileHeaders); It; ++It)
{
TSharedPtr<FJsonObject> JsonFileHeader = (*It)->AsObject();
if (JsonFileHeader.IsValid())
{
FCloudFileHeader FileHeader;
if (JsonFileHeader->HasField(TEXT("hash")))
{
FileHeader.Hash = JsonFileHeader->GetStringField(TEXT("hash"));
}
if (JsonFileHeader->HasField(TEXT("uniqueFilename")))
{
FileHeader.DLName = JsonFileHeader->GetStringField(TEXT("uniqueFilename"));
}
if (JsonFileHeader->HasField(TEXT("filename")))
{
FileHeader.FileName = JsonFileHeader->GetStringField(TEXT("filename"));
}
if (JsonFileHeader->HasField(TEXT("length")))
{
FileHeader.FileSize = FMath::TruncToInt(JsonFileHeader->GetNumberField(TEXT("length")));
}
if (FileHeader.FileName.IsEmpty())
{
FileHeader.FileName = FileHeader.DLName;
}
if (FileHeader.Hash.IsEmpty() ||
FileHeader.DLName.IsEmpty())
{
UE_LOG(LogEpicStorage, Warning, TEXT("Invalid file entry hash=%s dlname=%s filename=%s"),
*FileHeader.Hash, *FileHeader.DLName, *FileHeader.FileName);
}
else
{
FileHeaders.Add(FileHeader);
}
}
}
bResult = true;
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response payload=%s"),
*ResponseStr);
}
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response. code=%d error=%s"),
HttpResponse->GetResponseCode(), *ResponseStr);
}
}
if (!ErrorStr.IsEmpty())
{
UE_LOG(LogEpicStorage, Warning, TEXT("EnumerateFiles request failed. %s"), *ErrorStr);
}
TriggerOnEnumerateFilesCompleteDelegates(bResult);
}
void SSuperSearchBox::Query_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
bool bResult = false;
FString ResponseStr, ErrorStr;
if (bSucceeded && HttpResponse.IsValid())
{
ResponseStr = HttpResponse->GetContentAsString();
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
// Create the Json parser
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader, JsonObject) && JsonObject.IsValid())
{
if (FText * QueryText = RequestQueryMap.Find(HttpRequest))
{
const TArray<TSharedPtr<FJsonValue> > * JsonItems = nullptr;
if (JsonObject->TryGetArrayField(TEXT("items"), JsonItems))
{
//add search result into cache
FSearchResults & SearchResults = SearchResultsCache.FindOrAdd(QueryText->ToString());
FCategoryResults & OnlineResults = SearchResults.OnlineResults;
OnlineResults.Empty(); //reset online results since we just got updated
for (TSharedPtr<FJsonValue> JsonItem : *JsonItems)
{
const TSharedPtr<FJsonObject> & ItemObject = JsonItem->AsObject();
FSearchEntry SearchEntry;
SearchEntry.Title = ItemObject->GetStringField("title");
SearchEntry.URL = ItemObject->GetStringField("link");
SearchEntry.bCategory = false;
bool bValidLabel = false;
TArray<TSharedPtr<FJsonValue> > Labels = ItemObject->GetArrayField(TEXT("labels"));
for (TSharedPtr<FJsonValue> Label : Labels)
{
const TSharedPtr<FJsonObject> & LabelObject = Label->AsObject();
FString LabelString = LabelObject->GetStringField(TEXT("name"));
TArray<FSearchEntry> & SuggestionCategory = OnlineResults.FindOrAdd(LabelString);
SuggestionCategory.Add(SearchEntry);
}
}
}
bResult = true;
}
}
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response. code=%d error=%s"),
HttpResponse->GetResponseCode(), *ResponseStr);
}
}
if (bResult)
{
UpdateSuggestions();
}
}
void USIOJRequestJSON::OnProcessRequestComplete(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
// Be sure that we have no data from previous response
ResetResponseData();
// Check we have a response and save response code as int32
if(Response.IsValid())
{
ResponseCode = Response->GetResponseCode();
}
// Check we have result to process futher
if (!bWasSuccessful || !Response.IsValid())
{
UE_LOG(LogSIOJ, Error, TEXT("Request failed (%d): %s"), ResponseCode, *Request->GetURL());
// Broadcast the result event
OnRequestFail.Broadcast(this);
OnStaticRequestFail.Broadcast(this);
return;
}
// Save response data as a string
ResponseContent = Response->GetContentAsString();
// Log response state
UE_LOG(LogSIOJ, Log, TEXT("Response (%d): %s"), ResponseCode, *ResponseContent);
// Process response headers
TArray<FString> Headers = Response->GetAllHeaders();
for (FString Header : Headers)
{
FString Key;
FString Value;
if (Header.Split(TEXT(": "), &Key, &Value))
{
ResponseHeaders.Add(Key, Value);
}
}
// Try to deserialize data to JSON
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(ResponseContent);
FJsonSerializer::Deserialize(JsonReader, ResponseJsonObj->GetRootObject());
// Decide whether the request was successful
bIsValidJsonResponse = bWasSuccessful && ResponseJsonObj->GetRootObject().IsValid();
// Log errors
if (!bIsValidJsonResponse)
{
if (!ResponseJsonObj->GetRootObject().IsValid())
{
// As we assume it's recommended way to use current class, but not the only one,
// it will be the warning instead of error
UE_LOG(LogSIOJ, Warning, TEXT("JSON could not be decoded!"));
}
}
// Broadcast the result event
OnRequestComplete.Broadcast(this);
OnStaticRequestComplete.Broadcast(this);
// Finish the latent action
if (ContinueAction)
{
FSIOJLatentAction<USIOJsonObject*> *K = ContinueAction;
ContinueAction = nullptr;
K->Call(ResponseJsonObj);
}
}
void FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::EnumeratingSessions );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
UE_LOG( LogHttpReplay, Verbose, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished." ) );
TArray<FNetworkReplayStreamInfo> Streams;
FString StreamsString = HttpResponse->GetContentAsString();
int32 Index = INDEX_NONE;
TArray< FString > Tokens;
// Parse the string as { token 1, token ..., token n }
// This isn't perfect, we should convert to JSON when the dust settles
if ( StreamsString.FindChar( '{', Index ) )
{
StreamsString = StreamsString.RightChop( Index + 1 );
while ( StreamsString.FindChar( ',', Index ) )
{
Tokens.Add( StreamsString.Left( Index ) );
StreamsString = StreamsString.RightChop( Index + 1 );
}
if ( StreamsString.FindChar( '}', Index ) )
{
Tokens.Add( StreamsString.Left( Index ) );
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. '}' not found." ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
if ( Tokens.Num() > 0 )
{
Tokens[ Tokens.Num() - 1 ].RemoveFromStart( TEXT( " " ) );
Tokens[ Tokens.Num() - 1 ].RemoveFromEnd( TEXT( " " ) );
}
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. '{' not found." ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
const int NUM_TOKENS_PER_INFO = 6;
if ( Tokens.Num() == 0 || ( Tokens.Num() % NUM_TOKENS_PER_INFO ) != 0 )
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. Invalid number of tokens: %i" ), Tokens.Num() );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
// Convert tokens to individual FNetworkReplayStreamInfo's
for ( int i = 0; i < Tokens.Num(); i += NUM_TOKENS_PER_INFO )
{
FNetworkReplayStreamInfo NewStream;
NewStream.Name = Tokens[i];
NewStream.bIsLive = false;
NewStream.SizeInBytes = 0;
NewStream.Timestamp = 0;
if ( Tokens.IsValidIndex( i + 1 ) )
{
// Server returns milliseconds from January 1, 1970, 00:00:00 GMT
// We need to compensate for the fact that FDateTime starts at January 1, 0001 A.D. and is in 100 nanosecond resolution
NewStream.Timestamp = FDateTime( FCString::Atoi64( *Tokens[ i + 1 ] ) * 1000 * 10 + FDateTime( 1970, 1, 1 ).GetTicks() );
}
if ( Tokens.IsValidIndex( i + 2 ) )
{
NewStream.SizeInBytes = FCString::Atoi( *Tokens[ i + 2 ] );
}
if ( Tokens.IsValidIndex( i + 3 ) )
{
NewStream.LengthInMS = FCString::Atoi( *Tokens[ i + 3 ] );
}
if ( Tokens.IsValidIndex( i + 4 ) )
{
NewStream.NumViewers = FCString::Atoi( *Tokens[ i + 4 ] );
}
if ( Tokens.IsValidIndex( i + 5 ) )
{
NewStream.bIsLive = Tokens[ i + 5 ].Contains( TEXT( "true" ) );
}
Streams.Add( NewStream );
}
EnumerateStreamsDelegate.ExecuteIfBound( Streams );
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. FAILED" ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
}
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
}
void FOneSkyTranslationExportWorker::Query_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
bool bResult = false;
if (bSucceeded)
{
FString ResponseStr = HttpResponse->GetContentAsString();
FText ErrorText;
if (HttpResponse.IsValid())
{
EHttpResponseCodes::Type ResponseCode = (EHttpResponseCodes::Type) HttpResponse->GetResponseCode();
if (EHttpResponseCodes::IsOk(ResponseCode))
{
// TODO: Test Accepted case. Haven't been able to make this happen yet...
if (ResponseCode == EHttpResponseCodes::Accepted)
{
if (Command != nullptr)
{
TSharedPtr<FDownloadLocalizationTargetFile, ESPMode::ThreadSafe> TranslationExportOp = StaticCastSharedRef<FDownloadLocalizationTargetFile>(Command->Operation);
if (TranslationExportOp.IsValid())
{
// The file is not ready, try again
TSharedRef<FDownloadLocalizationTargetFile, ESPMode::ThreadSafe> NewTranslationExportLanguagesOp = ILocalizationServiceOperation::Create<FDownloadLocalizationTargetFile>();
NewTranslationExportLanguagesOp->SetInTargetGuid(TranslationExportOp->GetInTargetGuid());
NewTranslationExportLanguagesOp->SetInLocale(TranslationExportOp->GetInLocale());
NewTranslationExportLanguagesOp->SetInRelativeOutputFilePathAndName(TranslationExportOp->GetInRelativeOutputFilePathAndName());
// TODO: Can't spawn a new Worker here, as it tries to access the OneSky Connection Info from a thread that is not the main thread.
// Instead spawn in callback?
//ILocalizationServiceModule::Get().GetProvider().Execute(NewTranslationExportLanguagesOp, TArray<FLocalizationServiceTranslationIdentifier>(), ELocalizationServiceOperationConcurrency::Asynchronous);
// For now, error
ErrorText = LOCTEXT("TranslationExportQueryFailedRetryNotImplemented", "Translation Export Query Failed: Retry not yet implemented.");
bResult = false;
}
else
{
ErrorText = LOCTEXT("TranslationExportQueryFailedTranslationExportOpInvalid", "Translation Export Query Failed: Translation Export Operation is invalid.");
}
return;
}
else
{
ErrorText = LOCTEXT("TranslationExportQueryFailedCommandNull", "Translation Export Query Failed: Command is null.");
}
}
else if (ResponseCode == EHttpResponseCodes::NoContent)
{
bResult = false;
}
// If there's no response code, then this is the file
else
{
if (Command != nullptr)
{
TSharedPtr<FDownloadLocalizationTargetFile, ESPMode::ThreadSafe> TranslationExportOp = StaticCastSharedRef<FDownloadLocalizationTargetFile>(Command->Operation);
if (TranslationExportOp.IsValid())
{
// Path is relative to game directory
FString Filename = FPaths::ConvertRelativePathToFull(FPaths::GameDir() / TranslationExportOp->GetInRelativeOutputFilePathAndName());
if (Filename.IsEmpty())
{
ErrorText = LOCTEXT("InvalidExportFilename", "Export filename is invalid");
bResult = false;
}
else if (FFileHelper::SaveStringToFile(ResponseStr, *Filename, FFileHelper::EEncodingOptions::ForceUnicode))
{
bResult = true;
}
else
{
ErrorText = LOCTEXT("FailedToWriteFile", "Could not write file.");
bResult = false;
}
}
else
{
ErrorText = LOCTEXT("ExportFilenameNotFound", "Could not find export file name.");
bResult = false;
}
}
}
}
else
{
ErrorText = FText::Format(LOCTEXT("InvalidResponse", "Invalid response. code={0} error={1}"), FText::FromString(FString::FromInt(HttpResponse->GetResponseCode())), FText::FromString(ResponseStr));
}
}
if (!bResult)
{
UE_LOG(LogLocalizationService, Warning, TEXT("%s"), *(ErrorText.ToString()));
if (Command != nullptr)
{
Command->ErrorMessages.Add(ErrorText);
TSharedPtr<FDownloadLocalizationTargetFile, ESPMode::ThreadSafe> DownloadLocTargetOp = StaticCastSharedRef<FDownloadLocalizationTargetFile>(Command->Operation);
if (DownloadLocTargetOp.IsValid())
{
DownloadLocTargetOp->SetOutErrorText(ErrorText);
}
}
}
}
if (Command != nullptr)
{
Command->bCommandSuccessful = bResult;
FPlatformAtomics::InterlockedExchange(&(Command->bExecuteProcessed), 1);
}
}
void UPlayFabMatchmakerAPI::OnProcessRequestComplete(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
// Be sure that we have no data from previous response
ResetResponseData();
FPlayFabBaseModel myResponse;
// Check we have result to process futher
if (!bWasSuccessful)
{
UE_LOG(LogPlayFab, Error, TEXT("Request failed: %s"), *Request->GetURL());
// Broadcast the result event
myResponse.responseError.ErrorCode = 500;
myResponse.responseError.ErrorName = "Request Error";
myResponse.responseError.ErrorMessage = "HTTP Request Error";
myResponse.responseData = ResponseJsonObj;
Matchmaker_proxy->OnPlayFabResponse.Broadcast(myResponse, false);
return;
}
// Save response data as a string
ResponseContent = Response->GetContentAsString();
// Save response code as int32
ResponseCode = Response->GetResponseCode();
// Try to deserialize data to JSON
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(ResponseContent);
FJsonSerializer::Deserialize(JsonReader, ResponseJsonObj->GetRootObject());
// Decide whether the request was successful
bIsValidJsonResponse = bWasSuccessful && ResponseJsonObj->GetRootObject().IsValid();
// Log errors
if (!bIsValidJsonResponse)
{
if (!ResponseJsonObj->GetRootObject().IsValid())
{
// As we assume it's recommended way to use current class, but not the only one,
// it will be the warning instead of error
UE_LOG(LogPlayFab, Warning, TEXT("JSON could not be decoded!"));
}
}
// Serialize data to json string
FString InputString;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&InputString);
FJsonSerializer::Serialize(ResponseJsonObj->GetRootObject().ToSharedRef(), Writer);
// Log response state
UE_LOG(LogPlayFab, Log, TEXT("Response : %s"), *InputString);
myResponse.responseError.decodeError(ResponseJsonObj);
myResponse.responseData = ResponseJsonObj;
// Broadcast the result event
Matchmaker_proxy->OnPlayFabResponse.Broadcast(myResponse, true);
}
void FOnlineFriendsFacebook::QueryFriendsList_HttpRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FOnReadFriendsListComplete Delegate)
{
bool bResult = false;
FString ResponseStr, ErrorStr;
FPendingFriendsQuery PendingFriendsQuery = FriendsQueryRequests.FindRef(HttpRequest.Get());
// Remove the request from list of pending entries
FriendsQueryRequests.Remove(HttpRequest.Get());
if (bSucceeded &&
HttpResponse.IsValid())
{
ResponseStr = HttpResponse->GetContentAsString();
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
UE_LOG(LogOnline, Verbose, TEXT("Query friends request complete. url=%s code=%d response=%s"),
*HttpRequest->GetURL(), HttpResponse->GetResponseCode(), *ResponseStr);
// Create the Json parser
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader,JsonObject) &&
JsonObject.IsValid())
{
// Update cached entry for local user
FOnlineFriendsList& FriendsList = FriendsMap.FindOrAdd(PendingFriendsQuery.LocalUserNum);
FriendsList.Friends.Empty();
// Should have an array of id mappings
TArray<TSharedPtr<FJsonValue> > JsonFriends = JsonObject->GetArrayField(TEXT("data"));
for (TArray<TSharedPtr<FJsonValue> >::TConstIterator FriendIt(JsonFriends); FriendIt; ++FriendIt)
{
FString UserIdStr;
TMap<FString,FString> Attributes;
TSharedPtr<FJsonObject> JsonFriendEntry = (*FriendIt)->AsObject();
for (TMap<FString, TSharedPtr<FJsonValue > >::TConstIterator It(JsonFriendEntry->Values); It; ++It)
{
// parse user attributes
if (It->Value.IsValid() &&
It->Value->Type == EJson::String)
{
FString ValueStr = It->Value->AsString();
if (It->Key == TEXT("id"))
{
UserIdStr = ValueStr;
}
Attributes.Add(It->Key, ValueStr);
}
}
// only add if valid id
if (!UserIdStr.IsEmpty())
{
TSharedRef<FOnlineFriendFacebook> FriendEntry(new FOnlineFriendFacebook(UserIdStr));
FriendEntry->AccountData = Attributes;
// Add new friend entry to list
FriendsList.Friends.Add(FriendEntry);
}
}
bResult = true;
}
}
else
{
ErrorStr = FString::Printf(TEXT("Invalid response. code=%d error=%s"),
HttpResponse->GetResponseCode(), *ResponseStr);
}
}
else
{
ErrorStr = TEXT("No response");
}
if (!ErrorStr.IsEmpty())
{
UE_LOG(LogOnline, Warning, TEXT("Query friends list request failed. %s"), *ErrorStr);
}
Delegate.ExecuteIfBound(PendingFriendsQuery.LocalUserNum, bResult, EFriendsLists::ToString(EFriendsLists::Default), ErrorStr);
}
void FAnalyticsProviderET::EventRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
if (bSucceeded && HttpResponse.IsValid())
{
UE_LOG(LogAnalytics, VeryVerbose, TEXT("[%s] ET response for [%s]. Code: %d. Payload: %s"), *APIKey, *HttpRequest->GetURL(), HttpResponse->GetResponseCode(), *HttpResponse->GetContentAsString());
}
else
{
UE_LOG(LogAnalytics, VeryVerbose, TEXT("[%s] ET response for [%s]. No response"), *APIKey, *HttpRequest->GetURL());
}
}
void AVictoryPC::HTTPOnResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
this->VictoryPC_GetMyIP_DataReceived(Response->GetContentAsString());
}
