public async Task <IActionResult> OnPostImportAsync() { if (!await CheckModel(true)) { return(BadRequest()); } HttpClient httpclient = clientFactory.CreateClient(); ProblemsClient client = new ProblemsClient(httpclient); try { string sp = ""; using (Stream st = PostData.ImportFile.OpenReadStream()) using (StreamReader sr = new StreamReader(st)) sp = await sr.ReadToEndAsync(); ProblemPackage package = Newtonsoft.Json.JsonConvert.DeserializeObject <ProblemPackage>(sp); package.Metadata.UserId = PostData.Metadata.UserId; ProblemMetadata pro = await client.ImportAsync(package); return(RedirectToPage(new { id = pro.Id })); } catch { return(NotFound()); } }
public void SetUp() { _problemMetadata = new ProblemMetadata(0, new SourceContext(), Fragment.CreateEmpty(), Fragment.CreateEmpty()); MockRepository mocks = new MockRepository(); _blacklistManager = mocks.Stub <IBlacklistManager>(); }
async Task <bool> GetData(string id) { HttpClient httpclient = clientFactory.CreateClient(); ProblemsClient client = new ProblemsClient(httpclient); try { ProblemMetadata metadata = await client.GetAsync(id); Problem = await ProblemModel.GetAsync(metadata, httpclient, false, true); } catch { return(false); } TestCasePreviewModel emptyTestCase = new TestCasePreviewModel { Metadata = new TestCaseMetadata { Id = "empty", TimeLimit = TimeSpan.FromSeconds(1), MemoryLimit = 128 * MemoryValueHelper.MB, }, IsNew = true, }; { List <TestCasePreviewModel> ls = new List <TestCasePreviewModel>(); foreach (TestCaseMetadata item in Problem.Samples) { ls.Add(new TestCasePreviewModel { Metadata = item, Input = await client.GetSampleInputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes), Output = await client.GetSampleOutputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes), IsNew = false, }); } ls.Add(emptyTestCase); SamplePreview = ls; } { List <TestCasePreviewModel> ls = new List <TestCasePreviewModel>(); foreach (TestCaseMetadata item in Problem.Tests) { ls.Add(new TestCasePreviewModel { Metadata = item, Input = await client.GetTestInputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes), Output = await client.GetTestOutputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes), }); } ls.Add(emptyTestCase); TestPreview = ls; } return(true); }
private void PassProblem(Expression problemSource, ProblemMetadata problemMetadata) { string variableName; Fragment expectedFragment = problemMetadata.ExpectedFragment; if (ExpressionIsVariableFromPrecedingBlock(problemSource, out variableName)) { _preConditions.Add(new AssignabilityPreCondition(variableName, expectedFragment, problemMetadata)); } else if (problemSource is MethodCall) { MethodCall methodCall = (MethodCall)problemSource; Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); if (_customInferenceController.Analyzes(calleeMethod)) { _customInferenceController.PassProblem(methodCall, _preConditions, problemMetadata, _symbolTable, _problemPipe); } else { _problemPipe.AddProblem(problemMetadata); } } else { _problemPipe.AddProblem(problemMetadata); } }
public async Task SetMetadata(ProblemMetadata value) { _problem.Source = value.Source; _problem.UserId = int.Parse(value.UserId); _problem.Name = value.Name; await _context.SaveChangesAsync(); }
public async Task <IActionResult> OnPostCreateAsync() { if (!await CheckModel(false)) { if (await GetData(PostData.Metadata.Id)) { return(Page()); } else { return(NotFound()); } } HttpClient httpclient = clientFactory.CreateClient(); ProblemsClient client = new ProblemsClient(httpclient); try { ProblemMetadata pro = await client.CreateAsync(new API.Models.ProblemData { Description = PostData.Description, Metadata = PostData.Metadata, }); return(RedirectToPage(new { id = pro.Id })); } catch { return(NotFound()); } }
public void AddProblem(ProblemMetadata problemMetadata) { ArgumentUtility.CheckNotNull("problemMetadata", problemMetadata); var resolution = GetResolution(problemMetadata.ExpectedFragment, problemMetadata.GivenFragment); var problem = new Problem(resolution, problemMetadata.SourceContext, CheckId); Problems.Add(problem); }
protected PreConditionBase(string symbol, Fragment fragment) { ArgumentUtility.CheckNotNullOrEmpty("symbol", symbol); ArgumentUtility.CheckNotNull("fragment", fragment); _symbol = symbol; _fragment = fragment; _problemMetadata = null; }
private void CheckParameter(Expression operand, Fragment expectedFragment) { Fragment operandFragmentType = _symbolTable.InferFragmentType(operand); if (!FragmentUtility.FragmentTypesAssignable(operandFragmentType, expectedFragment)) { ProblemMetadata problemMetadata = new ProblemMetadata(operand.UniqueKey, operand.SourceContext, expectedFragment, operandFragmentType); PassProblem(operand, problemMetadata); } }
public void PassProblem( MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); ICustomInference matchingRule = MatchingAnalyzeRule(calleeMethod); if (matchingRule != null) { matchingRule.PassProblem(methodCall, preConditions, problemMetadata, symbolTable, problemPipe); } }
public async Task <IProblemProvider> Create(ProblemMetadata metadata) { Problem empty = new Problem(); _context.Add(empty); await _context.SaveChangesAsync(); ProblemProvider res = new ProblemProvider(_workspace, _context, empty); await res.SetMetadata(metadata); return(res); }
public async Task <ActionResult> UpdateMetadata(string id, [FromBody] ProblemMetadata data) { IProblemProvider res = await _workspace.Problems.Get(id); if (res == null) { return(NotFound()); } await res.SetMetadata(data); return(Accepted()); }
public async Task <ActionResult <ProblemMetadata> > Get(string id) { ProblemMetadata res = await(await _workspace.Problems.Get(id))?.GetMetadata(); if (res != null) { return(Ok(res)); } else { return(NotFound()); } }
private void HandleReturnType(ReturnNode returnNode, HandleContext context) { _blockParserContext.Inspect(returnNode.Expression); string returnSymbol = IntrospectionUtility.GetVariableName(returnNode.Expression); if (returnSymbol != null) { ProblemMetadata problemMetadata = new ProblemMetadata( returnNode.UniqueKey, returnNode.SourceContext, _blockParserContext.ReturnFragmentType, context.SymbolTable.GetFragmentType(returnSymbol)); AssignabilityPreCondition returnBlockCondition = new AssignabilityPreCondition( returnSymbol, _blockParserContext.ReturnFragmentType, problemMetadata); context.PreConditions.Add(returnBlockCondition); context.PreConditions.AddRange(_blockParserContext.ReturnConditions); } }
private void SetPreConditionForIndexerObject( AssignmentStatement assignmentStatement, string targetName, Fragment sourceFragmentType, HandleContext context) { if (targetName != null) { ProblemMetadata problemMetadata = new ProblemMetadata( assignmentStatement.UniqueKey, assignmentStatement.SourceContext, sourceFragmentType, Fragment.CreateNamed("??")); var preCondition = new EqualityPreCondition(targetName, sourceFragmentType, problemMetadata); context.PreConditions.Add(preCondition); } }
public void IsViolated_ViolatingContext_ChangesProblemMetadatasGivenType() { var expectedFragment = Fragment.CreateNamed("expectedFragment"); var unexpectedFragment = Fragment.CreateNamed("unexpectedFragment"); ProblemMetadata problemMetaData = new ProblemMetadata(0, new SourceContext(), expectedFragment, Fragment.CreateNamed("dummy")); IBlacklistManager blackListManager = _mocks.Stub <IBlacklistManager>(); EqualityPreCondition preCondition = new EqualityPreCondition("testSymbol", expectedFragment, problemMetaData); SymbolTable context = new SymbolTable(blackListManager); context.MakeSafe("testSymbol", unexpectedFragment); preCondition.IsViolated(context); Assert.That(problemMetaData.GivenFragment, Is.EqualTo(unexpectedFragment)); }
private void ValidateAssignmentOnField(AssignmentStatement assignmentStatement, HandleContext context) { Field targetField = IntrospectionUtility.GetField(assignmentStatement.Target); Fragment targetFragmentType = FragmentUtility.GetFragmentType(targetField.Attributes); Fragment givenFragmentType = context.SymbolTable.InferFragmentType(assignmentStatement.Source); if (!FragmentUtility.FragmentTypesAssignable(givenFragmentType, targetFragmentType)) { ProblemMetadata problemMetadata = new ProblemMetadata( targetField.UniqueKey, targetField.SourceContext, targetFragmentType, givenFragmentType); _blockParserContext.ProblemPipe.AddProblem(problemMetadata); } }
async Task <bool> GetData(string id) { HttpClient httpclient = clientFactory.CreateClient(); ProblemsClient client = new ProblemsClient(httpclient); try { ProblemMetadata metadata = await client.GetAsync(id); Problem = await ProblemModel.GetAsync(metadata, httpclient, true, false); } catch { return(false); } return(true); }
public void AddProblem_MultipleProblemMetadataObjectsWithDifferentSourceExpressionIds_PassesObjects_() { ProblemMetadata problem1 = new ProblemMetadata(c_sourceExpressionId1, new SourceContext(), Fragment.CreateNamed("dummy"), Fragment.CreateNamed("dummy")); ProblemMetadata problem2 = new ProblemMetadata(c_sourceExpressionId2, new SourceContext(), Fragment.CreateNamed("dummy"), Fragment.CreateNamed("dummy")); using (_mocks.Record()) { _problemDestination.AddProblem(problem1); _problemDestination.AddProblem(problem2); } var problemDuplicateFilter = new ProblemDuplicateFilter(_problemDestination); problemDuplicateFilter.AddProblem(problem1); problemDuplicateFilter.AddProblem(problem2); _mocks.Verify(_problemDestination); }
public void Analyze(MethodCall methodCall, ISymbolTable context, List <IPreCondition> preConditions) { Method method = IntrospectionUtility.ExtractMethod(methodCall); if (Analyzes(method) && methodCall.Callee is MemberBinding) { MemberBinding memberBinding = (MemberBinding)methodCall.Callee; if (IsFragmentParameterInferenceMethod(method)) { string variableName; if (IntrospectionUtility.IsVariable(memberBinding.TargetObject, out variableName)) { Fragment parameterFragment = ParameterFragmentUtility.ParameterFragmentIntersection(methodCall, context); Fragment targetObjectFragment = context.GetFragmentType(variableName); if (targetObjectFragment == Fragment.CreateLiteral() || targetObjectFragment.Undefined) { context.MakeSafe(variableName, parameterFragment); } else { if (targetObjectFragment == Fragment.CreateEmpty() && parameterFragment != Fragment.CreateLiteral()) // && parameterFragment != Fragment.CreateEmpty() { ProblemMetadata problemMetadata = new ProblemMetadata(methodCall.UniqueKey, methodCall.SourceContext, parameterFragment, targetObjectFragment); IPreCondition precondition = new CustomInferencePreCondition(variableName, parameterFragment, problemMetadata); preConditions.Add(precondition); } else if (!FragmentUtility.FragmentTypesAssignable(parameterFragment, targetObjectFragment)) { context.MakeUnsafe(variableName); } } } } else if (!IsSafeMethod(method)) { string variableName; if (IntrospectionUtility.IsVariable(memberBinding.TargetObject, out variableName)) { context.MakeUnsafe(variableName); } } } }
private void AddAssignmentPreCondition(AssignmentStatement assignmentStatement, HandleContext context) { Field targetField = IntrospectionUtility.GetField(assignmentStatement.Target); Fragment targetFragmentType = FragmentUtility.GetFragmentType(targetField.Attributes); if (targetFragmentType != Fragment.CreateEmpty()) { ProblemMetadata problemMetadata = new ProblemMetadata( assignmentStatement.UniqueKey, assignmentStatement.SourceContext, targetFragmentType, Fragment.CreateNamed("??")); string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source); if (sourceSymbol != null) { AssignabilityPreCondition preCondition = new AssignabilityPreCondition(sourceSymbol, targetFragmentType, problemMetadata); context.PreConditions.Add(preCondition); } } }
public void PassProblem( MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { Method calleeMethod = IntrospectionUtility.ExtractMethod(methodCall); if (_coveredMethods.Contains(calleeMethod.FullName)) { foreach (var operand in methodCall.Operands) { string nestedVariableName; if (OperandIsVariableFromPrecedingBlock(operand, symbolTable, out nestedVariableName)) { preConditions.Add(new AssignabilityPreCondition(nestedVariableName, problemMetadata.ExpectedFragment, problemMetadata)); } else { problemPipe.AddProblem(problemMetadata); } } } }
private void ProcessBlockInternalPreConditionViolation( ReturnNode returnNode, ReturnCondition returnCondition, Fragment blockInternalFragmentType, HandleContext context) { ProblemMetadata problemMetadata = new ProblemMetadata( returnNode.UniqueKey, returnNode.SourceContext, returnCondition.Fragment, blockInternalFragmentType); returnCondition.ProblemMetadata = problemMetadata; if (!context.AssignmentTargetVariables.Contains(returnCondition.Symbol)) { context.PreConditions.Add(returnCondition); } else { _blockParserContext.ProblemPipe.AddProblem(problemMetadata); } }
public void PassProblem(MethodCall methodCall, List <IPreCondition> preConditions, ProblemMetadata problemMetadata, ISymbolTable symbolTable, IProblemPipe problemPipe) { throw new NotImplementedException(); }
public async Task <IActionResult> OnGetAsync(string id) { if (string.IsNullOrEmpty(id)) { return(NotFound()); } HttpClient httpclient = clientFactory.CreateClient(); ProblemsClient client = new ProblemsClient(httpclient); try { ProblemMetadata metadata = await client.GetAsync(id); Problem = await ProblemModel.GetAsync(metadata, httpclient, true, true); } catch { return(NotFound()); } List <TestCaseData> samples = new List <TestCaseData>(); foreach (TestCaseMetadata s in Problem.Samples) { Core.DataPreview input = await client.GetSampleInputPreviewAsync(id, s.Id, int.MaxValue); Core.DataPreview output = await client.GetSampleOutputPreviewAsync(id, s.Id, int.MaxValue); TestCaseData td = new TestCaseData { Metadata = s, Input = input.Content, Output = output.Content, }; samples.Add(td); } SampleData = samples; CurrentUser = await _userManager.GetUserAsync(User); EnableCode = CurrentUser != null; if (EnableCode) { StringBuilder res = new StringBuilder(); WorkspaceClient wclient = new WorkspaceClient(httpclient); IList <ProgrammingLanguage> langs; try { langs = await wclient.GetSupportLanguagesAsync(); } catch { langs = Array.Empty <ProgrammingLanguage>(); } if (langs.Count == 0) { EnableCode = false; } else { EnableCode = true; foreach (ProgrammingLanguage item in langs) { string editorId = Helper.GetEditorLanguage(item); if (editorId == "plaintext") { continue; } res.Append("{editorId: \"" + editorId + "\", "); switch (item) { // editorId for editor, lang for enum, show for selector in html case ProgrammingLanguage.C: res.Append("lang: \"C\", show: \"C\"},"); break; case ProgrammingLanguage.Cpp: res.Append("lang: \"Cpp\", show: \"C++\"},"); break; case ProgrammingLanguage.Java: res.Append("lang: \"Java\", show: \"Java\"},"); break; case ProgrammingLanguage.Python: res.Append("lang: \"Python\", show: \"Python\"},"); break; case ProgrammingLanguage.CSharp: res.Append("lang: \"CSharp\", show: \"C#\"},"); break; case ProgrammingLanguage.Rust: res.Append("lang: \"Rust\", show: \"Rust\"},"); break; case ProgrammingLanguage.VisualBasic: res.Append("lang: \"VisualBasic\", show: \"Visual Basic\"},"); break; case ProgrammingLanguage.Go: res.Append("lang: \"Go\", show: \"Go\"},"); break; case ProgrammingLanguage.Haskell: res.Append("lang: \"Haskell\", show: \"Haskell\"},"); break; case ProgrammingLanguage.Javascript: res.Append("lang: \"Javascript\", show: \"Javascript\"},"); break; case ProgrammingLanguage.Kotlin: res.Append("lang: \"Kotlin\", show: \"Kotlin\"},"); break; case ProgrammingLanguage.Php: res.Append("lang: \"Php\", show: \"PHP\"},"); break; case ProgrammingLanguage.Ruby: res.Append("lang: \"Ruby\", show: \"Ruby\"},"); break; case ProgrammingLanguage.Scala: res.Append("lang: \"Scala\", show: \"Scala\"},"); break; } } } LanguageConfig = res.ToString(); } return(Page()); }
public void AddProblem(ProblemMetadata problemMetadata) { _problems.Add(problemMetadata); }
public EqualityPreCondition(string symbol, Fragment fragment, ProblemMetadata problemMetadata) : base(symbol, fragment, problemMetadata) { }
public static async Task <ProblemModel> GetAsync(ProblemMetadata metadata, HttpClient client, bool loadDescription, bool loadData) { ProblemModel res = new ProblemModel { Metadata = metadata, }; ProblemsClient pcli = new ProblemsClient(client); { try { StatisticsClient stcli = new StatisticsClient(client); res.Statistics = await stcli.GetProblemAsync(metadata.Id); } catch { res.Statistics = null; } } if (loadDescription) { try { res.Description = await pcli.GetDescriptionAsync(metadata.Id); } catch { } } if (loadData) { try { res.Samples = await pcli.GetSamplesAsync(metadata.Id); } catch { res.Samples = Array.Empty <TestCaseMetadata>(); } try { res.Tests = await pcli.GetTestsAsync(metadata.Id); } catch { res.Tests = Array.Empty <TestCaseMetadata>(); } } { UsersClient ucli = new UsersClient(client); try { res.User = await ucli.GetAsync(metadata.UserId); } catch { res.User = null; } } return(res); }
protected PreConditionBase(string symbol, Fragment fragment, ProblemMetadata problemMetadata) : this(symbol, fragment) { _problemMetadata = ArgumentUtility.CheckNotNull("sourceContext", problemMetadata); }
public CustomInferencePreCondition(string symbol, Fragment fragment, ProblemMetadata problemMetadata) : base(symbol, fragment, problemMetadata) { }