Ange/DTFluxAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add TrackedRequest implementation in DTFluxCoreSubsystem and various Modifications and bugfixes.

Browse Source
This commit is contained in:
Ange-Marie MAURIN
2025-07-11 23:45:23 +02:00
parent f1f300a351
commit d92ca63ea4
8 changed files with 199 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
Source/DTFluxAPIStatus/Private/widgets/DTFluxStatusWidget.cpp
View File

@ -416,7 +416,7 @@ FSlateColor SDTFluxStatusWidget::GetComboItemRankingColor(const TSharedPtr<FComb
FReply SDTFluxStatusWidget::OnRankingButtonClicked() const
{
if (DTFluxNetwork)
if (DTFluxCore)
{
// Exemple d'envoi de requête basée sur la sélection
int ForContest = SelectedContestComboBoxItem.IsValid() ? SelectedContestComboBoxItem->ContestId : -1;
@ -432,13 +432,19 @@ FReply SDTFluxStatusWidget::OnRankingButtonClicked() const
if (ForStage == -1)
{
UE_LOG(logDTFluxStatus, Warning, TEXT("Stage not selected !!!! Requesting contest Ranking"));
RequestType = EDTFluxApiDataType::ContestRanking;
DTFluxNetwork->SendRequest(RequestType, ForContest);
DTFluxCore->TrackedRequestContestRankings({ForContest});
return FReply::Handled();
}
RequestType = ForSplit == -1 ? EDTFluxApiDataType::StageRanking : EDTFluxApiDataType::SplitRanking;
if (ForSplit == -1)
{
UE_LOG(logDTFluxStatus, Warning, TEXT("Split not selected !!!! Requesting stage Ranking"));
FDTFluxStageKey StageKey = {ForContest, ForStage};
DTFluxCore->TrackedRequestStageRankings({StageKey});
return FReply::Handled();
}
FDTFluxSplitKey SplitKey = {ForContest, ForStage, ForSplit};
DTFluxCore->TrackedRequestSplitRankings({SplitKey});
UE_LOG(logDTFluxStatus, Warning, TEXT("Requesting %s Ranking"), *UEnum::GetValueAsString(RequestType));
DTFluxNetwork->SendRequest(RequestType, ForContest, ForStage, ForSplit);
}
return FReply::Handled();

171
Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
View File

@ -10,6 +10,7 @@
#include "FileHelpers.h"
#include "Assets/DTFluxModelAsset.h"
#include "Subsystems/DTFluxNetworkSubsystem.h"
#include "Struct/DTFluxServerResponseStruct.h"
#include "UObject/SavePackage.h"
void UDTFluxCoreSubsystem::Initialize(FSubsystemCollectionBase& Collection)
@ -52,6 +53,84 @@ void UDTFluxCoreSubsystem::SaveDataStorage()
}
}
void UDTFluxCoreSubsystem::ProcessTrackedResponse(FDTFluxServerResponse& InResponse)
{
switch (InResponse.GetResponseType())
{
case EDTFluxApiDataType::ContestRanking:
{
FDTFluxContestRankings Rankings;
if (InResponse.ParseContestRanking(Rankings))
{
ProcessContestRanking(Rankings);
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking added for Contest %s"),
*Rankings.ContestName);
}
else
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse ContestRanking"));
}
break;
}
case EDTFluxApiDataType::StageRanking:
{
FDTFluxStageRankings Rankings;
if (InResponse.ParseStageRanking(Rankings))
{
ProcessStageRanking(Rankings);
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking added for Stage %i of Contest %i"),
Rankings.StageId, Rankings.ContestId);
}
else
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse StageRanking"));
}
break;
}
case EDTFluxApiDataType::SplitRanking:
{
FDTFluxSplitRankings Rankings;
if (InResponse.ParseSplitRanking(Rankings))
{
ProcessSplitRanking(Rankings);
UE_LOG(logDTFluxCoreSubsystem, Warning,
TEXT("ContestRanking added for Split %i of Stage %i of Contest %i"),
Rankings.SplitId, Rankings.StageId, Rankings.ContestId);
}
else
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Unable to parse SplitRanking"));
}
break;
}
case EDTFluxApiDataType::RaceData:
{
FDTFluxRaceData RaceData;
if (InResponse.ParseRaceData(RaceData))
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("RaceDataDefinition added for Contest %s"),
*RaceData.Datas[0].Name);
ProcessRaceData(RaceData);
}
break;
}
case EDTFluxApiDataType::TeamList:
{
FDTFluxTeamListDefinition TeamList;
if (InResponse.ParseTeamList(TeamList))
{
ProcessTeamList(TeamList);
UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("Process TeamList"))
}
break;
}
default:
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Unknown DataType %s"),
*UEnum::GetValueAsString(InResponse.GetResponseType()));
break;
}
}
void UDTFluxCoreSubsystem::RegisterDelegates()
{
if (NetworkSubsystem)
@ -148,21 +227,24 @@ void UDTFluxCoreSubsystem::ProcessContestRanking(const FDTFluxContestRankings& C
DataStorage->AddContestRanking(NewContestRankings);
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRankings added for Contest %s"),
*NewContestRankings.ContestName);
if (bShouldKeepRankings)
{
SaveDataStorage();
}
}
void UDTFluxCoreSubsystem::ProcessStageRanking(const FDTFluxStageRankings& StageRankings)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Received StageRankings with %i Items"), StageRankings.Rankings.Num());
DataStorage->UpdateOrCreateStageRanking(StageRankings);
SaveDataStorage();
if (bShouldKeepRankings) { SaveDataStorage(); }
}
void UDTFluxCoreSubsystem::ProcessSplitRanking(const FDTFluxSplitRankings& SplitRankings)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Received SplitRanking with %i Items"), SplitRankings.Rankings.Num());
DataStorage->UpdateOrCreateSplitRanking(SplitRankings);
SaveDataStorage();
if (bShouldKeepRankings) { SaveDataStorage(); }
}
void UDTFluxCoreSubsystem::ProcessTeamStatusUpdate(const FDTFluxTeamStatusUpdate& NewParticipantStatus)
@ -286,14 +368,18 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<i
FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
[this](const FDTFluxTrackedRequest& Request)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking Request %s %s Success"),
UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("ContestRanking Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
if (Request.ParsedResponse.IsSet())
{
ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
}
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("ContestRanking Request [%s] Error %s"),
UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("ContestRanking Request [%s] Error %s"),
*InReq.RequestId.ToString(), *InError);
});
// if Contest is not ended
@ -318,6 +404,10 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDT
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
if (Request.ParsedResponse.IsSet())
{
ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
}
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
@ -348,6 +438,10 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDT
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
if (Request.ParsedResponse.IsSet())
{
ProcessTrackedResponse(*Request.ParsedResponse.GetValue());
}
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
@ -368,68 +462,6 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDT
return TArray<FGuid>();
}
void UDTFluxCoreSubsystem::SendTeamListRequest()
{
if (NetworkSubsystem)
{
NetworkSubsystem->SendRequest(EDTFluxRequestType::TeamList);
}
}
void UDTFluxCoreSubsystem::SendRaceDataRequest()
{
if (NetworkSubsystem)
{
NetworkSubsystem->SendRequest(EDTFluxRequestType::RaceData);
}
}
void UDTFluxCoreSubsystem::SendContestRankingRequest(int InContestId)
{
if (NetworkSubsystem)
{
NetworkSubsystem->SendRequest(EDTFluxRequestType::ContestRanking, InContestId);
}
}
void UDTFluxCoreSubsystem::SendStageRankingRequest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking)
{
// TODO Implement this
}
void UDTFluxCoreSubsystem::RequestAllStageRankingOfContest(int InContestId, int InStageId,
bool bShouldIncludeSplitRanking)
{
// TODO Implement this
}
void UDTFluxCoreSubsystem::SendSplitRankingRequest(int InContestId, int InStageId, int InSplitId)
{
// TODO Implement this
}
void UDTFluxCoreSubsystem::RequestAllSplitRankingOfContest(int InContestId, int InStageId)
{
// TODO Implement this
}
//
// FDTFluxStageRankings UDTFluxCoreSubsystem::GetStageRankings(FDTFluxStageKey StageKey)
// {
// if (DataStorage->StageRankings.Contains(StageKey))
// {
// return DataStorage->StageRankings[StageKey];
// }
// UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Cannot find StageRankings for key [%s]"), *StageKey.GetDisplayName());
// return FDTFluxStageRankings();
// }
void UDTFluxCoreSubsystem::RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId)
{
// TODO Implement this
}
const FDTFluxParticipant UDTFluxCoreSubsystem::GetParticipant(int InBib)
{
if (DataStorage->Participants.Contains(InBib))
@ -439,11 +471,6 @@ const FDTFluxParticipant UDTFluxCoreSubsystem::GetParticipant(int InBib)
return FDTFluxParticipant();
}
void UDTFluxCoreSubsystem::RefreshStorage()
{
// TODO Implement this
}
TArray<int> UDTFluxCoreSubsystem::GetCurrentContestsId()
{
return GetContestsIdForTime(FDateTime::Now());
@ -454,7 +481,7 @@ TArray<FDTFluxContest> UDTFluxCoreSubsystem::GetCurrentContests()
return GetContestsForTime(FDateTime::Now());
}
TArray<int> UDTFluxCoreSubsystem::GetContestsIdForTime(const FDateTime Time)
TArray<int> UDTFluxCoreSubsystem::GetContestsIdForTime(const FDateTime Time) const
{
TArray<int> Contests;
for (const auto& Pair : DataStorage->Contests)

34
Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h
View File

@ -15,6 +15,7 @@ class UDTFluxNetworkSubsystem;
/** Forward Decl */
class UDTFluxModelAsset;
class UDTFluxPursuitManager;
struct FDTFluxServerResponse;
USTRUCT(BlueprintType)
struct FPursuitStaterData
@ -114,42 +115,19 @@ public:
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
UDTFluxPursuitManager* PursuitManager = nullptr;
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendTeamListRequest();
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendRaceDataRequest();
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendContestRankingRequest(int InContestId);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendStageRankingRequest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RequestAllStageRankingOfContest(int InContestId, int InStageId, bool bShouldIncludeSplitRanking = true);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendSplitRankingRequest(int InContestId, int InStageId, int InSplitId);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RequestAllSplitRankingOfContest(int InContestId, int InStageId);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
const FDTFluxParticipant GetParticipant(int InBib);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RefreshStorage();
//TODO : this must be a ProjectSetting
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
bool bShouldKeepRankings = true;
UFUNCTION()
TArray<int> GetCurrentContestsId();
UFUNCTION()
TArray<FDTFluxContest> GetCurrentContests();
UFUNCTION()
TArray<int> GetContestsIdForTime(const FDateTime Time);
TArray<int> GetContestsIdForTime(const FDateTime Time) const;
UFUNCTION()
bool GetContestForId(const int Id, FDTFluxContest& OutContest);
UFUNCTION()
@ -167,6 +145,8 @@ protected:
// ~Subsystem Interface
UFUNCTION()
void SaveDataStorage();
UFUNCTION()
void ProcessTrackedResponse(FDTFluxServerResponse& InResponse);
private:
UDTFluxNetworkSubsystem* NetworkSubsystem = nullptr;

1
Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp
View File

@ -120,6 +120,7 @@ void FDTFluxAsyncParser::ParseResponseAsync(
OnFailed.ExecuteIfBound(RequestId, TEXT("Empty JSON data"));
return;
}
UE_LOG(logDTFluxNetwork, Verbose, TEXT("Starting async parsing for request %s"), *RequestId.ToString());
// Créer la tâche de parsing
FGraphEventRef Task = FFunctionGraphTask::CreateAndDispatchWhenReady(

49
Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp
View File

@ -255,6 +255,7 @@ bool FDTFluxQueuedRequestManager::MarkRequestAsSent(const FGuid& RequestId)
bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const FString& RawResponseData,
bool bUseAsyncParsing)
{
UE_LOG(logDTFluxNetwork, Log, TEXT("FDTFluxQueuedRequestManager::CompleteRequest() %s"), *RequestId.ToString());
TSharedPtr<FDTFluxTrackedRequest> Request;
{
@ -274,7 +275,8 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
// Stocker la réponse brute
Request->SetRawResponse(RawResponseData);
Request->CompletedAt = FDateTime::Now();
UE_LOG(logDTFluxNetwork, Log, TEXT("Request %s completed at %s"), *RequestId.ToString(),
*Request->CompletedAt.ToString());
// Décider du parsing selon les callbacks et la configuration
bool bHasCallbacks = false;
{
@ -284,6 +286,12 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
if (bHasCallbacks && bUseAsyncParsing && !RawResponseData.IsEmpty())
{
UE_LOG(logDTFluxNetwork, Log,
TEXT("Request %s [bHasCallbacks=%s], [bUseAsyncParsing=%s], [bIsRawResponseEmpty=%s]"),
*RequestId.ToString(),
bHasCallbacks ? TEXT("true") : TEXT("false"), bUseAsyncParsing ? TEXT("true") : TEXT("false"),
RawResponseData.IsEmpty() ? TEXT("true") : TEXT("false"));
// Parsing asynchrone pour les callbacks
FOnParsingCompleted OnCompleted = FOnParsingCompleted::CreateRaw(
this, &FDTFluxQueuedRequestManager::OnParsingCompleted
@ -294,12 +302,13 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
);
AsyncParser->ParseResponseAsync(RequestId, RawResponseData, OnCompleted, OnFailed);
// CleanupCallbacks(RequestId);
UE_LOG(logDTFluxNetwork, Verbose, TEXT("Started async parsing for request %s"), *RequestId.ToString());
return true;
}
else
{
UE_LOG(logDTFluxNetwork, Warning, TEXT("request %s completed without sync"), *RequestId.ToString());
// Compléter immédiatement sans parsing ou avec parsing sync
EDTFluxRequestState NewState = Request->Config.bEnableCache
? EDTFluxRequestState::Cached
@ -799,28 +808,55 @@ void FDTFluxQueuedRequestManager::RecordCacheMiss() const
void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess)
{
UE_LOG(logDTFluxNetwork, Log, TEXT("FDTFluxQueuedRequestManager::OnParsingCompleted() request %s"),
*RequestId.ToString())
TSharedPtr<FDTFluxTrackedRequest> Request;
{
FScopeLock Lock(&RequestsLock);
auto* RequestPtr = AllRequests.Find(RequestId);
if (!RequestPtr || !RequestPtr->IsValid())
{
UE_LOG(logDTFluxNetwork, Error,
TEXT(
"DTFluxQueuedRequestManager::OnParsingCompleted() RequestId%s [InvalidRequestId=%s], [RequestPtrValid=%s]"
),
*RequestId.ToString(), RequestPtr ? TEXT("true") : TEXT("false"),
RequestPtr->IsValid() ? TEXT("true") : TEXT("false"));
return;
}
auto Request = *RequestPtr;
Request = *RequestPtr;
}
if (bSuccess && ParsedResponse.IsValid())
{
Request->ParsedResponse = ParsedResponse;
Request->bIsResponseParsed = true;
EDTFluxRequestState NewState = Request->Config.bEnableCache
? EDTFluxRequestState::Cached
: EDTFluxRequestState::Completed;
UE_LOG(logDTFluxNetwork, VeryVerbose,
ChangeRequestState(Request, NewState);
if (Request->Config.bEnableCache)
{
FScopeLock Lock(&RequestsLock);
CacheKeyToRequestId.Add(Request->GetCacheKey(), RequestId);
}
UE_LOG(logDTFluxNetwork, Log,
TEXT("DTFluxQueuedRequestManager: Async parsing completed for request %s"),
*RequestId.ToString());
}
else
{
UE_LOG(logDTFluxNetwork, Warning, TEXT("DTFluxQueuedRequestManager: Async parsing failed for request %s"),
*RequestId.ToString());
Request->LastErrorMessage = TEXT("Async parsing failed");
ChangeRequestState(Request, EDTFluxRequestState::Failed);
UE_LOG(logDTFluxNetwork, Error, TEXT("Async parsing failed for request %s"), *RequestId.ToString());
}
// ✅ FIX: Déclencher les callbacks maintenant !
TriggerCallbacks(*Request);
CleanupCallbacks(RequestId);
}
void FDTFluxQueuedRequestManager::OnParsingFailed(const FGuid& RequestId, const FString& ErrorMessage)
@ -828,6 +864,7 @@ void FDTFluxQueuedRequestManager::OnParsingFailed(const FGuid& RequestId, const
UE_LOG(logDTFluxNetwork, Error, TEXT("DTFluxQueuedRequestManager: Async parsing failed for request %s: %s"),
*RequestId.ToString(),
*ErrorMessage);
FailRequest(RequestId, FString::Printf(TEXT("Parsing failed: %s"), *ErrorMessage));
}
FString FDTFluxQueuedRequestManager::GenerateCacheKey(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId,

19
Source/DTFluxNetwork/Private/Struct/DTFluxServerResponseStruct.cpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "Struct/DTFluxServerResponseStruct.h"
#include "DTFluxNetworkModule.h"
#include "Types/Objects/UDTFluxParticipantFactory.h"
#include "Struct/DTFluxServerResponseStruct.h"
// === IMPLÉMENTATION DES CONSTRUCTEURS ===
@ -194,7 +195,7 @@ FString FDTFluxServerResponse::ToDebugString() const
*UEnum::GetValueAsString(ParsingStatus), *Type, Code, ContestID, StageID, SplitID, *ReceivedAt.ToString());
}
bool FDTFluxServerResponse::ParseTeamListResponse(FDTFluxTeamListDefinition& OutTeamList)
bool FDTFluxServerResponse::ParseTeamList(FDTFluxTeamListDefinition& OutTeamList)
{
ParsingStatus = EDTFluxResponseStatus::Unset;
if (!ValidateResponseType(TEXT("team-list")))
@ -256,9 +257,9 @@ bool FDTFluxServerResponse::ParseTeamListResponse(FDTFluxTeamListDefinition& Out
return false;
}
bool FDTFluxServerResponse::ParseTeamUpdateResponse(FDTFluxTeamListDefinition& OutTeamUpdate)
bool FDTFluxServerResponse::ParseTeamUpdate(FDTFluxTeamListDefinition& OutTeamUpdate)
{
return ParseTeamListResponse(OutTeamUpdate);
return ParseTeamList(OutTeamUpdate);
}
bool FDTFluxServerResponse::ParseRaceData(FDTFluxRaceData& OutRaceData)
@ -368,7 +369,7 @@ bool FDTFluxServerResponse::ParseContestRanking(FDTFluxContestRankings& OutConte
return true;
}
bool FDTFluxServerResponse::ParseStageRankingResponse(FDTFluxStageRankings& OutStageRankings)
bool FDTFluxServerResponse::ParseStageRanking(FDTFluxStageRankings& OutStageRankings)
{
// UE_LOG(logDTFluxNetwork, Log, TEXT("Response is stage-ranking type %s"), *RawMessage);
if (!ValidateResponseType(TEXT("stage-ranking")))
@ -396,7 +397,7 @@ bool FDTFluxServerResponse::ParseStageRankingResponse(FDTFluxStageRankings& OutS
return true;
}
bool FDTFluxServerResponse::ParseSplitRankingResponse(FDTFluxSplitRankings& OutSplitRankings)
bool FDTFluxServerResponse::ParseSplitRanking(FDTFluxSplitRankings& OutSplitRankings)
{
if (!ValidateResponseType(TEXT("stage-ranking")) || SplitID == -1)
{
@ -427,7 +428,7 @@ bool FDTFluxServerResponse::ParseSplitRankingResponse(FDTFluxSplitRankings& OutS
return true;
}
bool FDTFluxServerResponse::ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& OutStatusUpdate)
bool FDTFluxServerResponse::ParseStatusUpdate(FDTFluxTeamStatusUpdate& OutStatusUpdate)
{
if (!ValidateResponseType(TEXT("status-update")))
{
@ -448,7 +449,7 @@ bool FDTFluxServerResponse::ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& O
return true;
}
bool FDTFluxServerResponse::ParseSplitSensorResponse(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos)
bool FDTFluxServerResponse::ParseSplitSensor(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos)
{
if (!ValidateResponseType(TEXT("split-sensor")))
{

27
Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp
View File

@ -444,7 +444,9 @@ bool UDTFluxNetworkSubsystem::TryMatchResponseToQueuedRequest(const FString& Mes
// Utiliser le parsing asynchrone pour les réponses volumineuses
bool bUseAsyncParsing = ShouldUseAsyncParsing(MessageString);
RequestManager->CompleteRequest(FoundRequestId, MessageString, bUseAsyncParsing);
if (RequestManager->CompleteRequest(FoundRequestId, MessageString, bUseAsyncParsing))
{
}
UE_LOG(logDTFluxNetwork, Log, TEXT("Matched response to tracked request %s (async=%s)"),
*FoundRequestId.ToString(), bUseAsyncParsing ? TEXT("true") : TEXT("false"));
@ -521,7 +523,12 @@ void UDTFluxNetworkSubsystem::OnRequestCompleted_Internal(const FDTFluxTrackedRe
CompletedRequest.RawResponseData
);
UE_LOG(logDTFluxNetwork, Log, TEXT("Tracked request completed: %s"), *CompletedRequest.RequestId.ToString());
if (CompletedRequest.ParsedResponse.IsSet())
{
UE_LOG(logDTFluxNetwork, Log, TEXT("Tracked About to process : %s"), *CompletedRequest.RequestId.ToString());
TSharedPtr<FDTFluxServerResponse> Response = CompletedRequest.ParsedResponse.GetValue();
ProcessParsedResponse(Response);
}
}
void UDTFluxNetworkSubsystem::OnRequestFailed_Internal(const FDTFluxTrackedRequest& FailedRequest)
@ -571,7 +578,7 @@ void UDTFluxNetworkSubsystem::ReconnectWs(const FName WsClientId)
void UDTFluxNetworkSubsystem::ParseTeamListResponse(FDTFluxServerResponse& Response)
{
FDTFluxTeamListDefinition TeamListDefinition;
Response.ParseTeamListResponse(TeamListDefinition);
Response.ParseTeamList(TeamListDefinition);
if (Response.GetParsingStatus() == EDTFluxResponseStatus::Success)
{
@ -620,7 +627,7 @@ void UDTFluxNetworkSubsystem::ParseContestRanking(FDTFluxServerResponse& Respons
void UDTFluxNetworkSubsystem::ParseStageRankingResponse(FDTFluxServerResponse& Response)
{
FDTFluxStageRankings StageRankings;
Response.ParseStageRankingResponse(StageRankings);
Response.ParseStageRanking(StageRankings);
if (Response.GetParsingStatus() == EDTFluxResponseStatus::Success)
{
@ -637,7 +644,7 @@ void UDTFluxNetworkSubsystem::ParseStageRankingResponse(FDTFluxServerResponse& R
void UDTFluxNetworkSubsystem::ParseSplitRankingResponse(FDTFluxServerResponse& Response)
{
FDTFluxSplitRankings SplitRankings;
Response.ParseSplitRankingResponse(SplitRankings);
Response.ParseSplitRanking(SplitRankings);
if (Response.GetParsingStatus() == EDTFluxResponseStatus::Success)
{
@ -654,7 +661,7 @@ void UDTFluxNetworkSubsystem::ParseSplitRankingResponse(FDTFluxServerResponse& R
void UDTFluxNetworkSubsystem::ParseStatusUpdateResponse(FDTFluxServerResponse& Response)
{
FDTFluxTeamStatusUpdate StatusUpdate;
Response.ParseStatusUpdateResponse(StatusUpdate);
Response.ParseStatusUpdate(StatusUpdate);
if (Response.GetParsingStatus() == EDTFluxResponseStatus::Success)
{
@ -671,7 +678,7 @@ void UDTFluxNetworkSubsystem::ParseStatusUpdateResponse(FDTFluxServerResponse& R
void UDTFluxNetworkSubsystem::ParseSplitSensorResponse(FDTFluxServerResponse& Response)
{
TArray<FDTFluxSplitSensorInfo> SplitSensorInfos;
Response.ParseSplitSensorResponse(SplitSensorInfos);
Response.ParseSplitSensor(SplitSensorInfos);
if (Response.GetParsingStatus() == EDTFluxResponseStatus::Success)
{
@ -702,7 +709,7 @@ EDTFluxResponseStatus UDTFluxNetworkSubsystem::ProcessPushMessage(FDTFluxServerR
case EDTFluxApiDataType::SplitSensor:
{
TArray<FDTFluxSplitSensorInfo> SplitSensorInfos;
if (Response.ParseSplitSensorResponse(SplitSensorInfos))
if (Response.ParseSplitSensor(SplitSensorInfos))
{
for (const auto& SplitSensorInfo : SplitSensorInfos)
{
@ -715,7 +722,7 @@ EDTFluxResponseStatus UDTFluxNetworkSubsystem::ProcessPushMessage(FDTFluxServerR
case EDTFluxApiDataType::StatusUpdate:
{
FDTFluxTeamStatusUpdate StatusUpdate;
if (Response.ParseStatusUpdateResponse(StatusUpdate))
if (Response.ParseStatusUpdate(StatusUpdate))
{
OnTeamStatusUpdateReceived.ExecuteIfBound(StatusUpdate);
}
@ -725,7 +732,7 @@ EDTFluxResponseStatus UDTFluxNetworkSubsystem::ProcessPushMessage(FDTFluxServerR
case EDTFluxApiDataType::TeamUpdate:
{
FDTFluxTeamListDefinition TeamUpdateList;
if (Response.ParseTeamUpdateResponse(TeamUpdateList))
if (Response.ParseTeamUpdate(TeamUpdateList))
{
OnTeamUpdateReceived.ExecuteIfBound(TeamUpdateList);
}

14
Source/DTFluxNetwork/Public/Struct/DTFluxServerResponseStruct.h
View File

@ -4,13 +4,11 @@
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "DTFluxNetworkModule.h"
#include "DTFluxRaceDataServerResponse.h"
#include "DTFluxRankingServerResponse.h"
#include "DTFluxSplitSensorServerResponse.h"
#include "JsonObjectConverter.h"
#include "Types/Enum/DTFluxCoreEnum.h"
#include "Types/Objects/UDTFluxParticipantFactory.h"
#include "Types/Struct/DTFluxRaceDataStructs.h"
#include "Types/Struct/DTFluxRankingStructs.h"
#include "Types/Struct/DTFluxSplitSensor.h"
@ -85,14 +83,14 @@ public:
EDTFluxResponseStatus TryParse(bool bLogErrors = true);
bool ParseTeamListResponse(FDTFluxTeamListDefinition& OutTeamList);
bool ParseTeamUpdateResponse(FDTFluxTeamListDefinition& OutTeamUpdate);
bool ParseTeamList(FDTFluxTeamListDefinition& OutTeamList);
bool ParseTeamUpdate(FDTFluxTeamListDefinition& OutTeamUpdate);
bool ParseRaceData(FDTFluxRaceData& OutRaceData);
bool ParseContestRanking(FDTFluxContestRankings& OutContestRankings);
bool ParseStageRankingResponse(FDTFluxStageRankings& OutStageRankings);
bool ParseSplitRankingResponse(FDTFluxSplitRankings& OutSplitRankings);
bool ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& OutStatusUpdate);
bool ParseSplitSensorResponse(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);
bool ParseStageRanking(FDTFluxStageRankings& OutStageRankings);
bool ParseSplitRanking(FDTFluxSplitRankings& OutSplitRankings);
bool ParseStatusUpdate(FDTFluxTeamStatusUpdate& OutStatusUpdate);
bool ParseSplitSensor(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);
// === MÉTHODES UTILITAIRES ===