public async Task <bool> UpdateTaskByIdAsync(int taskId, TaskDTO taskDTO)
{
StudentTask item = await db.Tasks.GetAsync(taskId);
if (item == null)
{
return(false);
}
if (!string.IsNullOrEmpty(taskDTO.Name))
{
item.Name = taskDTO.Name;
}
if (!string.IsNullOrEmpty(taskDTO.Description))
{
item.Description = taskDTO.Description;
}
item.Private = taskDTO.Private;
if (taskDTO.ModifierId != null)
{
item.Mod_Id = taskDTO.ModifierId;
}
item.Youtube_Url = taskDTO.Youtube_Url;
await db.Tasks.UpdateAsync(item);
db.Save();
return(true);
}
private void SaveTaskProc()
{
title = SelectedTask.Title;
StudentTask task = new StudentTask();
foreach (var v in AssociatedPerson.Tasks)
{
if (v.Title == SelectedTask.Title && v.Description == SelectedTask.Description)
{
task = v;
}
}
AssociatedPerson.Tasks.Remove(task);
AssociatedPerson.Tasks.Add(TaskModel);
//if (!string.IsNullOrEmpty(task.Title) )
//{
// task.Title = TaskModel.Title;
// task.Description = TaskModel.Description;
//}
EditTask();
ReadToDoListFromTextFile();
EditTaskWindow.Close();
}
public async Task <bool> AddTaskToPlanAsync(TaskDTO taskDTO, int?selectedPriority, int?selectedSection)
{
StudentTask task = new StudentTask
{
Name = taskDTO.Name,
Description = taskDTO.Description,
Private = taskDTO.Private,
Create_Id = taskDTO.CreatorId,
Create_Date = taskDTO.CreateDate,
};
await db.Tasks.AddAsync(task);
db.Save();
int taskId = await db.Tasks.GetTaskIdAsync(task);
PlanTask planTask = new PlanTask
{
Plan_Id = taskDTO.PlanTaskId.Value,
Task_Id = taskId,
Priority = selectedPriority,
Section_Id = selectedSection
};
await db.PlanTasks.AddAsync(planTask);
db.Save();
return(true);
}
public IActionResult AddStudentTag(int id)
{
StudentTask studentTask = context.StudentTasks.Find(id);
List <StudentTag> possibleTags = context.StudentTags.ToList();
AddTaskTagViewModel viewModel = new AddTaskTagViewModel(studentTask, possibleTags);
return(View(viewModel));
}
public ExtendedTaskViewModel(StudentTask task)
{
TaskName = task.Name;
Type = task.IsContest ? "Контест" : "Контрольная работа";
GroupName = task.Group.Name;
NumberOfAttempts = task.NumberOfAttempts;
Deadline = task.To.ToString();
TaskId = task.Id;
}
public async Task <TaskDTO> GetTaskByIdAsync(int taskId)
{
StudentTask taks = await db.Tasks.GetAsync(taskId);
if (taks == null)
{
return(null);
}
return(await TaskToTaskDTOAsync(taks));
}
public IActionResult Delete(int[] studentTaskIds)
{
foreach (int studentTaskId in studentTaskIds)
{
//StudentTaskData.Remove(studentTaskId);
StudentTask theStudentTask = context.StudentTasks.Find(studentTaskId);
context.StudentTasks.Remove(theStudentTask);
}
context.SaveChanges();
return(Redirect("/StudentTask"));
}
public IActionResult DetailStudent(int id)
{
StudentTask theStudentTask = context.StudentTasks.Single(e => e.Id == id);
//List<TaskTag> studentNamesText = context.TaskTags
// .Where(et => et.StudentTaskId == id)
// .Include(et => et.StudentTag)
// .ToList();
DetailStudentTaskViewModel viewModel = new DetailStudentTaskViewModel(theStudentTask);
return(View(viewModel));
}
public TaskViewModelNew(StudentTask task)
{
Id = task.Id;
Name = task.Name;
Text = task.TaskText;
GroupId = task.GroupId.Value;
Time = new List <DateTime> {
task.From, task.To
};
IsContest = task.IsContest;
AttemptsNumber = task.NumberOfAttempts;
Tests = task.Tests.Select(t => new TestViewModel(t, task.Tests.IndexOf(t))).ToList();
}
async private void GetMarks()
{
this.marks = await APIHandler.GetGroupMarks(group);
foreach (AbstractMark mark in this.marks)
{
StudentTask key = new StudentTask()
{
studentId = mark.GetStudentId(), taskId = mark.GetTaskId()
};
studentTaskMarkLinker[key] = mark;
}
ProgressBarIncrement();
}
public bool CreateTask(TaskDTO taskDTO)
{
var task = new StudentTask()
{
Name = taskDTO.Name,
Description = taskDTO.Description,
Private = taskDTO.Private,
Create_Id = taskDTO.CreatorId,
Mod_Id = taskDTO.ModifierId
};
db.Tasks.AddAsync(task);
db.Save();
return(true);
}
public AddTaskTagViewModel(StudentTask studentTask, List <StudentTag> possibleTags)
{
StudentTags = new List <SelectListItem>();
foreach (var tag in possibleTags)
{
StudentTags.Add(new SelectListItem
{
Value = tag.Id.ToString(),
Text = tag.StudentName
});
}
StudentTask = studentTask;
}
private void EditTaskProc()
{
if (SelectedTask == null)
{
MessageBox.Show("Select task to edit first");
return;
}
EditTaskWindow = new EditTaskWindow();
TaskModel = new StudentTask()
{
Title = SelectedTask?.Title,
Description = SelectedTask?.Description
};
EditTaskWindow.Show();
}
public async Task <bool> RemoveTaskByIdAsync(int taskId)
{
await db.Tasks.DeleteTaskAsync(taskId);
StudentTask item = await db.Tasks.GetAsync(taskId);
if (item != null || await db.Tasks.IsRemovableAsync(taskId))
{
await db.Tasks.RemoveAsync(item);
db.Save();
return(true);
}
return(false);
}
public async Task <TaskDTO> GetTaskForPlanAsync(int taskId, int planId)
{
StudentTask task = await db.Tasks.GetAsync(taskId);
if (task == null)
{
return(null);
}
var planTask = await db.PlanTasks.Get(taskId, planId);
if (planTask == null)
{
return(null);
}
return(await GetTaskForPlanAsync(planTask.Id));
}
public async Task <ActionResult <StudentTaskDTO> > PostStudentTask(StudentTaskDTO studentTaskDTO)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
StudentTask newStudentTask = new StudentTask
{
StudentTaskName = studentTaskDTO.StudentTaskName,
TaskDueDate = studentTaskDTO.TaskDueDate,
Priority = studentTaskDTO.Priority,
UserId = user.Id,
};
_context.StudentTasks.Add(newStudentTask);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetStudentTask", new { id = newStudentTask.StudentTaskId }, newStudentTask));
}
private async Task <TaskDTO> TaskToTaskDTOAsync(StudentTask task)
{
return(new TaskDTO(task.Id,
task.Name,
task.Description,
task.Private,
task.Create_Id,
await db.Users.ExtractFullNameAsync(task.Create_Id),
task.Mod_Id,
await db.Users.ExtractFullNameAsync(task.Mod_Id),
task.Create_Date,
task.Mod_Date,
null,
null,
null,
task.Youtube_Url));
}
public async Task <int?> AddAndGetIdAsync(TaskDTO taskDTO)
{
if (!(await db.Users.ContainsIdAsync(taskDTO.CreatorId)))
{
return(null);
}
var task = new StudentTask
{
Name = taskDTO.Name,
Description = taskDTO.Description,
Private = taskDTO.Private,
Create_Id = taskDTO.CreatorId,
Mod_Id = taskDTO.ModifierId
};
var createdTask = db.Tasks.AddAndReturnElement(task);
db.Save();
return(createdTask?.Id);
}
public IActionResult Add(AddStudentTaskViewModel addStudentTaskViewModel)
{
var currentUserId = userManager.GetUserId(User);
StudentTask newStudentTask = new StudentTask
{
Name = addStudentTaskViewModel.Name,
Description = addStudentTaskViewModel.Description,
DueDate = addStudentTaskViewModel.DueDate,
UserId = currentUserId
};
//StudentTaskData.Add(newStudentTask);
//New two lines store to persistent database
context.StudentTasks.Add(newStudentTask);
context.SaveChanges();
return(Redirect("/StudentTask"));
}
public TaskTestViewModel(TaskTest t, StudentTask task, string[] frameworkTypes, CodeStyleFilesViewModel[] codeStyleFiles)
{
CodeStyleFiles = codeStyleFiles;
FrameworkTypes = frameworkTypes;
TaskName = task.Name;
GroupName = task.Group.Name;
Id = t.Id;
TaskId = t.TaskId;
Type = t.TestType;
Name = TestsNamesConverter.ConvertTypeToName(t.TestType);
if (TestsNamesConverter.IsValidType(Type))
{
object obj = null;
if (t.TestData != null)
{
switch (Type)
{
case "reflectionTest":
obj = JsonConvert.DeserializeObject <ReflectionTestData>(t.TestData);
break;
case "functionalTest":
obj = JsonConvert.DeserializeObject <FunctionalTestData>(t.TestData);
break;
case "codeStyleTest":
obj = JsonConvert.DeserializeObject <CodeStyleTestData>(t.TestData);
break;
}
}
Data = obj;
IsRaw = false;
}
else
{
Data = t.TestData;
IsRaw = true;
}
}
public async ThreadTask.Task <bool> AddTaskToPlanAsync(int planId, int taskId, int?sectionId, int?priority)
{
var plan = await db.Plans.Get(planId);
if (plan == null)
{
return(false);
}
StudentTask task = await db.Tasks.GetAsync(taskId);
if (task == null)
{
return(false);
}
await db.Plans.AddTaskToPlanAsync(planId, taskId, sectionId, priority);
await CreateUserTasksForAllLearningByPlanAsync(planId, taskId);
db.Save();
return(true);
}
private void ProcessData()
{
dataGrid.ColumnCount = this.tasks.Length;
dataGrid.RowCount = this.students.Length;
this.markGrid = new AbstractMark[dataGrid.ColumnCount, dataGrid.RowCount]; // Used to store references to each mark - making the tooltips work
for (int i = 0; i < this.tasks.Length; i++)
{
dataGrid.Columns[i].HeaderCell.Value = this.tasks[i].title;
dataGrid.Columns[i].ReadOnly = false;
}
for (int i = 0; i < this.students.Length; i++)
{
Student student = this.students[i];
dataGrid.Rows[i].HeaderCell.Value = student.fullName;
for (int j = 0; j < this.tasks.Length; j++)
{
Assignment task = this.tasks[j];
StudentTask key = new StudentTask()
{
studentId = student.id, taskId = task.id
};
AbstractMark mark;
bool exists = studentTaskMarkLinker.TryGetValue(key, out mark);
if (exists)
{
this.markGrid[j, i] = mark;
}
else
{
this.markGrid[j, i] = new AbstractMark(student.id, task.id); // Add an empty mark
}
// The tooltip should not be set here because it can cause performance issues - https://docs.microsoft.com/en-us/dotnet/desktop/winforms/controls/add-tooltips-to-individual-cells-in-a-wf-datagridview-control?view=netframeworkdesktop-4.8#robust-programming
}
}
this.dataGridInitialised = true;
}
protected bool CanSend(StudentTask task, string studentId, Solution[] solutions = null)
{
bool canSend = false;
if (task.To > DateTime.Now)
{
if (solutions is null)
{
solutions = _db.Solutions.Where(s => s.StudentId == studentId && s.TaskId == task.Id).ToArray();
}
if (task.IsContest)
{
canSend = solutions.Length < task.NumberOfAttempts;
}
else
{
canSend = solutions.Length == 0;
}
}
return(canSend);
}
//public string StudentNamesText { get; set; }
public DetailStudentTaskViewModel(StudentTask studentTask)
{
this.TaskId = studentTask.Id;
this.Name = studentTask.Name;
this.Description = studentTask.Description;
this.DueDate = studentTask.DueDate;
this.SubmitDate = studentTask.SubmitDate;
this.ApproveDate = studentTask.ApproveDate;
this.Approved = studentTask.Approved;
//this.StudentNamesText = "";
//for (var i = 0; i < taskTags.Count; i++)
//{
// StudentNamesText += taskTags[i].StudentTag.StudentName;
// if (i < taskTags.Count - 1)
// {
// StudentNamesText += ", ";
// }
//}
}
public async Task <IActionResult> PutStudentTask(int id, StudentTaskDTO studentTaskDTO)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
StudentTask taskToUpdate = await _context.StudentTasks.FindAsync(id);
if (id != taskToUpdate.StudentTaskId)
{
return(BadRequest("Task Id does not match any task."));
}
taskToUpdate.Priority = studentTaskDTO.Priority;
taskToUpdate.StudentTaskName = studentTaskDTO.StudentTaskName;
taskToUpdate.TaskDueDate = studentTaskDTO.TaskDueDate;
taskToUpdate.UserId = user.Id; // Added UserId
_context.Entry(taskToUpdate).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PostNewTask(string json)
{
TaskViewModelNew jsonTask = JsonConvert.DeserializeObject <TaskViewModelNew>(json);
StudentTask newTask = new StudentTask
{
Name = jsonTask.Name,
GroupId = jsonTask.GroupId,
TaskText = jsonTask.Text,
IsContest = jsonTask.IsContest,
From = jsonTask.Time[0],
To = jsonTask.Time[1],
NumberOfAttempts = jsonTask.AttemptsNumber
};
var x = _db.StudentTasks.Add(newTask);
var beforeState = x.State;
int r = _db.SaveChanges();
var afterState = x.State;
bool ok = beforeState == Microsoft.EntityFrameworkCore.EntityState.Added && afterState == Microsoft.EntityFrameworkCore.EntityState.Unchanged && r == 1;
if (ok)
{
var newTaskTests = jsonTask.Tests.Select(tt =>
new TaskTest
{
TaskId = newTask.Id,
TestType = tt.Type,
Block = tt.Block,
Weight = tt.Weight / 100.0,
TestData = null
}).ToArray();
_db.TaskTests.AddRange(newTaskTests);
r = _db.SaveChanges();
ok = r == newTaskTests.Length;
}
if (ok)
{
var plagCheck = new PlagiarismCheck
{
TaskId = newTask.Id,
Settings = new PlagiarismCheckSettings
{
Language = "csharp",
MaxMatches = 5,
MinPercent = 0.4,
MakeCheck = false
}
};
_db.Add(plagCheck);
_db.SaveChanges();
try
{
var msgQueue = RabbitHutch.CreateBus(_config.MessageQueueInfo, _config.FrontEnd);
var request = new PlagiarismCheckRequest
{
TaskId = newTask.Id,
};
await msgQueue.SendAsync(_config.MessageQueueInfo.PlagiarismQueueName, request);
}
catch (RabbitMQ.Client.Exceptions.BrokerUnreachableException e)
{
return(Content("error"));
}
}
return(Content(ok ? "/TestingSystem/Professor/ChangeTask?id=" + newTask.Id.ToString() : "error"));
}
public TaskDetailPage(StudentTask task)
{
Task = task;
InitializeComponent();
}
private void ShowAddNewTaskProc()
{
AddNewTaskWindow = new AddNewTaskWindow();
TaskModel = new StudentTask();
AddNewTaskWindow.Show();
}
