Add TrackedRequest implementation in DTFluxCoreSubsystem and various Modifications and bugfixes.

Source/DTFluxAPIStatus/Private/widgets/DTFluxStatusWidget.cpp

@@ -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;
+			DTFluxCore->TrackedRequestContestRankings({ForContest});
-			DTFluxNetwork->SendRequest(RequestType, 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();

Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp

@@ -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)

Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h

@@ -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")
+	//TODO : this must be a ProjectSetting
-	void RefreshStorage();
+	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;

Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp

@@ -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(

Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp

@@ -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
@@ -798,29 +807,56 @@ 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"),
+		Request->LastErrorMessage = TEXT("Async parsing failed");
-		       *RequestId.ToString());
+		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,

Source/DTFluxNetwork/Private/Struct/DTFluxServerResponseStruct.cpp

@@ -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")))
 	{

Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp

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

Source/DTFluxNetwork/Public/Struct/DTFluxServerResponseStruct.h

@@ -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 ParseTeamList(FDTFluxTeamListDefinition& OutTeamList);
-	bool ParseTeamUpdateResponse(FDTFluxTeamListDefinition& OutTeamUpdate);
+	bool ParseTeamUpdate(FDTFluxTeamListDefinition& OutTeamUpdate);
 	bool ParseRaceData(FDTFluxRaceData& OutRaceData);
 	bool ParseContestRanking(FDTFluxContestRankings& OutContestRankings);
-	bool ParseStageRankingResponse(FDTFluxStageRankings& OutStageRankings);
+	bool ParseStageRanking(FDTFluxStageRankings& OutStageRankings);
-	bool ParseSplitRankingResponse(FDTFluxSplitRankings& OutSplitRankings);
+	bool ParseSplitRanking(FDTFluxSplitRankings& OutSplitRankings);
-	bool ParseStatusUpdateResponse(FDTFluxTeamStatusUpdate& OutStatusUpdate);
+	bool ParseStatusUpdate(FDTFluxTeamStatusUpdate& OutStatusUpdate);
-	bool ParseSplitSensorResponse(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);
+	bool ParseSplitSensor(TArray<FDTFluxSplitSensorInfo>& OutSplitSensorInfos);
 
 
 	// === MÉTHODES UTILITAIRES ===