Esempio n. 1
0
        public Games GamesEntryToGames(GamesEntry gameEntry)
        {
            Games game = new Games()
            {
                GameControls        = gameEntry.GameControls,
                GameCreatorName     = gameEntry.GameCreatorName,
                GameDescription     = gameEntry.GameDescription,
                GameGenreSurvival   = gameEntry.GameGenreSurvival,
                GameGenreStrategy   = gameEntry.GameGenreStrategy,
                GameGenreSports     = gameEntry.GameGenreSports,
                GameGenreAction     = gameEntry.GameGenreAction,
                GameGenreAdventure  = gameEntry.GameGenreAdventure,
                GameGenreFighting   = gameEntry.GameGenreFighting,
                GameGenrePuzzle     = gameEntry.GameGenrePuzzle,
                GameGenreRacing     = gameEntry.GameGenreRacing,
                GameGenreRpg        = gameEntry.GameGenreRpg,
                GameGenreRhythm     = gameEntry.GameGenreRhythm,
                GameGenreShooter    = gameEntry.GameGenreShooter,
                GameGenrePlatformer = gameEntry.GameGenrePlatformer,
                GameId                  = gameEntry.GameId,
                GameName                = gameEntry.GameName,
                GameOnArcade            = gameEntry.GameOnArcade,
                GamePath                = gameEntry.GamePath,
                GameReviewDateUtc       = gameEntry.GameReviewDateUtc,
                GameStatus              = gameEntry.GameStatus,
                GameSubmissionDateUtc   = gameEntry.GameSubmissionDateUtc,
                GameVideoLink           = gameEntry.GameVideoLink,
                GameAvailableToDownload = gameEntry.GameAvailableToDownload,
            };

            game = InsertArrayToColumn(game, gameEntry);

            return(game);
        }
Esempio n. 2
0
        public void PutGamesEntry(GamesEntry gameEntry)
        {
            Games game = GamesEntryToGames(gameEntry);

            _rdsData.PutGames(game);
            return;
        }
Esempio n. 3
0
        ///Helper functions///

        public GamesEntry GamesToGamesEntry(Games game)
        {
            GamesEntry gameEntry = new GamesEntry()
            {
                GameControls        = game.GameControls,
                GameCreatorName     = game.GameCreatorName,
                GameDescription     = game.GameDescription,
                GameGenreSurvival   = game.GameGenreSurvival,
                GameGenreStrategy   = game.GameGenreStrategy,
                GameGenreSports     = game.GameGenreSports,
                GameGenreAction     = game.GameGenreAction,
                GameGenreAdventure  = game.GameGenreAdventure,
                GameGenreFighting   = game.GameGenreFighting,
                GameGenrePuzzle     = game.GameGenrePuzzle,
                GameGenreRacing     = game.GameGenreRacing,
                GameGenreRpg        = game.GameGenreRpg,
                GameGenreRhythm     = game.GameGenreRhythm,
                GameGenreShooter    = game.GameGenreShooter,
                GameGenrePlatformer = game.GameGenrePlatformer,
                GameId                  = game.GameId,
                GameName                = game.GameName,
                GameOnArcade            = game.GameOnArcade,
                GamePath                = game.GamePath,
                GameReviewDateUtc       = game.GameReviewDateUtc,
                GameStatus              = game.GameStatus,
                GameSubmissionDateUtc   = game.GameSubmissionDateUtc,
                GameVideoLink           = game.GameVideoLink,
                GameImg                 = ValidGameImageURLs(game),
                GameAvailableToDownload = game.GameAvailableToDownload
            };

            return(gameEntry);
        }
Esempio n. 4
0
        public GamesEntry GetGamesEntry(string gameName)
        {
            Games      game      = _rdsData.GetGames(gameName);
            GamesEntry gameEntry = GamesToGamesEntry(game);

            return(gameEntry);
        }
