/// <summary> Изменение лабораторной работы </summary>
public void ModifyLabWork(LabWork lab)
{
CheckNotDisposed();
Context.Entry(lab).State = EntityState.Modified;
Context.SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("EventID,Title,Description,StartDateTime,CourseID")] LabWork labWork)
{
if (id != labWork.EventID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(labWork);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LabWorkExists(labWork.EventID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseID"] = new SelectList(_context.Courses, "CourseID", "Title", labWork.CourseID);
return(View(labWork));
}
private IEnumerable <BaseListEntryModel> GetOtherTasksModels(LabWork lab, Result result, Task task, DomainModel.TestPoolEntry testPoolEntry)
{
var otherTasks = result.AbstractResultEntries.Where(e => e is TestResult).Select(e =>
{
var testResult = (TestResult)e;
var entry = testResult.TestPoolEntry;
var model = _testModelLoader.Load(result, entry);
if (testResult.TestPoolEntry.Id == testPoolEntry?.Id)
{
model.State = TaskExecutionState.CurrentlySolving;
}
return((BaseListEntryModel)model);
});
var addTasks = lab.LabEntries.Select(e =>
{
var model = _taskModelLoader.Load(result, e);
if (e.Task.Id == task?.Id)
{
model.State = TaskExecutionState.CurrentlySolving;
}
return((BaseListEntryModel)model);
}).ToArray();
return(otherTasks.Union(addTasks));
}
/// <summary> Сохранение лабораторной работы </summary>
public void SaveLabWork(LabWork lab)
{
CheckNotDisposed();
Context.LabWorks.Add(lab);
Context.SaveChanges();
}
public CreateLabVariantModel(LabWork lab, long variantId = 0)
{
id = lab.Id;
varId = variantId;
Name = lab.Name;
Variant = MakeLabVariantModel(lab.LabEntries.Select(e => e.Task));
}
// GET: LabWorks/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LabWork labWork = db.LabWorks.Include(x => x.Exercises).FirstOrDefault(x => x.Id == id);
if (labWork == null)
{
return(HttpNotFound());
}
var selectedExercises = labWork.Exercises.Select(x => x.Id).ToArray();
var exercises = db.Exercises.Select(x => new
{
Id = x.Id,
Value = x.Name
}).ToList();
ViewBag.Exercises = new MultiSelectList(exercises, "Id", "Value", selectedExercises);
return(View(labWork));
}
private Task TryGetTaskByIndex(Result labResult, LabWork lab, int?index)
{
if (!index.HasValue)
{
return(null);
}
var taskEntry = lab.LabEntries.FirstOrDefault(e => e.Task.Id == index);
if (taskEntry == null)
{
return(null);
}
var taskResult = labResult
.AbstractResultEntries
.OfType <TaskResult>()
.SingleOrDefault(tr => tr.TaskVariant.Task.Id == taskEntry.Id &&
tr.Status == ExecutionStatus.Complete);
if (taskResult?.Status == ExecutionStatus.Complete)
{
return(null);
}
return(taskEntry.Task);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Type")] LabWork labwork)
{
if (id != labwork.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(labwork);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LabWorkExists(labwork.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(labwork));
}
/// <summary> Проверить существование лабораторной работы </summary>
public bool CheckLabWorkExist(long id)
{
CheckNotDisposed();
LabWork lab = Context.LabWorks.SingleOrDefault(l => l.Id == id);
return(lab == null ? false : true);
}
public ActionResult DeleteConfirmed(int id)
{
LabWork labWork = db.LabWorks.Find(id);
db.LabWorks.Remove(labWork);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ArrayLengthTest(int[] myArray, int expected)
{
// act
var actual = LabWork.GetLengthOfArray(myArray);
// assert
Assert.AreEqual(expected, actual);
}
public JSONResultLabInfo(LabWork lab)
: base(0)
{
LabId = lab.Id;
LabName = lab.Name;
Tasks = MakeTasksFromLabEntry(lab.LabEntries);
Variants = MakeVariantsFromLabVariants(lab.LabVariants);
}
/// <summary> Проверить существование лабораторной работы по имени</summary>
public bool CheckLabWorkExist(string name)
{
CheckNotDisposed();
LabWork lab = Context.LabWorks.SingleOrDefault(l => l.Name == name);
return(lab == null ? false : true);
}
public void SumTotalOfArrayTest()
{
//range
int[] myArray = { 10, 20, 30 };
var tExpected = 60;
var tActual = LabWork.SumTotalOfArrayTest(myArray);
Assert.AreEqual(tExpected, tActual);
}
public void CubicNumbersStaticTest(int x, int y, int z, int expected)
{
// arrange
// act
var actual = LabWork.CubeNumbersStatic(x, y, z);
// assert
Assert.AreEqual(expected, actual);
}
public void CubicNumbersTest(int x, int y, int z, int expected)
{
// arrange
var instance = new LabWork();
// act
var actual = instance.CubeNumbers(x, y, z);
// assert
Assert.AreEqual(expected, actual);
}
public ActionResult Create([Bind(Include = "Id,Name,IsOpened,DueDate")] LabWork labWork)
{
if (ModelState.IsValid)
{
db.LabWorks.Add(labWork);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(labWork));
}
public void SumTotalofArrayTest()
{
// arrange
int[] myArray = { 10, 20, 30 };
var expected = 3;
// act
var actual = LabWork.SumTotalofArrayMembers(myArray);
// assert
Assert.AreEqual(expected, actual);
}
public async Task <IActionResult> Create([Bind("ID,Name,Type")] LabWork product)
{
if (ModelState.IsValid)
{
_context.Add(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
public async Task <IActionResult> Create([Bind("EventID,Title,Description,StartDateTime,CourseID")] LabWork labWork)
{
if (ModelState.IsValid)
{
_context.Add(labWork);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseID"] = new SelectList(_context.Courses, "CourseID", "Title", labWork.CourseID);
return(View(labWork));
}
// GET: LabWorks/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LabWork labWork = db.LabWorks.Find(id);
if (labWork == null)
{
return(HttpNotFound());
}
return(View(labWork));
}
public JsonResult LabWorkCreate(string Name, string JsonArr)
{
if (_labRepository.CheckLabWorkExist(Name))
{
return(Json(new JSONResultCreateLab(ResponseConstants.LabWorkExistErrorSystemName, Name)));
}
;
LabWork lab = _labWorksContext.LabWorks.CreateNew();
lab.Name = Name;
_labRepository.SaveLabWork(lab);
_labRepository.SaveLabEntries(lab.Id, JsonConvert.DeserializeObject <long[]>(JsonArr));
_labRepository.DeleteExcessTaskVariantsFromLabVariants(lab.Id);
return(Json(new JSONResultCreateLab(ResponseConstants.LabWorkSuccessCreateSystemName, Name, lab.Id)));
}
public JsonResult CreateVariant(long Id, string Number, string JsonArr, bool IntrVar)
{
LabWork lab = _labRepository.GetLabWorkById(Id);
if (_labRepository.CheckLabVariantExist(Id, Number))
{
return(Json(ResponseConstants.LabVariantNameCollisionSystemName));
}
LabVariant labVar = _labWorksContext.LabVariants.CreateNew();
labVar.LabWork = lab;
labVar.Number = Number;
labVar.IntroducingVariant = IntrVar;
labVar.Version = 1;
labVar.TaskVariants = MakeTaskVariantsList(JsonConvert.DeserializeObject <long[]>(JsonArr));
return(Json(ResponseConstants.LabVariantSaveSuccessSystemName));
}
/// <summary> Сохранение содержания лабораторной работы </summary>
public void SaveLabEntries(long labWorkId, long[] tasksId)
{
CheckNotDisposed();
int i = 0;
LabWork lab = GetLabWorkById(labWorkId);
foreach (var task in tasksId.Distinct().Select(id => _taskRepository.Tasks.Find(id)))
{
LabEntry entry = Context.LabEntries.Create();
entry.LabWork = lab;
entry.Order = ++i;
entry.Task = task;
Context.LabEntries.Add(entry);
}
Context.SaveChanges();
}
public JsonResult LabWorkEdit(string Name, string JsonArr, long id)
{
if (_labRepository.CheckLabWorkExist(Name) && (_labRepository.GetLabWorkIdByName(Name) != id))
{
return(Json(new JSONResultCreateLab(ResponseConstants.LabWorkExistErrorSystemName, Name)));
}
;
LabWork lab = _labRepository.GetLabWorkById(id);
var message = "";
lab.Name = Name;
_labRepository.DeleteEntries(id);
lab.LabEntries.Clear();
_labRepository.ModifyLabWork(lab);
_labRepository.SaveLabEntries(lab.Id, JsonConvert.DeserializeObject <long[]>(JsonArr));
_labRepository.DeleteExcessTaskVariantsFromLabVariants(lab.Id);
return(Json(new JSONResultCreateLab(ResponseConstants.LabWorkSuccessEditSystemName, Name, lab.Id)));
}
public ActionResult Edit([Bind(Include = "Id,Name,IsOpened,DueDate")] LabWork labWork, int[] exerciseIds)
{
if (ModelState.IsValid)
{
db.Entry(labWork).State = EntityState.Modified;
db.SaveChanges();
labWork = db.LabWorks.Include(x => x.Exercises).FirstOrDefault(x => x.Id == labWork.Id);
if (exerciseIds == null)
{
labWork.Exercises.Clear();
}
else
{
var selectedExercises = db.Exercises.Where(x => exerciseIds.Contains(x.Id)).ToList();
labWork.Exercises = selectedExercises;
}
db.SaveChanges();
return(RedirectToAction("Details", new { labWork.Id }));
}
return(View(labWork));
}
public void ArrayToSort(int[] array, int[] expectedArray)
{
var actualArray = LabWork.SortArray(array);
Assert.AreEqual(expectedArray, actualArray);
}
public void MultiplicationAndFactors(double x, double y, double n, double expected)
{
var actual = LabWork.MultiplicationAndFactors(x, y, n);
Assert.AreEqual(expected, actual);
}
public void ReturnSumOfArray(int[] array, int expected)
{
var actual = LabWork.SumTotalOfArrayMembers(array);
Assert.AreEqual(expected, actual);
}
public void GetLengthOfArrayTest(int[] array, int expected)
{
var actual = LabWork.GetLengthOfArray(array);
Assert.AreEqual(expected, actual);
}
