public async Task <SaveResult> StoreSubmision(SubmisionDto submision)
        {
            try
            {
                if (!_directoryEngine.ValidateSubmision(submision))
                {
                    return new SaveResult {
                               Type = ResultType.ValidationFailed
                    }
                }
                ;

                return(await _directoryEngine.StoreSubmision(submision));
            }
            catch (Exception ex)
            {
                await _logger.LogException(new ExceptionLogDto(ex));

                return(new SaveResult
                {
                    Type = ResultType.Exception,
                    Message = ex.Message
                });
            }
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> ProblemContestExecute([FromForm] FileExecutionContestViewModel model)
        {
            //read the content of the file
            Tuple <string, long> fileContent = await FileHelpers.ProcessFormFile(model.File, ModelState);

            double sizeOfFile       = (fileContent.Item2) % 1000;
            var    compilationModel = new CompilationModel {
                Content = fileContent.Item1, Language = model.Compilator, ProblemName = model.ProblemName, Username = User.Identity.Name
            };

            //save the submission
            var submission = new Submision
            {
                SubmisionId        = Guid.NewGuid(),
                DataOfSubmision    = DateTime.Now,
                Compilator         = model.Compilator,
                ProblemId          = Guid.Parse(model.ProblemId),
                SourceSize         = sizeOfFile.ToString(),
                StateOfSubmision   = SubmissionStatus.NotCompiled.ToString(),
                UserName           = User.Identity.Name,
                MessageOfSubmision = string.Empty,
                Score      = 0,
                JobQueued  = false,
                SourceCode = fileContent.Item1
            };

            await _submisionRepository.AddAsync(submission);

            var submissionContest = new SubmisionContest
            {
                SubmisionContestId = Guid.NewGuid(),
                ContestId          = model.ContestId,
                SubmisionId        = submission.SubmisionId
            };

            await _submisionContestRepository.AddAsync(submissionContest);


            //build the submission dto
            var    problem     = _problemRepository.GetItem(submission.ProblemId);
            string problemName = problem.ProblemName;
            int    nrOfTests   = _testRepository.GetNumberOfTestForProblem(problem.ProblemId);

            var submissionDtoModel = new SubmisionDto
            {
                Compilator    = submission.Compilator,
                ProblemName   = problemName,
                Content       = submission.SourceCode,
                SubmissionId  = submission.SubmisionId,
                UserName      = User.Identity.Name,
                MemoryLimit   = problem.MemoryLimit,
                TimeLimit     = problem.TimeLimit,
                NumberOfTests = nrOfTests,
                FileName      = problemName.ToLower()
            };

            await Task.Run(() => VerificaThread(submissionDtoModel));

            return(RedirectToAction(nameof(ProblemsOverview), new { id = model.ContestId }));
        }
Ejemplo n.º 3
0
        public async Task MakeSubmissionRequestAsync(SubmisionDto submision, string _compilationApi,
                                                     string _executionApi)
        {
            UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.Compiling, string.Empty, 0);
            //notify signal r to compiling status
            await NotifyResponse(MessageType.CompilationMessage, SubmissionStatus.Compiling.ToString(), submision.SubmissionId.ToString(), "0");

            var compilationModel = new CompilationModel
            {
                Content     = submision.Content,
                Language    = submision.Compilator,
                ProblemName = submision.ProblemName,
                Username    = submision.UserName
            };
            var client         = new HttpClient();
            var serializedData = JsonConvert.SerializeObject(compilationModel);
            var httpContent    = new StringContent(serializedData, Encoding.UTF8, "application/json");

            var response = await client.PostAsync(_compilationApi, httpContent);

            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                var result = await response.Content.ReadAsStringAsync();

                var content = JsonConvert.DeserializeObject <ResponseCompilationModel>(result);

                if (content.CompilationResponse == "SUCCESS")
                {
                    UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.Compiled, content.OutputMessage, 0);

                    //notify with signal r
                    await NotifyResponse(MessageType.CompilationMessage, SubmissionStatus.Compiled.ToString(), submision.SubmissionId.ToString(), "0");

                    //call the api to execute
                    await semaphoreSlim.WaitAsync();

                    try
                    {
                        await ExecuteSubmission(submision, _executionApi);
                    }
                    finally
                    {
                        semaphoreSlim.Release();
                    }
                }
                else
                {
                    UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.CompilationError, content.OutputMessage, 0);

                    //notify with signal r
                    await NotifyResponse(MessageType.CompilationMessage, SubmissionStatus.CompilationError.ToString(), submision.SubmissionId.ToString(), "0");
                }
            }
            else
            {
                //server error
                UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.ServerError, response.ReasonPhrase, 0);
            }
        }
