public async Task <int> CreateAndAssignToSingleUserAsync(Controller controller, string studentId, CreateViewModel inputModel, HttpPostedFileBase file)
{
AssignmentFileDTO assignmentFile = dtoFactory.CreateDTO <AssignmentFileDTOBuilderData, AssignmentFileDTO>(new AssignmentFileDTOBuilderData(file));
fileService.Create(assignmentFile);
string path = Path.Combine(controller.Server.MapPath("~/Files/Assignments"), assignmentFile.FileGuid);
file.SaveAs(path);
string mentorId = controller.User.Identity.GetUserId();
MentorDTO mentor = await mentorService.GetByIdAsync(mentorId);
AssignmentDTOBuilderData builderData = new AssignmentDTOBuilderData(inputModel, mentorId, assignmentFile);
AssignmentDTO newAssignment = dtoFactory.CreateDTO <AssignmentDTOBuilderData, AssignmentDTO>(builderData);
assignmentService.Create(newAssignment);
await assignmentService.SaveChangesAsync();
StudentDTO student = await studentService.GetByIdAsync(studentId);
if (student == null)
{
throw new Exception();
}
SubmissionDTOBuilderData bulderData = new SubmissionDTOBuilderData(studentId, newAssignment.AssignmentId, DateTime.Now.AddDays(3));
SubmissionDTO newSubmission = dtoFactory.CreateDTO <SubmissionDTOBuilderData, SubmissionDTO>(bulderData);
student.Submissions.Add(newSubmission);
await assignmentService.SaveChangesAsync();
return(newAssignment.AssignmentId);
}
public async Task <IFileStreamWithInfo> GetAssignmentFileAsync(int assignmentId)
{
AssignmentDTO assignment = await assignmentService.GetByIdAsync(assignmentId);
if (assignment == null || assignment.AssignmentFile == null)
{
return(null);
}
string origFileName = assignment.AssignmentFile.FileName;
string fileGuid = assignment.AssignmentFile.FileGuid;
string mimeType = MimeMapping.GetMimeMapping(origFileName);
IFileStreamWithInfo fileStream = null;
try
{
string filePath = Path.Combine(HttpContext.Current.Server.MapPath("~/Files/Assignments"), fileGuid);
fileStream = new FileStreamWithInfo
{
FileStream = File.ReadAllBytes(filePath),
FileName = origFileName,
FileType = mimeType
};
}
catch (Exception)
{
return(null);
}
return(fileStream);
}
public AssignmentDTO GetUserAssignment(Project project, Guid userId)
{
var result = new AssignmentDTO();
if (this.CurrentUOW.UserManager.RolesContainsAny(userId, Role.ORG_PROJECT_MANAGMENT, Role.ORG_ADMINSTRATOR))
{
result.AllowView = true;
result.AllowAdd = true;
result.AllowEdit = true;
result.AllowDelete = true;
result.AllowExportPdf = true;
result.AllowExportZip = true;
}
else
{
var assignment = project.Assignments.Where(a => a.OrgUserId == userId).SingleOrDefault();
if (assignment != null)
{
result.AllowView = assignment.CanView;
result.AllowAdd = assignment.CanAdd;
result.AllowEdit = assignment.CanEdit;
result.AllowDelete = assignment.CanDelete;
result.AllowExportPdf = assignment.CanExportPdf;
result.AllowExportZip = assignment.CanExportZip;
}
}
return(result);
}
public async Task addAssignementAddsDeleteAssignmentDeletes()
{
//Double Test of Insert and Delete. Not exactly a unit test, but practical. Does mutate the data if the test fails in the middle.
//Will be less necessary if Test DB was setup and torn down after each test run.
//arrange
var newAssignment = new AssignmentDTO()
{
lessonID = -5000,
description = "Test Assignemnt",
practiceNotes = "Test Notes"
};
//Act
var addedAssignment = await _repo.AddAssignment(newAssignment);
//Assert
//TODO: Build an equality function for this
Assert.Equal(newAssignment.lessonID, addedAssignment.lessonID);
Assert.Equal(newAssignment.description, addedAssignment.description);
Assert.Equal(newAssignment.practiceNotes, addedAssignment.practiceNotes);
//Act2
await _repo.DeleteAssignment(addedAssignment.assignmentID);
var deletedAssignemnt = await _repo.GetAssignment(addedAssignment.assignmentID);
//Assert
Assert.Null(deletedAssignemnt);
}
public int InsertByTableName(string tablename, AssignmentDTO entity)
{
assignRep.AddInputParameters("@tablename", tablename);
assignRep.AddInputParameters("@toid", entity.toid);
assignRep.AddInputParameters("@fromid", entity.fromid);
return(assignRep.IUD("sp_Assignment_InsertByTableName", CommandType.StoredProcedure));
}
public async Task AssignToStudentsAsync(int assigmentId, List <string> studentIds)
{
if (studentIds == null)
{
throw new ArgumentNullException("studentIds");
}
AssignmentDTO assignment = await assignmentService.GetByIdWithFileAsync(assigmentId);
if (assignment == null)
{
throw new KeyNotFoundException();
}
IEnumerable <StudentDTO> students = await studentService.GetAllByIdAsync(studentIds);
foreach (StudentDTO student in students)
{
SubmissionDTOBuilderData bulderData = new SubmissionDTOBuilderData(student.Id, assignment.AssignmentId, DateTime.Now.AddDays(3));
SubmissionDTO newSubmission = dtoFactory.CreateDTO <SubmissionDTOBuilderData, SubmissionDTO>(bulderData);
student.Submissions.Add(newSubmission);
}
await assignmentService.SaveChangesAsync();
}
public AssignmentDTO MapAssignment(Assignment assignment)
{
var dto = new AssignmentDTO();
MapAssignmentInternal(dto, assignment);
return(dto);
}
public async Task UpdateAsync(EdtiViewModel inputModel)
{
AssignmentDTOBuilderData builderData = new AssignmentDTOBuilderData(inputModel);
AssignmentDTO updatedAssignment = dtoFactory.CreateDTO <AssignmentDTOBuilderData, AssignmentDTO>(builderData);
assignmentService.UpdateTitle(updatedAssignment);
await assignmentService.SaveChangesAsync();;
}
public async Task <IActionResult> PostAssignment([FromBody] AssignmentDTO assignment)
{
_logger.LogInformation($"PostAssignment() method called: {assignment.lessonID}, {assignment.description}, {assignment.practiceNotes}");
var newAssignment = await _manager.InsertAssignment(assignment);
newAssignment.Links = BuildAssignmentLinks(newAssignment);
return(Created(newAssignment.Links.Where(p => p.Rel == "self").FirstOrDefault().Href, newAssignment));
}
public SummaryPageViewModel(INavigationService navigationService, INotificationService notify, IAssignmentDataAccessService assignmentDataAccessService) : base(
navigationService)
{
_notificationService = notify;
_assignmentDAService = assignmentDataAccessService;
var date = DateTime.Today;
_currentAssignment = new AssignmentDTO();
}
public IActionResult AddAssignment([FromBody] AssignmentDTO dto)
{
return(this.Created(() =>
{
bool result = _AssignmentRepo.Add(dto).Equals((int)TransactionStatus.SUCCESS);
return result ? dto.ToJson() : new JObject();
}));
}
public async Task <RemoveStudentViewModel> GetRemoveStudentViewModelAsync(int assignmentId, string studentId)
{
StudentDTO student = await studentService.GetByIdAsync(studentId);
AssignmentDTO assignment = await assignmentService.GetByIdWithFileAsync(assignmentId);
var viewModelData = new RemoveStudentViewData(student, assignment);
var viewModel = viewFactory.CreateView <RemoveStudentViewData, RemoveStudentViewModel>(viewModelData);
return(viewModel);
}
public ActionResult SaveRecord(string assignTable, AssignmentDTO entity)
{
if (ModelState.IsValid)
{
assignServ.InsertByTableName(assignTable, entity);
return(Json(new { mesaj = "Əlavə olundu" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { mesaj = "Xəta baş verdi!!!" }, JsonRequestBehavior.AllowGet));
}
}
public async Task <DeleteViewModel> GetDeleteViewModelAsync(int assignmentId)
{
AssignmentDTO assignment = await assignmentService.GetByIdAsync(assignmentId);
if (assignment == null)
{
return(null);
}
DeleteViewData viewModelData = new DeleteViewData(assignment);
DeleteViewModel viewModel = viewFactory.CreateView <DeleteViewData, DeleteViewModel>(viewModelData);
return(viewModel);
}
public async Task <DetailsViewModel> GetDetailsViewModelAsync(int assignmentId)
{
AssignmentDTO assignment = await assignmentService.GetByIdWithAssignmentFileCreatorAndSubmissionsAsync(assignmentId);
if (assignment == null)
{
return(null);
}
DetailsViewData viewModelData = new DetailsViewData(assignment);
DetailsViewModel viewModel = viewFactory.CreateView <DetailsViewData, DetailsViewModel>(viewModelData);
return(viewModel);
}
public void Update(AssignmentDTO assignment)
{
var dpt = _dbContext.Assignment.Find(assignment.Id);
_dbContext.Entry(dpt).CurrentValues.SetValues(assignment);
//var entity = _dbSet.SingleOrDefault(a => a.Id == attendance.Id);
if (dpt != null)
{
dpt = assignment;
}
}
public async Task DeleteAsync(int assignmentId)
{
AssignmentDTO assignment = await assignmentService.GetByIdAsyncWithSubmissionAndFiles(assignmentId);
foreach (SubmissionDTO submission in assignment.Submissions)
{
DeleteFile(submission.SubmitFile);
}
DeleteFile(assignment.AssignmentFile);
assignmentService.Delete(assignment);
await assignmentService.SaveChangesAsync();
}
public void Delete(AssignmentDTO assignment)
{
//if (_dbContext.Entry(assignment).State == EntityState.Detached)
//{
// _dbSet.Attach(assignment);
//}
var dpt = _dbContext.Assignment.Find(assignment.Id);
_dbContext.Entry(dpt).CurrentValues.SetValues(assignment);
_dbSet.Remove(dpt);
}
public async Task InsertAssignmentInvalidAssignemntThrowsError()
{
//Arrange
var assignment = new AssignmentDTO()
{
lessonID = 0, //this is an invalid value
description = "Description",
practiceNotes = "Notes"
};
//Act/Assert
await Assert.ThrowsAsync <HttpResponseException>(async() => await _manager.InsertAssignment(assignment));
}
public async Task <AssignmentDTO> AddAssignment(AssignmentDTO assignment)
{
//TODO: Data should be validated prior to insert. Strings should be truncated or rejected. Lesson Id is required
int id;
using (var conn = new SqliteConnection(_connString))
{
id = conn.QuerySingle <int>(@"Insert into assignment(lessonId,description, practiceNotes)
values(@lessonID, @description, @practiceNotes);
select last_insert_rowid()", assignment);
}
return(await this.GetAssignment(id));
}
public async Task <StudentsAndSubmissionsListViewModel> GetStudentsAndSubmissionsListViewModelAsync(int assingmentId)
{
AssignmentDTO assignment = await assignmentService.GetByIdIncludeAssingmentFileCreatorSubmissionStudentAsync(assingmentId);
if (assignment == null)
{
return(null);
}
var viewModelData = new StudentsAndSubmissionsListViewData(assignment);
var viewModel = viewFactory.CreateView <StudentsAndSubmissionsListViewData, StudentsAndSubmissionsListViewModel>(viewModelData);
return(viewModel);
}
public void AddAssignment(AssignmentDTO assignmentDTO)
{
Assignment assignmet = new Assignment
{
Id = assignmentDTO.Id,
Name = assignmentDTO.Name,
Description = assignmentDTO.Description,
StartTime = assignmentDTO.StartTime,
EndTime = assignmentDTO.EndTime
};
Database.Assignment.Create(assignmet);
Database.Save();
}
public void SubmitTask_Should_Accept_Correct_DataValues()
{
var taskList = new List <ConsultantTask>();
var allAssignment = new AssignmentDTO()
{
ConsultantTasks = taskList,
AssignerName = "Fortunatus Ochi",
DateAssigned = "07-16-2019"
};
AssignmentImplementation implementation = new AssignmentImplementation();
var assignmentDTO = new Mock <IAssignment>();
var ListOfAssignment = new List <GetAllAssignmentDTO>();
assignmentDTO.Setup(c => c.GetConsultantAssignmentsByPresentDate("")).Returns(Task.FromResult <AssignmentDTO>(allAssignment));
Assert.That(allAssignment, Is.InstanceOf <AssignmentDTO>());
}
public async Task <Assignment> InsertAssignment(AssignmentDTO assignmentDTO)
{
var assignment = GetAssignmentFromDTO(assignmentDTO);
//Just a basic validation - should be made more thorough
if (assignment.IsValid())
{
var returnData = await _repo.AddAssignment(GetDTOFromAssignment(assignment));
return(GetAssignmentFromDTO(returnData));
}
throw new HttpResponseException()
{
Status = 400, Value = "Assignment data is invalid. You should fix it and try again."
};
}
public int Update(int id, AssignmentDTO dto)
{
Assignment assignment = Find(i => i.Id.Equals(id));
if (assignment is null || assignment.Id <= 0)
{
return((int)TransactionStatus.ENTITY_NOT_FOUND);
}
if (assignment.Status.Equals(Status.Active.ToString()))
{
return(Update(assignment, dto));
}
return((int)TransactionStatus.UNCHANGED);
}
public void AddAssignment()
{
// Arrange:
AddAssignmentViewModel assignmentModel = new AddAssignmentViewModel
{
AssignmentGroupID = 1,
Name = "Another Assignment"
};
// Act:
AssignmentDTO newAssignment = _service.AddAssignment(1, assignmentModel);
// Assert:
Assert.AreEqual(assignmentModel.Name, newAssignment.Name);
Assert.AreEqual(assignmentModel.AssignmentGroupID, newAssignment.AssignmentGroupID);
}
public async Task InsertAssignmentInsertsValidAssignment()
{
//Arrange
var assignment = new AssignmentDTO()
{
lessonID = 1,
description = "Description",
practiceNotes = "Notes"
};
//Act
var returnedAssignment = await _manager.InsertAssignment(assignment);
//Assert
Assert.NotNull(returnedAssignment);
}
//Convert AssignmentDTO to Assignment
public Assignment GetAssignmentFromDTO(AssignmentDTO dto)
{
//Don't map if null
if (dto == null)
{
return(null);
}
//Provide Custom Mapping Here
return(new Assignment()
{
Id = dto.assignmentID,
LessonID = dto.lessonID,
Description = dto.description,
PracticeNotes = dto.practiceNotes
});
}
public async Task <IActionResult> PutAssignment(int id, AssignmentDTO assignmentDTO)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var assignmentToUpdate = await(from Assignment in _context.Assignments
join Course in _context.Courses
on Assignment.CourseId equals Course.CourseId
where Course.UserId == user.Id
select new Assignment
{
AssignmentId = Assignment.AssignmentId,
AssignmentName = Assignment.AssignmentName,
DueDate = Assignment.DueDate,
CourseId = Course.CourseId,
Course = Course
}).SingleOrDefaultAsync(a => a.AssignmentId == id);
if (id != assignmentToUpdate.AssignmentId)
{
return(BadRequest("Requested Id does not match any assignment."));
}
assignmentToUpdate.AssignmentName = assignmentDTO.AssignmentName;
assignmentToUpdate.DueDate = assignmentDTO.DueDate;
assignmentToUpdate.CourseId = assignmentDTO.CourseId;
_context.Entry(assignmentToUpdate).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AssignmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <AssignmentDTO> > PostAssignment(AssignmentDTO assignmentDTO)
{
Course theCourse = await _context.Courses.FindAsync(assignmentDTO.CourseId);
Assignment newAssignment = new Assignment
{
AssignmentName = assignmentDTO.AssignmentName,
DueDate = assignmentDTO.DueDate,
Course = theCourse,
CourseId = theCourse.CourseId
};
_context.Assignments.Add(newAssignment);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAssignment", new { id = newAssignment.AssignmentId }, newAssignment));
}