Esempio n. 5
0
        public void PutGamesEntry(GamesEntry gameEntry)
        {
            Games game = GamesEntryToGames(gameEntry);

            _rdsData.PutGames(game);

            Submissions submission = new Submissions();

            submission.GameId = game.GameId;
            if (game.GameImage0 != null)
            {
                submission.SubmissionImage0 = game.GameImage0;
            }
            if (game.GameReviewDateUtc != null)
            {
                submission.SubmissionReviewDateUtc = game.GameReviewDateUtc;
            }
            if (game.GameStatus != null)
            {
                submission.SubmissionStatus = game.GameStatus;
            }
            _rdsData.PutSubmissions(submission);

            return;
        }
Esempio n. 6
0
        ///////
        //// Games Table
        ///////

        public GamesEntry GetGamesEntry(int gameId)
        {
            Games      game      = _rdsData.GetGames(gameId);
            GamesEntry gameEntry = GamesToGamesEntry(game);

            return(gameEntry);
        }
        public IActionResult PutGames(GamesEntry game)
        {
            try
            {
                StringValues accessToken = new StringValues();
                Request.Headers.TryGetValue("Authorization", out accessToken);
                if (accessToken.Count() == 0)
                {
                    return(StatusCode(401, "Empty or no authorization header."));
                }

                if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
                {
                    return(StatusCode(401, "Empty or no authorization header."));
                }

                if (_validation.CheckValidation(accessToken.ToString()))
                {
                    _rdsLogic.PutGamesEntry(game);
                    return(Ok());
                }

                return(StatusCode(403, "This is an invalid access token."));
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                return(StatusCode(500, e.Message));
            }
        }
        public IActionResult PostNewEntry([FromBody] GamesEntry newEntry)
        {
            try
            {
                StringValues accessToken = new StringValues();
                Request.Headers.TryGetValue("Authorization", out accessToken);
                if (accessToken.Count() == 0)
                {
                    return(StatusCode(401, "Empty or no authorization header."));
                }

                if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
                {
                    return(StatusCode(401, "Empty or no authorization header."));
                }

                if (_validation.CheckValidation(accessToken.ToString()))
                {
                    Tuple <Games, int> tuple = _rdsLogic.PostNewEntry(newEntry);
                    if (tuple.Item2 == 1)
                    {
                        return(StatusCode(409, "That game name already exists."));
                    }
                    _ec2Logic.StartAutomatedTestingEC2();
                    return(StatusCode(201, tuple.Item1));
                }

                return(StatusCode(403, "This is an invalid access token."));
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                return(StatusCode(500, e.Message));
            }
        }
Esempio n. 9
0
        public bool PutGames(GamesEntry myGame, HttpClient client)
        {
            try
            {
                string json        = JsonConvert.SerializeObject(myGame);
                var    buffer      = System.Text.Encoding.UTF8.GetBytes(json);
                var    byteContent = new ByteArrayContent(buffer);
                byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                HttpResponseMessage response = client.PutAsync(new Uri("http://" + _host + "/api/v1/Restricted/rds/games/game"), byteContent).Result;


                if (response.StatusCode.ToString() == "OK")
                {
                    return(true);
                }

                return(false);
            }

            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                return(false);
            }
        }
Esempio n. 10
0
        public Games InsertArrayToColumn(Games game, GamesEntry newEntry)
        {
            try
            {
                int size = newEntry.GameImg.Count();
                switch (size)
                {
                case 1:
                    game.GameImage0 = newEntry.GameImg[0];
                    break;

                case 2:
                    game.GameImage0 = newEntry.GameImg[0];
                    game.GameImage1 = newEntry.GameImg[1];
                    break;

                case 3:
                    game.GameImage0 = newEntry.GameImg[0];
                    game.GameImage1 = newEntry.GameImg[1];
                    game.GameImage2 = newEntry.GameImg[2];
                    break;

                case 4:
                    game.GameImage0 = newEntry.GameImg[0];
                    game.GameImage1 = newEntry.GameImg[1];
                    game.GameImage2 = newEntry.GameImg[2];
                    game.GameImage3 = newEntry.GameImg[3];
                    break;

                case 5:
                    game.GameImage0 = newEntry.GameImg[0];
                    game.GameImage1 = newEntry.GameImg[1];
                    game.GameImage2 = newEntry.GameImg[2];
                    game.GameImage3 = newEntry.GameImg[3];
                    game.GameImage4 = newEntry.GameImg[4];
                    break;

                default:
                    break;
                }
            }
            catch (Exception e)
            {
                _logger.LogCritical(e.Message, e);
            }

            return(game);
        }
