Fixing Various Bugs On Delegates

2025-07-11 19:04:37 +02:00
parent 73413e44b4
commit f1f300a351
12 changed files with 2765 additions and 1207 deletions
--- a/Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
+++ b/Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
@ -84,9 +84,6 @@ void UDTFluxCoreSubsystem::RegisterDelegates()
 			&UDTFluxCoreSubsystem::ProcessSplitRanking
 		);

-		// ⚠️ ATTENTION : Vous avez un doublon ici !
-		// NetworkSubsystem->OnReceivedTeamUpdate().BindUFunction(this, "ProcessTeamList");
-
 		NetworkSubsystem->OnReceivedTeamStatusUpdate().BindUObject(
 			this,
 			&UDTFluxCoreSubsystem::ProcessTeamStatusUpdate
@ -205,6 +202,173 @@ void UDTFluxCoreSubsystem::SendRequest(const FString& Message)
 	}
 }

+bool UDTFluxCoreSubsystem::GetContestRankings(const int ContestId,
+                                              FDTFluxContestRankings& OutContestRankings)
+{
+	if (DataStorage->ContestRankings.Contains(ContestId))
+	{
+		OutContestRankings = DataStorage->ContestRankings[ContestId];
+		return true;
+	}
+	if (NetworkSubsystem)
+	{
+		TArray<int> TackedContestIds = {ContestId};
+		TrackedRequestContestRankings(TackedContestIds);
+		return false;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"));
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetStageRankings(const int ContestId, const int StageId,
+                                            FDTFluxStageRankings& OutStageRankings)
+{
+	return GetStageRankingsWithKey(FDTFluxStageKey(ContestId, StageId), OutStageRankings);
+}
+
+bool UDTFluxCoreSubsystem::GetSplitRankings(const int ContestId, const int StageId, const int SplitId,
+                                            FDTFluxSplitRankings& OutSplitRankings)
+{
+	return GetSplitRankingsWithKey(FDTFluxSplitKey(ContestId, StageId, SplitId), OutSplitRankings);
+}
+
+bool UDTFluxCoreSubsystem::GetStageRankingsWithKey(const FDTFluxStageKey StageKey,
+                                                   FDTFluxStageRankings& OutStageRankings, const bool bShouldUseCached)
+{
+	//We Have the data
+	if (DataStorage->StageRankings.Contains(StageKey) && bShouldUseCached)
+	{
+		OutStageRankings = DataStorage->StageRankings[StageKey];
+		return true;
+	}
+	else
+	{
+		if (NetworkSubsystem)
+		{
+			TArray<FDTFluxStageKey> TackedStageKeys = {StageKey};
+			TrackedRequestStageRankings(TackedStageKeys);
+			OutStageRankings = FDTFluxStageRankings();
+			return false;
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
+	}
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey,
+                                                   FDTFluxSplitRankings& OutSplitRankings, const bool bShouldUseCached)
+{
+	//We Have the data
+	if (DataStorage->SplitRankings.Contains(SplitKey) && bShouldUseCached)
+	{
+		OutSplitRankings = DataStorage->SplitRankings[SplitKey];
+		return true;
+	}
+	else
+	{
+		if (NetworkSubsystem)
+		{
+			TArray<FDTFluxSplitKey> TackedSplitKey = {SplitKey};
+			TrackedRequestSplitRankings(TackedSplitKey);
+			OutSplitRankings = FDTFluxSplitRankings();
+			return false;
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
+		return false;
+	}
+}
+
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<int> ForContests)
+{
+	if (NetworkSubsystem)
+	{
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+			});
+
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("ContestRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto ContestId : ForContests)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::ContestRanking,
+				ContestId, -1, -1, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
+}
+
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages)
+{
+	if (NetworkSubsystem)
+	{
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+			});
+
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto StageKey : ForStages)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::StageRanking,
+				StageKey.ContestId, StageKey.StageId, -1, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
+}
+
+TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits)
+{
+	if (NetworkSubsystem)
+	{
+		TArray<FGuid> RequestIds;
+		FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
+			[this](const FDTFluxTrackedRequest& Request)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
+				       *Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
+			});
+
+		FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
+			[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
+			{
+				UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
+				       *InReq.RequestId.ToString(), *InError);
+			});
+		// if Contest is not ended 
+		for (auto SplitKey : ForSplits)
+		{
+			FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::SplitRanking,
+				SplitKey.ContestId, SplitKey.StageId, SplitKey.SplitId, OnSuccess, OnError);
+			RequestIds.Add(ContestRequest);
+		}
+		return RequestIds;
+	}
+	return TArray<FGuid>();
+}
+
+
 void UDTFluxCoreSubsystem::SendTeamListRequest()
 {
 	if (NetworkSubsystem)
@ -250,15 +414,16 @@ void UDTFluxCoreSubsystem::RequestAllSplitRankingOfContest(int InContestId, int
 	// 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();
-}
+//
+// 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)
 {