public async Task <SubmissionResponse> SaveTable(Table table, bool isUpdate)
{
if (table == null)
{
return(SubmissionResponse.Error());
}
if (isUpdate && table.Id.IsEmptyOrEmptyGuid())
{
return(SubmissionResponse.Error(Constants.Errors.EmptyPayload));
}
if (isUpdate)
{
table.SetUpdateCommonFields();
}
else
{
if (table.Id.IsEmptyOrEmptyGuid())
{
table.Id = Guid.NewGuid().ToString();
}
table.SetNewCommonFields();
}
return(await coreStore.SaveTable(table, isUpdate));
}
public SubmissionResponse SaveNewSubmission(BaseSubmission submission, string result)
{
var response = new SubmissionResponse();
if (!DoesUserTaskSubmissionExist(submission.TaskId, submission.Nickname))
{
var newSubmission = new UserSubmission()
{
Code = submission.Solution,
IsCorrect = DoesTaskHaveCorrectResult(submission.TaskId, result),
IsDeleted = false,
Nickname = submission.Nickname,
Result = result,
SubmissionDateTime = DateTime.UtcNow,
TaskId = submission.TaskId
};
_programmingCompetitionDataContext.UserSubmission.Add(newSubmission);
_programmingCompetitionDataContext.SaveChanges();
response.IsCorrectResult = newSubmission.IsCorrect;
response.IsSubmissionAccepted = true;
response.Response = newSubmission.Result;
}
else
{
response.IsSubmissionAccepted = false;
response.Response = "There is already a submission for this task with current user nickname!";
}
return(response);
}
public async Task <SubmissionResponse> ExecuteFiddleAsync(BaseSubmission submission)
{
var model = ConfigureSubmissionForm(submission.Solution);
const string requestEndpoint = "api/fiddles";
var stringContent = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync(requestEndpoint, stringContent);
var result = new SubmissionResponse();
if (response.StatusCode != HttpStatusCode.OK)
{
result.Response =
$@"Failed to execute API request. Here is an answer from API:
Response Code: {response.StatusCode}, Response Body: {response.Content}";
result.IsSubmissionAccepted = false;
}
else
{
var unparsedResponse = await response.Content.ReadAsStringAsync();
var executionResult = JsonConvert.DeserializeObject <FiddleExecuteResult>(unparsedResponse);
if (!executionResult.HasErrors && !executionResult.HasCompilationErrors)
{
result = _submissionsRepository.SaveNewSubmission(submission, executionResult.ConsoleOutput);
}
else
{
result.Response = executionResult.ConsoleOutput;
result.IsSubmissionAccepted = false;
}
}
return(result);
}
public void SyncSubmitPositionTest()
{
// Test that submitting a score returns proper position
SubmissionResponse r1 = lb.SubmitScore(uniqueLevelName, new Score(1, "abc", "xyz"));
SubmissionResponse r2 = lb.SubmitScore(uniqueLevelName, new Score(3, "abc", "xyz"));
SubmissionResponse r3 = lb.SubmitScore(uniqueLevelName, new Score(2, "abc", "xyz"));
// Confirm the returned positions
Assert.AreEqual(r1.position, 1);
Assert.AreEqual(r2.position, 2);
Assert.AreEqual(r3.position, 2);
}
public async Task <SubmissionResponse> SaveTable(Table table, bool isUpdate)
{
var tableCollection = mongoService.GetCollection <Table>(Constants.Collections.TablesCollection);
var update = Builders <Table> .Update
.Set(m => m.ModifiedOn, table.ModifiedOn)
.Set(m => m.ModifiedBy, table.ModifiedBy)
.SetIfNotEmpty(m => m.TableNumber, table.TableNumber);
if (!isUpdate)
{
update = update.SetIfNotEmpty(m => m.CreatedOn, table.CreatedOn)
.SetIfNotEmpty(m => m.CreatedBy, table.CreatedBy);
}
await tableCollection.UpdateOneAsync(table.Id.ToIdFilter <Table>(), update, new UpdateOptions { IsUpsert = true });
return(SubmissionResponse.Ok(table));
}
public async Task <ActionResult <SubmissionResponse> > PatchEmployee([FromBody] Employee request)
{
var command = commandFactory.PatchEmployeeCommand(request);
logger.LogTrace("Validating command");
var validationResult = Validate(command);
if (validationResult.IsFailure)
{
return(BadRequest(this.ModelState));
}
var result = await mediator.Send(command).ConfigureAwait(false);
if (result.IsFailure)
{
return(this.Ok(SubmissionResponse.ForFailure(result.Error)));
}
return(this.Ok(SubmissionResponse.ForSuccess()));
}
public SubmissionResponse SubmitText(string text)
{
SubmissionResponse finalResult = null;
var dirProcess = GetRandomDirectionalProcess();
var originalProcess = dirProcess;
var retry = false;
var retryCountMax = 3;
var retryCount = 0;
do
{
finalResult = SubmitTextInternal(dirProcess, _grid.Width, text);
// If it inserted successfully, then do not retry.
retry = !finalResult.Success;
if (retry)
{
var nextDir = dirProcess.GetNextDirection();
// If we've reached the original direction in the retry loop, then quit.
if (nextDir == originalProcess.Direction)
{
retryCount++;
if (retryCount == retryCountMax)
{
break;
}
}
dirProcess = GetDirectionProcess(nextDir);
}
} while (retry);
return(finalResult);
}
public IActionResult AddMovies(SubmissionResponse onSubmit)
{
TempStorage.AddSubmission(onSubmit);
return(View("Confirmation", onSubmit));
}
public SubmissionRejected(Submission submission, SubmissionResponse response)
{
Submission = submission;
Response = response;
}
public static ActionResult <SubmissionResponse> GetSubmissionResponse(this ControllerBase controller, SubmissionResponse result) => result.ToOption() .Where(m => m.Success) .Select(m => (ActionResult <SubmissionResponse>)controller.Ok(result)) .DefaultIfEmpty(controller.BadRequest(result)) .Single();
public SubmissionApproved(Submission submission, SubmissionResponse response)
{
Submission = submission;
Response = response;
}