Esempio n. 11
0
        public GamesEntry GetGamesByID(int?gameID, HttpClient client)
        {
            try
            {
                HttpResponseMessage response = client.GetAsync("http://" + _host + "/api/v1/Public/rds/games/gamesbyid?gameId=" + gameID).Result;
                string     json  = response.Content.ReadAsStringAsync().Result;
                GamesEntry games = JsonConvert.DeserializeObject <GamesEntry>(json);

                return(games);
            }

            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                return(null);
            }
        }
Esempio n. 12
0
        public void PutNewEntry(GamesEntry updateEntry)
        {
            Games postedGame = _rdsData.GetGames((int)updateEntry.GameId);

            GamesEntry oldEntry = GamesToGamesEntry(postedGame);
            GamesEntry newEntry = UpdateEntry(oldEntry, updateEntry);

            Games newGamesUpdate = GamesEntryToGames(newEntry);

            _rdsData.PutGames(newGamesUpdate);

            try
            {
                TestsQueue newTestQueue = new TestsQueue()
                {
                    GameId     = newGamesUpdate.GameId,
                    RetryCount = 0
                };

                try
                {
                    _rdsData.DeleteTestsQueue((int)newGamesUpdate.GameId);
                }
                catch (Exception e)
                {
                    _logger.LogCritical(e.Message, e);
                }
                _rdsData.PostTestsQueue(newTestQueue);

                Tests newTest = new Tests()
                {
                    GameId              = newGamesUpdate.GameId,
                    Test10min           = false,
                    TestCloses          = false,
                    TestOpens           = false,
                    TestAttempts        = 0,
                    TestAverageRam      = null,
                    TestCloseOn3        = null,
                    TestCloseOnEscape   = null,
                    TestFolderFileNames = null,
                    TestNumExeFiles     = null,
                    TestPeakRam         = null
                };

                try
                {
                    _rdsData.DeleteTests((int)newGamesUpdate.GameId);
                }
                catch (Exception e)
                {
                    _logger.LogCritical(e.Message, e);
                }

                _rdsData.PostTests(newTest);

                return;
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                throw new Exception(e.Message);
            }
        }
