public virtual SubmitResult ResetPassword(ResetDTO dto)
{
var submitResult = new SubmitResult();
try
{
if (ResetUserTokens.TryGetValue(dto.UserId, out string existing))
{
var token = Shell.Encryptor.Decrypt(dto.Token);
if (token == existing)
{
var user = Unit.AuthUserRepository.FindSingle(dto.UserId);
user.Password = dto.Password.ToMD5();
Unit.AuthUserRepository.Update(user);
Unit.SaveChanges();
}
}
submitResult.Code = 0;
}
catch// (Exception e)
{
submitResult.Code = 1;
}
return(submitResult);
}
protected virtual SubmitResult UpdateDbStructure(string db)
{
SubmitResult res = new SubmitResult();
SubmitResult tableAdd = null;
string updateScript = null;
if (CompareStructures(db, out updateScript))
{
Out.WriteLine();
Out.WriteLine("Discovered tables needs to be added first");
SaveComparisonFile(db, updateScript, true);
tableAdd = RunUpdateScript(db, updateScript);
if (CompareStructures(db, out updateScript))
{
Out.WriteLine("Tables still need to be added");
Out.WriteLine(updateScript);
return(res);
}
}
SaveComparisonFile(db, updateScript);
res = RunUpdateScript(db, updateScript);
if (tableAdd != null)
{
res.Data["TableAddResult"] = tableAdd;
}
SyncSchemas(db);
SyncBasicData(db);
Out.WriteLine();
return(res);
}
private async Task <IHttpActionResult> Update(
EdmEntityObject edmEntityObject,
bool isFullReplaceUpdate,
CancellationToken cancellationToken)
{
ODataPath path = this.GetPath();
IEdmEntitySet entitySet = path.NavigationSource as IEdmEntitySet;
if (entitySet == null)
{
throw new NotImplementedException(Resources.UpdateOnlySupportedOnEntitySet);
}
var propertiesInEtag = await this.GetOriginalValues(entitySet);
if (propertiesInEtag == null)
{
throw new PreconditionRequiredException(Resources.PreconditionRequired);
}
// In case of type inheritance, the actual type will be different from entity type
// This is only needed for put case, and does not for patch case
var expectedEntityType = path.EdmType;
var actualEntityType = path.EdmType;
if (edmEntityObject.ActualEdmType != null)
{
expectedEntityType = edmEntityObject.ExpectedEdmType;
actualEntityType = edmEntityObject.ActualEdmType;
}
DataModificationItem updateItem = new DataModificationItem(
entitySet.Name,
expectedEntityType.GetClrType(Api),
actualEntityType.GetClrType(Api),
DataModificationItemAction.Update,
RestierQueryBuilder.GetPathKeyValues(path),
propertiesInEtag,
edmEntityObject.CreatePropertyDictionary());
updateItem.IsFullReplaceUpdateRequest = isFullReplaceUpdate;
RestierChangeSetProperty changeSetProperty = this.Request.GetChangeSet();
if (changeSetProperty == null)
{
ChangeSet changeSet = new ChangeSet();
changeSet.Entries.Add(updateItem);
SubmitResult result = await Api.SubmitAsync(changeSet, cancellationToken);
}
else
{
changeSetProperty.ChangeSet.Entries.Add(updateItem);
await changeSetProperty.OnChangeSetCompleted();
}
return(this.CreateUpdatedODataResult(updateItem.Entity));
}
public virtual void AppendLog(Exception ex, string message = "Local Server Error")
{
if (LogToFile == null)
{
return;
}
List <string> lst = new List <string>();
SubmitResult res = new SubmitResult(1, message);
res.SetException(ex);
lst.Add(" ");
lst.Add("--------------------------------------------------------------------");
lst.Add(" ");
lst.Add(res.Message);
lst.Add(res.ExceptionMessage);
lst.Add(" ");
lst.Add("--------------------------------------------------------------------");
lst.Add(" ");
lst.AddRange(res.StackTrace);
File.AppendAllLines(LogToFile, lst);
}
public void CanSetAndGetResult()
{
var testValue = new SubmitResult(new Exception());
testClass.Result = testValue;
testClass.Result.Should().Be(testValue);
}
public JsonResult Submit(int ID)
{
SubmitResult result = new SubmitResult()
{
Success = false
};
var uploadRequest = accessor.GetCurrentContextObject <UploadRequest>();
var testInfo = DBHelper.GetTestInfo(uploadRequest.OpenId);
if (testInfo == null)
{
result.ErrMsg = "无法找到测试者的信息对应的试题";
}
else
{
if (testInfo.ContestFinished != "0")
{
result.NoMore = true; result.Success = true;
}
else
{
int raw = DBHelper.SubmitChoice(ID, uploadRequest);
result.Success = true; result.NoMore = DBHelper.GetAdminTestInfo() <= ID + 1; result.RowsAffected = raw;
}
}
return(new JsonResult(result));
}
public unsafe void SubmitAndWait(bool mayWait)
{
bool operationsRemaining = WriteSubmissions();
// We can't wait if there are more submissions to be sent,
// or the event loop wants to do something.
bool waitForCompletion = !operationsRemaining && mayWait;
// io_uring_enter
SubmitResult result = _ring !.SubmitAndWait(minComplete: waitForCompletion ? 1U : 0, out _);
if (result == SubmitResult.SubmittedSuccessfully) // likely case: all sqes were queued
{
_iovsUsed = 0;
_newOperations.RemoveRange(0, _newOperationsQueued);
_newOperationsQueued = 0;
}
else
{
// We were not able to submit all requests.
// TODO: This seems similar to EAGAIN, not enough resources?
// Or does it happen in other cases?
// Is there a semantical difference between 0 and EAGAIN;
// could submitted be less than _seqsQueued if there is an issue with
// the sqe at submitted + 1?
// TODO: detect if we're not making any more progress.
}
}
private IEnumerator RequestAddNote(LocationInfo location, string content, int colour)
{
print("Submitting note at " + location.longitude + ", " + location.latitude);
WWWForm form = new WWWForm();
form.AddField("long", location.longitude.ToString());
form.AddField("lat", location.latitude.ToString());
form.AddField("altitude", location.altitude.ToString());
form.AddField("content", content);
form.AddField("duration", (86400 * 5).ToString()); // 5 days for now (UI later?)
form.AddField("color", colour.ToString());
using (UnityWebRequest www = UnityWebRequest.Post(API_ROOT + "/notes", form)) {
www.chunkedTransfer = false; // chunked transfers appear to break gunicorn.
print("sending...");
yield return(www.SendWebRequest());
print("sent!");
if (www.isNetworkError || www.isHttpError)
{
// TODO: Error handling.
print("Failed to actually submit the note.");
}
else
{
print("Submitted note!");
SubmitResult result = JsonUtility.FromJson <SubmitResult>(www.downloadHandler.text);
onNotePosted.Invoke(result.note);
}
}
}
public void Constructor_NoParameters_TestProperties()
{
SubmitResult r = new SubmitResult();
Assert.AreEqual(SubmitStatusCode.Unknown, r.Status);
Assert.AreEqual(0, r.Messages.Count);
}
//public SubmitResult RestoreSourceDatabase()
//{
// var env = Environment;
// SubmitResult res = new SubmitResult();
// if (!string.IsNullOrEmpty(env.SourceBackupPath) && !string.IsNullOrEmpty(env.SourceDatabase))
// {
// res = RestoreDatabase(env.SourceDatabase, env.SourceBackupPath);
// }
// else
// {
// Out.WriteLine("'SourceDataBase' and 'SourceBackupPath' are both required to be present in the environment to use this function");
// }
// Out.WriteLine();
// return res;
//}
//public SubmitResult RestoreConfigDatabase()
//{
// var env = Environment;
// SubmitResult res = new SubmitResult();
// if (!string.IsNullOrEmpty(env.ConfigBackupPath) && !string.IsNullOrEmpty(env.ConfigDatabase))
// {
// res = RestoreDatabase(env.ConfigDatabase, env.ConfigBackupPath);
// }
// else
// {
// Out.WriteLine("'ConfigBackupPath' and 'ConfigDatabase' are both required to be present in the environment to use this function");
// }
// Out.WriteLine();
// return res;
//}
public SubmitResult UpdateDatabase(string db)
{
string updateScript = null;
CommandTimeout = 90;
SubmitResult res = new SubmitResult();
SubmitResult tableAdd = new SubmitResult();
if (CompareStructures(db, out updateScript))
{
Out.WriteLine();
Out.WriteLine("Discovered tables needs to be added first");
SaveComparisonFile(db, updateScript, true);
tableAdd = RunUpdateScript(db, updateScript);
if (CompareStructures(db, out updateScript))
{
Out.WriteLine("Tables still need to be added");
Out.WriteLine(updateScript);
return(new SubmitResult(1, "something_went_wrong"));
}
}
SaveComparisonFile(db, updateScript);
res = RunUpdateScript(db, updateScript);
if (res.IsSuccess)
{
SyncSchemas(db);
SyncBasicData(db);
}
Out.WriteLine();
return(res);
}
/// <summary>
/// Handles a DELETE request to delete an entity.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The task object that contains the deletion result.</returns>
public async Task <IHttpActionResult> Delete(CancellationToken cancellationToken)
{
ODataPath path = this.GetPath();
IEdmEntitySet entitySet = path.NavigationSource as IEdmEntitySet;
if (entitySet == null)
{
throw new NotImplementedException(Resources.DeleteOnlySupportedOnEntitySet);
}
DataModificationEntry deleteEntry = new DataModificationEntry(
entitySet.Name,
path.EdmType.FullTypeName(),
RestierQueryBuilder.GetPathKeyValues(path),
this.GetOriginalValues(),
null);
RestierChangeSetProperty changeSetProperty = this.Request.GetChangeSet();
if (changeSetProperty == null)
{
ChangeSet changeSet = new ChangeSet();
changeSet.Entries.Add(deleteEntry);
SubmitResult result = await Api.SubmitAsync(changeSet, cancellationToken);
}
else
{
changeSetProperty.ChangeSet.Entries.Add(deleteEntry);
await changeSetProperty.OnChangeSetCompleted();
}
return(this.StatusCode(HttpStatusCode.NoContent));
}
public SubmitQueueItem(SubmitResult result, string language, Task task, string userName)
{
var totalBytes = result.TotalBytes != null?Math.Min(result.TotalBytes.Value, task.MemoryLimitBytes) : (int?)null;
var totalMilliseconds = result.TotalMilliseconds != null?Math.Min(result.TotalMilliseconds.Value, task.TimeLimitMilliseconds) : (int?)null;
SubmitId = result.Submit.Id;
Language = language;
ProblemId = result.Submit.ProblemId;
ProblemName = task.Name;
ResultDescription = result.Status.GetDescription();
SubmitResultId = result.Id;
SubmitTime = result.Submit.SubmitDateUtc;
UserId = result.Submit.UserId;
UserName = userName;
Status = result.Status;
CompileResult = result.CompileOutput;
if (result.Status != SubmitStatus.CompilationError && result.Status != SubmitStatus.ServerError)
{
AllocatedMemory = (totalBytes / (1024f * 1024f))?.ToString("F3");
ExecutionTime = (totalMilliseconds / 1000f)?.ToString("F3");
if (result.Status != SubmitStatus.Accepted)
{
PassedTests = result.PassedTests;
}
}
}
internal async Task SubmitChangeSet(ChangeSet changeSet)
{
using (var api = this.apiFactory())
{
SubmitResult submitResults = await api.SubmitAsync(changeSet);
}
}
private static SubmitQueueItem GetSubmitQueueItem
(
SubmitResult submitResult,
IReadOnlyDictionary <int, string> languages,
IReadOnlyDictionary <long, string> users,
IReadOnlyDictionary <long, string> tasks,
ContestTask[] contestTasks
)
{
string taskLabel = null;
int? contestId = null;
var contestTaskSubmit = submitResult.Submit as ContestTaskSubmit;
if (contestTaskSubmit != null)
{
taskLabel = contestTasks.FirstOrDefault(o => o.Contest.Id == contestTaskSubmit.ContestId &&
o.Task.Id == contestTaskSubmit.ProblemId)?.TaskName ?? "deleted";
contestId = contestTaskSubmit.ContestId;
}
var language = languages[submitResult.Submit.LanguageId];
var problemName = tasks[submitResult.Submit.ProblemId];
var userName = users[submitResult.Submit.UserId];
return(new SubmitQueueItem(submitResult, language, problemName, taskLabel, contestId, userName));
}
public async Task <SubmitResult> Close(int id)
{
var result = new SubmitResult();
using (var db = dbFactory())
{
var rosterCount = await db.SignIns.Where(f => f.EventId == id && f.TimeOut == null).CountAsync();
if (rosterCount > 0)
{
result.Errors.Add(new SubmitError("All members must be signed out before an event can be closed"));
}
if (result.Errors.Count == 0)
{
var e = await db.Events.SingleOrDefaultAsync(f => f.Id == id);
e.Closed = DateTimeOffset.UtcNow.ToOrgTime(config);
await db.SaveChangesAsync();
this.config.GetPushHub <CallsHub>().updatedEvent(compiledProj(e));
}
}
return(result);
}
internal async Task SubmitChangeSet(ChangeSet changeSet)
{
using (var domain = this.domainFactory())
{
SubmitResult submitResults = await domain.SubmitAsync(changeSet);
}
}
public virtual SubmitResult CustomizeException(Exception ex, string failMessage = null)
{
var res = new SubmitResult
{
Code = 101,
Message = failMessage
};
res.SetException(ex);
var sqlException = GetSqlException(ex);
if (sqlException != null)
{
if (sqlException.Number == 547)
{
DeleteResult deleteResult = res.MapToResult <DeleteResult>();
deleteResult.Code = 547;
deleteResult.CanDelete = false;
deleteResult.TableName = SqlInterpreter.N00547(sqlException.Message)[5].Split('.')[1];
return(deleteResult);
}
}
return(res);
}
public void GetAnotherUserSolutionTest()
{
const long submitId = 1;
const long userId = 2;
const string sourceCode = "qwe";
var submitResult = new SubmitResult(new ProblemSubmit
{
FileName = "main.cpp",
Id = submitId,
LanguageId = 4,
ProblemId = 6,
SourceCode = sourceCode,
UserId = userId
})
{
Id = submitId
};
var task = new TaskName
{
IsOpened = false,
Name = "task"
};
_submitResultRepository.Stub(o => o.Get(submitId)).Return(submitResult);
_taskRepository.Stub(o => o.Get(6)).Return(task);
Assert.Throws <AuthenticationException>(() => _service.GetSolution(submitId, 3));
}
public IActionResult SyncTenants([FromBody] AssociateDTO dto)
{
SyncResult res = molds.SyncTenants(dto.Id1, dto.Id2);
SubmitResult = new SubmitResult();
SubmitResult.Data["Sync"] = res;
return(Respond());
}
public override void OnException(HttpActionExecutedContext actionExecutedContext)
{
SubmitResult res = new SubmitResult(1, "Error");
res.SetException(actionExecutedContext.Exception);
actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(HttpStatusCode.InternalServerError, res);
Logger.WriteException(actionExecutedContext.Exception);
}
public void CanConstruct()
{
var instance = new SubmitResult(exception);
instance.Should().NotBeNull();
instance = new SubmitResult(completedChangeSet);
instance.Should().NotBeNull();
}
internal async Task SubmitChangeSet(HttpRequestMessage request, ChangeSet changeSet)
{
var requestContainer = request.GetRequestContainer();
using (var api = requestContainer.GetService <ApiBase>())
{
SubmitResult submitResults = await api.SubmitAsync(changeSet);
}
}
public SyncResult SyncTenants(long src, long tar)
{
var con = GetService <MoldsterContext>();
var wt = new ConsoleService(_output);
using (var s = SW.Measure())
{
var d = con.SyncTenants(src, tar);
if (d != null)
{
_output.WriteLine();
using (_output.Set(ConsoleColor.DarkCyan))
{
_output.WriteLine("Synced tenant '" + d.SourceTenant + "' to '" + d.TargetTenant + "'");
}
_output.WriteLine("------------------------------------");
_output.WriteLine();
_output.Write("Added Pages : ");
_output.GotoColumn(5);
_output.WriteLine(d.AddedPages.ToString());
_output.Write("Added Controls : ");
_output.GotoColumn(5);
_output.WriteLine(d.AddedPageControls.ToString());
_output.Write("Updated Pages : ");
_output.GotoColumn(5);
_output.WriteLine(d.UpdatedPages.ToString());
_output.Write("Updated Controls : ");
_output.GotoColumn(5);
_output.WriteLine(d.UpdatedPageControls.ToString());
_output.Write("Added Navigation Pages : ");
_output.GotoColumn(5);
_output.WriteLine(d.NavigationPages.ToString());
_output.WriteLine();
}
_output.Write("Updating viewparams");
SubmitResult res = _pages.UpdateTemplatePagesViewParamsJson(tar);
wt.GotoColumn(wt.SuccessCol);
if (res.IsSuccess)
{
wt.WriteSuccess();
_output.Write("Affected : " + res.AffectedRows);
}
else
{
wt.WriteFailed();
}
_output.WriteLine();
return(d);
}
}
public virtual DeleteResult DeleteById(object prime)
{
Repository.DeleteById(prime);
SubmitResult submitResult = UnitOfWork.SaveChanges();
DeleteResult deleteResult = submitResult.MapTo <DeleteResult>();
deleteResult.CanDelete = submitResult.Code == 0;
return(deleteResult);
}
public void ClearUserConnectionId(string userId, string deviceId)
{
using (var sc = CodeShellCore.Shell.GetScope())
{
var conn = GetConnectionId();
var service = sc.ServiceProvider.GetService <IUserDeviceService>();
SubmitResult res = service.ClearDeviceConnection(userId, deviceId);
}
}
public SubmitQueueItem(SubmitResult submitResult, string language, Task task, string taskLabel, int?contestId, string userName)
: base(submitResult, language, task, userName)
{
TaskLabel = taskLabel;
ContestId = contestId;
ResultsEnabled = true;
RunDescription = submitResult.RunDescription;
RunOutput = submitResult.RunOutput;
}
public JudgeResult Check(SubmitResult submitResult)
{
CreateWorkingDirectory();
Language language;
Task task;
using (var uow = this.unitOfWorkFactory.GetUnitOfWork())
{
language = uow.LanguageRepository.Get(submitResult.Submit.LanguageId);
task = uow.TaskRepository.Get(submitResult.Submit.ProblemId);
}
CompileResult compileResult;
if (language.IsCompilable)
{
compileResult = Compile(language, submitResult.Submit.FileName, submitResult.Submit.SourceCode);
this.logger.Info($"Compile result: {compileResult.CompileStatus}");
}
else
{
File.WriteAllText(Path.Combine(_workingDirectory, submitResult.Submit.FileName),
submitResult.Submit.SourceCode);
compileResult = CompileResult.GetEmpty(submitResult.Submit.FileName);
}
ICollection <SubmitRunResult> results = null;
SubmitRunResult lastRunResult = null;
if (compileResult.CompileStatus == CompileStatus.Success)
{
var runString = GetRunString(language, compileResult.FileName);
this.logger.Info($"Run string: {runString}");
CopyChecker(task);
results = Run(task, runString);
lastRunResult = results.Last();
}
RemoveWorkingDirectory();
return(new JudgeResult
{
CompileResult = compileResult,
RunStatus = lastRunResult?.RunStatus,
Description = lastRunResult?.Description,
Output = lastRunResult?.Output,
TextStatus = lastRunResult?.TextStatus,
PeakMemoryBytes = results?.Max(o => o.PeakMemoryBytes),
TimeConsumedMilliseconds = results?.Max(o => o.TimeConsumedMilliseconds),
TimePassedMilliseconds = results?.Max(o => o.TimePassedMilliseconds),
TestRunsCount = results?.Count ?? 0,
CheckStatus = lastRunResult?.CheckStatus
});
}
public string SetUserConnectionId(string userId, string deviceId, string lang)
{
using (var sc = CodeShellCore.Shell.GetScope())
{
var conn = GetConnectionId();
var service = sc.ServiceProvider.GetService <IUserDeviceService>();
SubmitResult res = service.UpdateUserDevice(userId, DeviceType.SignalR, deviceId, conn, lang);
return(conn);
}
}
// To protect from overposting attacks, enable the specific properties you want to bind to.
// For more details, see https://aka.ms/RazorPagesCRUD.
public async Task <JsonResult> OnPostAsync(string academicYearID, int enrolmentID)
{
SubmitResult = new SubmitResult
{
SubmitResultID = "ENROLMENT"
};
string academicYear = academicYearID.Replace("-", "/");
Enrolment.AcademicYearID = academicYear;
Enrolment.EnrolmentID = enrolmentID;
TryValidateModel(Enrolment, nameof(Enrolment));
//if (!ModelState.IsValid)
//{
// SubmitResult.IsSuccessful = false;
// SubmitResult.ErrorLevel = ErrorLevel.Error;
// SubmitResult.ErrorCode = "MODEL";
// SubmitResult.ErrorDescription = "Data Model Is Invalid";
// SubmitResult.StackTrace = ModelState.ToString();
// //return Page();
// return new JsonResult(SubmitResult);
//}
_context.Attach(Enrolment).State = EntityState.Modified;
try
{
//await _context.SaveChangesAsync();
await _context.Database
.ExecuteSqlInterpolatedAsync($"EXEC SPR_GPR_UpdateEnrolment @AcademicYear={Enrolment.AcademicYearID}, @EnrolmentID={Enrolment.EnrolmentID}, @PredictedToAchieve={Enrolment.PredictedToAchieve}, @PredictedToAchieveBy={Enrolment.PredictedToAchieveBy}, @PredictedGrade={Enrolment.PredictedGrade}, @Comment={Enrolment.Comment}, @CreatedBy={User.Identity.Name.Split('\\').Last()}, @CreatedDate={DateTime.Now}");
}
catch (DbUpdateConcurrencyException)
{
if (!EnrolmentExists(Enrolment.EnrolmentID))
{
//return NotFound();
SubmitResult.IsSuccessful = false;
SubmitResult.ErrorLevel = ErrorLevel.Error;
SubmitResult.ErrorCode = "NOT_FOUND";
SubmitResult.ErrorDescription = $"The enrolment {Enrolment.EnrolmentID} could not be found";
//return Page();
return(new JsonResult(SubmitResult));
}
else
{
throw;
}
}
//return RedirectToPage("./Index");
SubmitResult.IsSuccessful = true;
return(new JsonResult(SubmitResult));
}
/// <summary>
/// Handles a POST request to create an entity.
/// </summary>
/// <param name="edmEntityObject">The entity object to create.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The task object that contains the creation result.</returns>
public async Task <IHttpActionResult> Post(EdmEntityObject edmEntityObject, CancellationToken cancellationToken)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
ODataPath path = this.GetPath();
IEdmEntitySet entitySet = path.NavigationSource as IEdmEntitySet;
if (entitySet == null)
{
throw new NotImplementedException(Resources.InsertOnlySupportedOnEntitySet);
}
// In case of type inheritance, the actual type will be different from entity type
var expectedEntityType = path.EdmType;
var actualEntityType = path.EdmType;
if (edmEntityObject.ActualEdmType != null)
{
expectedEntityType = edmEntityObject.ExpectedEdmType;
actualEntityType = edmEntityObject.ActualEdmType;
}
DataModificationItem postItem = new DataModificationItem(
entitySet.Name,
expectedEntityType.GetClrType(Api),
actualEntityType.GetClrType(Api),
DataModificationItemAction.Insert,
null,
null,
edmEntityObject.CreatePropertyDictionary());
RestierChangeSetProperty changeSetProperty = this.Request.GetChangeSet();
if (changeSetProperty == null)
{
ChangeSet changeSet = new ChangeSet();
changeSet.Entries.Add(postItem);
SubmitResult result = await Api.SubmitAsync(changeSet, cancellationToken);
}
else
{
changeSetProperty.ChangeSet.Entries.Add(postItem);
await changeSetProperty.OnChangeSetCompleted();
}
return(this.CreateCreatedODataResult(postItem.Entity));
}
internal static extern int WerReportSubmit(
ReportHandle reportHandle,
Consent consent,
SubmitFlags flags,
out SubmitResult result);
public void Constructor_NoParameters_TestProperties()
{
SubmitResult r = new SubmitResult();
Assert.AreEqual(SubmitStatusCode.Unknown, r.Status);
Assert.AreEqual(0, r.Messages.Count);
}
public DataActionResult SaveStatus(Guid q, UnitStatusType model)
{
if (!Permissions.HasPermission(PermissionType.AdminOrganization, q)) return GetLoginError();
SubmitResult<UnitStatusType> result = new SubmitResult<UnitStatusType>();
ModelState.Remove("Organization");
if (ModelState.IsValid)
{
using (var ctx = GetRepository())
{
var oldModel = ctx.Organizations.Where(f => f.Id == q).SelectMany(f => f.UnitStatusTypes).SingleOrDefault(f => f.Id == model.Id);
if (oldModel == null)
{
ctx.Organizations.Single(f => f.Id == q).UnitStatusTypes.Add(model);
}
else
{
oldModel.CopyFrom(model);
}
ctx.SaveChanges();
}
}
result.Result = model;
return Data(result);
}
