public async Task <IActionResult> ReCheckTaskSolutions(int taskId)
        {
            var sols = _db.StudentResults.Where(r => r.TaskId == taskId).Select(r => r.Solution).ToList();

            if (sols is null || sols.Count == 0)
            {
                return(NotFound());
            }

            //запускаем тестирование посылая сообщение микросервису
            try
            {
                var msgQueue = RabbitHutch.CreateBus(_config.MessageQueueInfo, _config.FrontEnd);

                foreach (var sol in sols)
                {
                    sol.ResultCode = ResultCode.NT;
                    var request = new SolutionTestingRequest
                    {
                        SolutionId = sol.Id,
                        ReCheck    = true,
                    };
                    await msgQueue.SendAsync(_config.MessageQueueInfo.TestingQueueName, request);
                }
            }
            catch (RabbitMQ.Client.Exceptions.BrokerUnreachableException e)
            {
                return(Content("error"));
            }

            _db.SaveChanges();

            return(Content("ok"));
        }
        public async Task <IActionResult> ReCheckSolution(int id)
        {
            var sol = _db.Solutions.Find(id);

            if (sol is null)
            {
                return(NotFound());
            }

            sol.ResultCode = ResultCode.NT;

            //запускаем тестирование посылая сообщение микросервису
            try
            {
                var msgQueue = RabbitHutch.CreateBus(_config.MessageQueueInfo, _config.FrontEnd);

                var request = new SolutionTestingRequest
                {
                    SolutionId = sol.Id,
                    ReCheck    = true,
                };
                await msgQueue.SendAsync(_config.MessageQueueInfo.TestingQueueName, request);
            }
            catch (RabbitMQ.Client.Exceptions.BrokerUnreachableException e)
            {
                return(Content("error"));
            }

            _db.SaveChanges();

            return(Content("ok"));
        }
        public async Task <IActionResult> CheckSolution(IFormFile file, int taskId, string framework)
        {
            var task = _db.StudentTasks.Find(taskId);

            if (task == null)
            {
                var response1 = new
                {
                    status = "error",
                    data   = "No task found!"
                };
                return(Json(response1));
            }

            if (!CanSend(task, curId))
            {
                var response2 = new
                {
                    status = "error",
                    data   = "Can't send new solutions!"
                };
                return(Json(response2));
            }

            if (file != null)
            {
                string dirPath = "c:/TemporaryTaskDownloads";

                dirPath += "/" + Guid.NewGuid().ToString();
                while (Directory.Exists(dirPath))
                {
                    dirPath += "/" + Guid.NewGuid().ToString();
                }

                var dir = Directory.CreateDirectory(dirPath);

                string fullZipFilePath = dirPath + "/" + file.FileName;
                string fullDirPath     = dirPath + "/unpacked";

                // сохраняем файл в папку
                using (var fileStream = new FileStream(fullZipFilePath, FileMode.Create))
                {
                    await file.CopyToAsync(fileStream);
                }
                ZipFile.ExtractToDirectory(fullZipFilePath, fullDirPath, true);

                //ищем файл проекта
                var pathToProj = FindProjectFile(dir);

                if (pathToProj == null)
                {
                    var response2 = new
                    {
                        status = "error",
                        data   = "No project file found!"
                    };
                    return(Json(response2));
                }

                //чистим от бинарных файлов
                CleanSolutionFiles(fullDirPath);

                //сжимаем очищенные файлы обратно в архив
                string newfullZipFilePath = dirPath + "/cleaned_" + file.FileName;
                ZipFile.CreateFromDirectory(fullDirPath, newfullZipFilePath);

                //записываем файл с архивом в базу
                var dataBytes = System.IO.File.ReadAllBytes(newfullZipFilePath);

                int fileId = _db.UploadFile(file.FileName, dataBytes);

                if (fileId == -1)
                {
                    var response2 = new
                    {
                        status = "error",
                        data   = "Can't upload file to db!"
                    };
                    return(Json(response2));
                }

                dir.Delete(true);

                //записываем новое решение в базу
                var solution = new Solution
                {
                    TaskId        = taskId,
                    FrameworkType = framework,
                    FileId        = fileId,
                    StudentId     = curId,
                    ResultCode    = ResultCode.NT,
                    Time          = DateTime.Now,
                };

                var  x           = _db.Solutions.Add(solution);
                var  beforeState = x.State;
                int  r           = _db.SaveChanges();
                var  afterState  = x.State;
                bool ok          = beforeState == EntityState.Added && afterState == EntityState.Unchanged && r == 1;

                if (!ok)
                {
                    var response2 = new
                    {
                        status = "error",
                        data   = "Error on writing solution to db!"
                    };
                    return(Json(response2));
                }

                //если это первое решение - записываем как результат
                var studentResult = _db.StudentResults.Find(curId, taskId);

                if (studentResult is null)
                {
                    var newResult = new StudentResult
                    {
                        StudentId  = curId,
                        TaskId     = taskId,
                        SolutionId = solution.Id
                    };

                    var x1 = _db.StudentResults.Add(newResult);
                    beforeState = x1.State;
                    r           = _db.SaveChanges();
                    afterState  = x1.State;
                    ok          = beforeState == EntityState.Added && afterState == EntityState.Unchanged && r == 1;

                    if (!ok)
                    {
                        var response2 = new
                        {
                            status = "error",
                            data   = "Error on writing result to db!"
                        };
                        return(Json(response2));
                    }
                }


                //запускаем тестирование посылая сообщение микросервису
                try
                {
                    var msgQueue = RabbitHutch.CreateBus(_config.MessageQueueInfo, _config.FrontEnd);

                    var request = new SolutionTestingRequest
                    {
                        SolutionId = solution.Id,
                    };
                    await msgQueue.SendAsync(_config.MessageQueueInfo.TestingQueueName, request);
                }
                catch (RabbitMQ.Client.Exceptions.BrokerUnreachableException e)
                {
                    var response1 = new
                    {
                        status = "connectionError",
                        msg    = "Can't connect to RabbitMQ!",
                        data   = GetStudentTaskView(taskId, curId)
                    };
                    return(Json(response1));
                }

                var response = new
                {
                    status = "success",
                    data   = GetStudentTaskView(taskId, curId)
                };
                return(Json(response));
            }

            var response3 = new
            {
                status = "error",
                data   = "Error while sending file!"
            };

            return(Json(response3));
        }
        public async Task<TestingSystemResponse> CheckSolution(SolutionTestingRequest solutionRequest)
        {
            try
            {
                var solution = _db.Solutions.Find(solutionRequest.SolutionId);

                if (solution != null && solution.File != null)
                {
                    var taskTests = _db.TaskTests.Where(t => t.TaskId == solution.TaskId).ToArray();

                    if (taskTests != null && taskTests.Length > 0)
                    {
                        var isAlive = await CheckIfAlive(_config.CompilerServicesOrchestrator);

                        if (isAlive)
                        {
                            //var dataBytes = await file.GetBytes();                        
                            var codeStyleTask = taskTests.FirstOrDefault(t => t.TestType == "codeStyleTest");

                            var req = new TestRequest
                            {
                                SolutionId = solutionRequest.SolutionId,
                                TestId = codeStyleTask is null ? -1 : codeStyleTask.Id,
                                ReCheck = solutionRequest.ReCheck,
                            };

                            string url = _config.CompilerServicesOrchestrator.GetFullTestLinkFrom(_config.TestingSystemWorker);
                            using var httpClient = new HttpClient();
                            using var form = JsonContent.Create(req);
                            HttpResponseMessage response = await httpClient.PostAsync(url, form);
                            string apiResponse = await response.Content.ReadAsStringAsync();
                            if (response.IsSuccessStatusCode)
                            {
                                TestResponse compResponse = JsonConvert.DeserializeObject<TestResponse>(apiResponse);

                                if (compResponse.OK && compResponse.Result == ResultCode.OK)
                                {
                                    var compResult = _db.CompilationResults.Find(solutionRequest.SolutionId);

                                    if (compResult != null)
                                    {
                                        if (compResult.ResultCode != ResultCode.CE && compResult.File != null)
                                        {
                                            var testTasks = new List<Task<TestResponse>>();
                                            foreach (var test in taskTests)
                                            {
                                                if (_config.Tests.ContainsKey(test.TestType))
                                                {
                                                    testTasks.Add(StartTest(test.TestType, solutionRequest.SolutionId, test.Id, solutionRequest.ReCheck));
                                                }
                                                else
                                                {
                                                    testTasks.Add(Task.Run(() => NoTestFound(test.TestType, solutionRequest.SolutionId, test.Id)));
                                                }
                                            }
                                            await Task.WhenAll(testTasks);

                                            var responses = testTasks.Select(t => t.Result).ToArray();
                                            var results = responses.Join(taskTests, i => i.TestId, o => o.Id, (i, o) => new { Result = i, Definition = o }).ToArray();

                                            double totalScore = 0;
                                            ResultCode totalResult = results.Select(r => r.Result.Result).Max();

                                            foreach (var res in results)
                                            {
                                                if (res.Definition.Block && res.Result.Score == 0)
                                                {
                                                    totalScore = 0;

                                                    break;
                                                }
                                                else
                                                {
                                                    totalScore += res.Result.Score * res.Definition.Weight;
                                                }
                                            }

                                            return WriteToDb(solution, totalResult, totalScore, "success", true, responses);
                                        }
                                        else
                                        {
                                            return WriteToDb(solution, compResult.ResultCode, 0, "compilation error!", true);
                                        }
                                    }
                                    else
                                    {
                                        return WriteToDb(solution, compResponse.Result, 0, "can't find compilation! Inner message: " + compResponse.Message, false);
                                    }
                                }
                                else
                                {
                                    return WriteToDb(solution, compResponse.Result, 0, "something went wrong during compilation! Inner message: " + compResponse.Message, false);
                                }
                            }
                            else
                            {
                                return WriteToDb(solution, ResultCode.IE, 0, "bad response from compilation container: " + response.StatusCode, false);
                            }
                        }
                        else
                        {
                            return WriteToDb(solution, ResultCode.IE, 0, "Compiler Service Is Dead!", false);
                        }
                    }
                    else
                    {
                        return WriteToDb(null, ResultCode.IE, 0, "Can't find task tests!", false);
                    }
                }
                else
                {
                    return WriteToDb(null, ResultCode.IE, 0, "Can't find solution!", false);
                }
            }
            catch
            {
                return new TestingSystemResponse();
            }
        }