Esempio n. 13
0
        public GamesEntry UpdateEntry(GamesEntry old, GamesEntry newInfo)
        {
            if (newInfo.GameAvailableToDownload != null)
            {
                old.GameAvailableToDownload = newInfo.GameAvailableToDownload;
            }
            if (newInfo.GameControls != null)
            {
                old.GameControls = newInfo.GameControls;
            }
            if (newInfo.GameCreatorEmail != null)
            {
                old.GameCreatorEmail = newInfo.GameCreatorEmail;
            }
            if (newInfo.GameCreatorName != null)
            {
                old.GameCreatorName = newInfo.GameCreatorName;
            }
            if (newInfo.GameDescription != null)
            {
                old.GameDescription = newInfo.GameDescription;
            }
            if (newInfo.GameGenreAction != null)
            {
                old.GameGenreAction = newInfo.GameGenreAction;
            }
            if (newInfo.GameGenreAdventure != null)
            {
                old.GameGenreAdventure = newInfo.GameGenreAdventure;
            }
            if (newInfo.GameGenreFighting != null)
            {
                old.GameGenreFighting = newInfo.GameGenreFighting;
            }
            if (newInfo.GameGenrePlatformer != null)
            {
                old.GameGenrePlatformer = newInfo.GameGenrePlatformer;
            }
            if (newInfo.GameGenrePuzzle != null)
            {
                old.GameGenrePuzzle = newInfo.GameGenrePuzzle;
            }
            if (newInfo.GameGenreRacing != null)
            {
                old.GameGenreRacing = newInfo.GameGenreRacing;
            }
            if (newInfo.GameGenreRhythm != null)
            {
                old.GameGenreRhythm = newInfo.GameGenreRhythm;
            }
            if (newInfo.GameGenreRpg != null)
            {
                old.GameGenreRpg = newInfo.GameGenreRpg;
            }
            if (newInfo.GameGenreShooter != null)
            {
                old.GameGenreShooter = newInfo.GameGenreShooter;
            }
            if (newInfo.GameGenreSports != null)
            {
                old.GameGenreSports = newInfo.GameGenreSports;
            }
            if (newInfo.GameGenreStrategy != null)
            {
                old.GameGenreStrategy = newInfo.GameGenreStrategy;
            }
            if (newInfo.GameGenreSurvival != null)
            {
                old.GameGenreSurvival = newInfo.GameGenreSurvival;
            }
            if (newInfo.GameImg != null)
            {
                old.GameImg = newInfo.GameImg;
            }
            if (newInfo.GameName != null)
            {
                old.GameName = newInfo.GameName;
            }
            if (newInfo.GameOnArcade != null)
            {
                old.GameOnArcade = newInfo.GameOnArcade;
            }
            if (newInfo.GamePath != null)
            {
                old.GamePath = newInfo.GamePath;
            }
            if (newInfo.GameReviewComments != null)
            {
                old.GameReviewComments = newInfo.GameReviewComments;
            }
            if (newInfo.GameReviewDateUtc != null)
            {
                old.GameReviewDateUtc = newInfo.GameReviewDateUtc;
            }
            if (newInfo.GameStatus != null)
            {
                old.GameStatus = newInfo.GameStatus;
            }
            if (newInfo.GameSubmissionDateUtc != null)
            {
                old.GameSubmissionDateUtc = newInfo.GameSubmissionDateUtc;
            }
            if (newInfo.GameVideoLink != null)
            {
                old.GameVideoLink = newInfo.GameVideoLink;
            }

            return(old);
        }
Esempio n. 14
0
        public Tuple <Games, int> PostNewEntry(GamesEntry newEntry)
        {
            Games newGame = new Games()
            {
                GameControls            = newEntry.GameControls,
                GameCreatorName         = newEntry.GameCreatorName,
                GameCreatorEmail        = newEntry.GameCreatorEmail,
                GameDescription         = newEntry.GameDescription,
                GameGenreAction         = newEntry.GameGenreAction,
                GameGenreAdventure      = newEntry.GameGenreAdventure,
                GameGenreFighting       = newEntry.GameGenreFighting,
                GameGenrePuzzle         = newEntry.GameGenrePuzzle,
                GameGenreRacing         = newEntry.GameGenreRacing,
                GameGenreRhythm         = newEntry.GameGenreRhythm,
                GameGenreRpg            = newEntry.GameGenreRpg,
                GameGenreShooter        = newEntry.GameGenreShooter,
                GameGenreSports         = newEntry.GameGenreSports,
                GameGenreStrategy       = newEntry.GameGenreStrategy,
                GameGenreSurvival       = newEntry.GameGenreSurvival,
                GameGenrePlatformer     = newEntry.GameGenrePlatformer,
                GameName                = newEntry.GameName,
                GamePath                = newEntry.GamePath,
                GameVideoLink           = newEntry.GameVideoLink,
                GameOnArcade            = false,
                GameStatus              = "t",
                GameSubmissionDateUtc   = DateTime.UtcNow,
                GameAvailableToDownload = newEntry.GameAvailableToDownload,
            };

            char[] s = new char[5];

            newGame = InsertArrayToColumn(newGame, newEntry);
            if (_rdsData.GetGames(newGame.GameName) != null)
            {
                return(Tuple.Create <Games, int>(null, 1));
            }

            try
            {
                _rdsData.PostGames(newGame);
                Games postedGame = _rdsData.GetGames(newGame.GameName);

                TestsQueue newTestQueue = new TestsQueue()
                {
                    GameId     = postedGame.GameId,
                    RetryCount = 0
                };

                _rdsData.PostTestsQueue(newTestQueue);

                Tests newTest = new Tests()
                {
                    GameId              = postedGame.GameId,
                    Test10min           = false,
                    TestCloses          = false,
                    TestOpens           = false,
                    TestAttempts        = 0,
                    TestAverageRam      = null,
                    TestCloseOn3        = null,
                    TestCloseOnEscape   = null,
                    TestFolderFileNames = null,
                    TestNumExeFiles     = null,
                    TestPeakRam         = null
                };

                _rdsData.PostTests(newTest);

                return(Tuple.Create(newGame, 0));
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, e);
                CleanUpOnCrash((int)newGame.GameId);
                throw new Exception(e.Message);
            }
        }
