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)
{
}