Ejemplo n.º 4
0
        public async Task <int> StoreSubmision(SubmisionDto submision)
        {
            using (var ctx = _contextFactory.ConstructContext())
            {
                await ctx.Submisions.AddAsync(submision.ToEntity());

                return(await ctx.SaveChangesAsync(true));
            }
        }
Ejemplo n.º 5
0
 private async Task VerificaThread(SubmisionDto submissionDtoModel)
 {
     semaphoreSlim.Wait();
     try
     {
         var submRequest = new SubmissionRequest(_submissionHub, _submisionRepository, _hubContext,
                                                 _serializeTests, _evaluationRepository);
         await submRequest.MakeSubmissionRequestAsync(submissionDtoModel, _compilationApi, _executionApi);
     }
     finally
     {
         semaphoreSlim.Release();
     }
 }
Ejemplo n.º 6
0
        public bool ValidateSubmision(SubmisionDto submision)
        {
            if (submision == null)
            {
                return(false);
            }

            if (!submision.FamilyName.HasValue())
            {
                return(false);
            }

            if (submision.HomeAddress == null)
            {
                return(false);
            }

            if (!submision.HomeAddress.City.HasValue())
            {
                return(false);
            }

            if (string.IsNullOrEmpty(submision.HomeAddress.Zip))
            {
                return(false);
            }

            if (string.IsNullOrEmpty(submision.HomeAddress.Street))
            {
                return(false);
            }

            if (!ValidatePhone(submision.HomePhone))
            {
                return(false);
            }

            if (!ValidatePhone(submision.AdultOneMobilePhone))
            {
                return(false);
            }

            if (!ValidatePhone(submision.AdultTwoMobilePhone))
            {
                return(false);
            }

            return(!string.IsNullOrEmpty(submision.AdultOneFirstName.TryTrim()));
        }
        public async Task SubmitFormTest2()
        {
            //Arrange
            using (var dirCtxFactory = new SharedSqliteInMemoryContextFactory <DirectoryContext>())
                using (var logCtxFactory = new SharedSqliteInMemoryContextFactory <LogContext>())
                    using (var logCtx = logCtxFactory.ConstructContext())
                    {
                        await logCtx.Database.ExecuteSqlCommandAsync("delete from detail");

                        await logCtx.Database.ExecuteSqlCommandAsync("delete from header");

                        var manager = FactoryManager(null, logCtxFactory, dirCtxFactory);

                        var request = new SubmisionDto
                        {
                            FamilyName        = "testerson",
                            AdultOneFirstName = "test",
                            HomePhone         = new PhoneDto
                            {
                                PhoneType = PhoneType.Home,
                                Number    = "6365555555"
                            },
                            HomeAddress = new AddressDto
                            {
                                Street      = "123 Main",
                                City        = "Hometown",
                                Zip         = "90210",
                                AddressType = AddressType.Home,
                                State       = new StateDto
                                {
                                    Abbreviation = "GH"
                                }
                            },
                        };

                        //Act
                        var result = await manager.StoreSubmision(request);

                        //Assert
                        Assert.IsNotNull(result, "should always respond.");
                        Assert.AreEqual(ResultType.Exception, result.Type, "Should succeed");
                        Assert.AreEqual("Could not match state: GH", result.Message, "Should be equal");
                        Assert.AreEqual(1, logCtx.LogHeaders.Count(), "Should be a msg logged after this");
                        Assert.AreEqual(2, logCtx.LogDetails.Count(), "Should be two details logged after this");
                    }
        }
