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()); }