Esempio n. 15
0
        public void RunSingleEntryTest(TestsQueue testsQueue, Tests testProcess)
        {
            try
            {
                while (testsQueue.RetryCount < 3)
                {
                    testProcess.Test10min           = false;
                    testProcess.TestAttempts        = testsQueue.RetryCount;
                    testProcess.TestCloseOn3        = false;
                    testProcess.TestCloseOnEscape   = false;
                    testProcess.TestCloses          = false;
                    testProcess.TestOpens           = false;
                    testProcess.TestNumExeFiles     = 0;
                    testProcess.TestAverageRam      = null;
                    testProcess.TestFolderFileNames = null;
                    testProcess.TestPeakRam         = null;

                    TestingLog testLog = new TestingLog();

                    _webData.PutTestsQueue(testsQueue, _client);

                    testLog.TestlogAttempt = (int)testsQueue.RetryCount;
                    testLog.GameId         = (int)testsQueue.GameId;

                    GamesEntry myGame = _webData.GetGamesByID(testsQueue.GameId, _client);

                    //Retry to pull game if it failed the first time
                    if (myGame == null)
                    {
                        testLog.TestlogLog         = "No valid game found with this ID.";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;
                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    string debugKey = "public/" + myGame.GamePath;
                    fileLocation = _s3Data.ReadObjectDataAsync(debugKey).Result;

                    //Point variable to folder which contains .exe file
                    string subFileLocation = FindSubDir(fileLocation);

                    //Store list of names of files within game folder
                    testProcess.TestFolderFileNames = FolderFileNames(subFileLocation);

                    //Find .exe file path
                    string[] exeFiles = FindExe(subFileLocation);

                    //Store number of exe files within game folder
                    testProcess.TestNumExeFiles = exeFiles.Length;

                    gameProcess = new Process();

                    //start .exe, check to see if it started
                    testProcess.TestOpens = StartFile(exeFiles[0]);

                    //Retry tests if process does not start
                    if (!(bool)testProcess.TestOpens)
                    {
                        testLog.TestlogLog         = "Game Failed Start Test";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Check to see if game still running after 5 min
                    testProcess.Test10min = SleepFile(exeFiles[0]);

                    //Retry tests if process does not stay open for 5 min
                    if ((bool)!testProcess.Test10min)
                    {
                        testLog.TestlogLog         = "Game Failed Sleep Test";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Store memory usage by game process
                    testProcess.TestAverageRam = RamFile();

                    //Retry tests if the program is unable to record the game's RAM usage
                    if (testProcess.TestAverageRam == null)
                    {
                        testLog.TestlogLog         = "Game Average RAM Test Failed";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Store memory usage by game process
                    testProcess.TestPeakRam = RamFile();

                    //Retry tests if the program is unable to record the game's RAM usage
                    if (testProcess.TestPeakRam == null)
                    {
                        testLog.TestlogLog         = "Game Peak RAM Test Failed";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Test whether game will close on "3" key press
                    int i = CloseOn3(exeFiles[0]);

                    if (i == 0)
                    {
                        testProcess.TestCloseOn3   = true;
                        testLog.TestlogLog         = "Game shut down on 3 press.";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                    }
                    else if (i == 1)
                    {
                        testLog.TestlogLog         = "Game did not shut down on 3 press.";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                    }
                    //Retry tests if the program is unable to restart after passing "3" test
                    else if (i == 2)
                    {
                        testLog.TestlogLog         = "Game passed 'close on 3' test but failed to restart";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Test whether game will close on "Escape" key press
                    i = EscapeFile(exeFiles[0]);

                    //Log if game did not shut down after "Escape" press
                    if (i == 0)
                    {
                        testProcess.TestCloseOnEscape = true;

                        testLog.TestlogLog         = "Game shut down after Escape press";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                    }
                    else if (i == 1)
                    {
                        testProcess.TestCloseOnEscape = false;

                        testLog.TestlogLog         = "Game did not down after Escape press";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                    }

                    //Retry tests if the program is unable to restart after passing "3" test
                    else if (i == 2)
                    {
                        testLog.TestlogLog         = "Game passed 'close on Escape' test but failed to restart";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }

                    //Log if game did not shut down after "3" press
                    if ((bool)!testProcess.TestCloseOnEscape)
                    {
                        testLog.TestlogLog         = "Game failed 'close on Escape' test";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                    }

                    //stop .exe, check to see if it stopped
                    testProcess.TestCloses = StopFile(exeFiles[0]);

                    if ((bool)!testProcess.TestCloses)
                    {
                        testLog.TestlogLog         = "Game Failed Stop Test";
                        testLog.TestlogDatetimeUtc = DateTime.UtcNow;

                        _webData.PostTestingLog(testLog, _client);
                        continue;
                    }


                    //If all tests passed, update game object and stop rechecking
                    if ((bool)testProcess.TestOpens && (bool)testProcess.Test10min && (bool)testProcess.TestCloses)
                    {
                        myGame.GameReviewDateUtc = DateTime.UtcNow;
                        myGame.GameStatus        = "p";

                        if ((testsQueue.RetryCount - 1) == 0)
                        {
                            testLog.TestlogLog = "Game Passed all essential tests on first try";
                        }
                        else if ((testsQueue.RetryCount - 1) == 1)
                        {
                            testLog.TestlogLog = "Game Passed all essential tests after 1 retry";
                        }
                        else if ((testsQueue.RetryCount - 1) == 2)
                        {
                            testLog.TestlogLog = "Game Passed all essential tests after 2 retries";
                        }

                        _webData.PostTestingLog(testLog, _client);
                        _webData.PutGames(myGame, _client);

                        break;
                    }
                }

                //Delete game from test queue and push the test results to database
                _webData.DeleteTestQueue(testsQueue.GameId, _client);
                _webData.PutTests(testProcess, _client);
            }

            catch (Exception e)
            {
                _webData.PostTestingLog(new TestingLog()
                {
                    GameId             = testsQueue.GameId,
                    TestlogAttempt     = (int)testsQueue.RetryCount,
                    TestlogDatetimeUtc = DateTime.UtcNow,
                    TestlogLog         = "There was an error with the testing process, and it has crashed during this test. The error: " + e.Message
                }, _client);
                _webData.PutGames(new GamesEntry()
                {
                    GameId     = testsQueue.GameId,
                    GameStatus = "p"
                }, _client);
                _webData.DeleteTestQueue(testsQueue.GameId, _client);
                _webData.PutTests(testProcess, _client);
                _logger.LogError(e.Message, e);
            }
        }