Ejemplo n.º 8
0
        private async Task ExecuteSubmission(SubmisionDto submision, string _executionApi)
        {
            var client = new HttpClient();

            var executionModel = new ExecutionModel
            {
                MemoryLimit   = submision.MemoryLimit,
                ProblemName   = submision.ProblemName,
                UserName      = submision.UserName,
                TimeLimit     = submision.TimeLimit,
                Compilator    = submision.Compilator,
                FileName      = submision.FileName,
                NumberOfTests = submision.NumberOfTests
            };
            var serializedExecutionData = JsonConvert.SerializeObject(executionModel);
            var httpContentExecution    = new StringContent(serializedExecutionData, Encoding.UTF8, "application/json");
            var responseExecution       = await client.PostAsync(_executionApi, httpContentExecution);

            if (responseExecution.StatusCode == System.Net.HttpStatusCode.OK)
            {
                var resultExecution = await responseExecution.Content.ReadAsStringAsync();

                var responseExecutionModels = DeserializeExecutionResponse(resultExecution);
                var serializedData          = _serializeTests.SerializeReponseTest(responseExecutionModels);
                //save in db the serializedData
                var evaluationModel = new Evaluation
                {
                    EvaluationId     = Guid.NewGuid(),
                    EvaluationResult = serializedData.Item1,
                    Score            = serializedData.Item2,
                    SubmisionId      = submision.SubmissionId
                };
                await _evaluationRepository.AddAsync(evaluationModel);

                UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.Executed, string.Empty, serializedData.Item2);
                //notify with signalR
                await NotifyResponse(MessageType.ExecutionMessage, SubmissionStatus.Executed.ToString(), submision.SubmissionId.ToString(), serializedData.Item2.ToString());

                var x = 2;
            }
            else
            {
                //server error
                UpdateSubmissionStatus(submision.SubmissionId, SubmissionStatus.ServerError, responseExecution.ReasonPhrase, 0);
            }
        }
Ejemplo n.º 9
0
        public async Task <SaveResult> StoreSubmision(SubmisionDto submision)
        {
            var state = await GetStateByAbbr(submision.HomeAddress.State.Abbreviation);

            if (state == null)
            {
                throw new InvalidDataException($"Could not match state: {submision.HomeAddress.State.Abbreviation}");
            }

            submision.HomeAddress.State.Id = state.Id;

            var rowCount = await _directoryAccessor.StoreSubmision(submision);

            return(new SaveResult
            {
                Type = DeterminExpectedRowCount(submision) == rowCount
                    ? ResultType.Success
                    : ResultType.SaveFailure,
                RowsAffected = rowCount
            });
        }
        private void AddRow(DataTable table, SubmisionDto dto)
        {
            var row = table.NewRow();

            row[0]  = dto.FamilyName;
            row[1]  = dto.AdultOneFirstName;
            row[2]  = dto.AdultTwoFirstName;
            row[3]  = dto.OtherFamily;
            row[4]  = dto.PublishAddress.ToString();
            row[5]  = dto.PublishPhone.ToString();
            row[6]  = dto.HomePhone?.Number; //TODO: format like nnn-nnn-nnnn
            row[7]  = dto.HomeAddress.Street;
            row[8]  = dto.HomeAddress.City;
            row[9]  = dto.HomeAddress.State.Name;
            row[10] = dto.HomeAddress.Zip;
            row[11] = dto.AdultOneMobilePhone?.Number; //TODO: format like nnn-nnn-nnnn
            row[12] = dto.AdultOneEmailAddress?.Address;
            row[13] = dto.AdultTwoMobilePhone?.Number; //TODO: format like nnn-nnn-nnnn
            row[14] = dto.AdultTwoEmailAddress?.Address;

            table.Rows.Add(row);
        }
        internal static SubmisionEntitiy ToEntity(this SubmisionDto dto)
        {
            if (dto == null)
            {
                return(null);
            }

            return(new SubmisionEntitiy
            {
                PublishAddress = dto.PublishAddress,
                PublishPhone = dto.PublishPhone,
                FamilyName = dto.FamilyName,
                AdultOneFirstName = dto.AdultOneFirstName,
                AdultTwoFirstName = dto.AdultTwoFirstName,
                OtherFamily = dto.OtherFamily,
                HomeAddress = dto.HomeAddress?.ToEntity(),
                HomePhone = dto.HomePhone?.ToEntity(),
                AdultOneMobilePhone = dto.AdultOneMobilePhone?.ToEntity(),
                AdultTwoMobilePhone = dto.AdultTwoMobilePhone?.ToEntity(),
                AdultOneEmail = dto.AdultOneEmailAddress?.ToEntity(),
                AdultTwoEmail = dto.AdultTwoEmailAddress?.ToEntity()
            });
        }
Ejemplo n.º 12
0
        private int DeterminExpectedRowCount(SubmisionDto dto)
        {
            var count = 1;

            if (dto.HomeAddress != null)
            {
                count++;
            }

            if (dto.HomePhone != null)
            {
                count++;
            }

            if (dto.AdultOneEmailAddress != null)
            {
                count++;
            }

            if (dto.AdultOneMobilePhone != null)
            {
                count++;
            }

            if (dto.AdultTwoEmailAddress != null)
            {
                count++;
            }

            if (dto.AdultTwoMobilePhone != null)
            {
                count++;
            }

            return(count);
        }