//accept a candidate for an assignments
//UserAssignment-object property Accepted is set to true
// Status of this assignment becomes 'Closed'
//the other candidates - UserAssignment-objects are deleted
//returns ok
public async Task <IActionResult> AcceptAssignmentCandidate(int assignmentID, int candidateID)
{
//get UserAssignment-object of this assignment and the user
UserAssignment userAssignment = _context.UserAssignments.Include(ua => ua.Assignment).Include(ua => ua.User).FirstOrDefault(ua => ua.Assignment.AssignmentID == assignmentID && ua.User.UserID == candidateID);
//set Accepted to true - this user can do the assignment
userAssignment.Accepted = true;
_context.Entry(userAssignment).State = EntityState.Modified;
//assignment-status is set to Closed
Assignment assignment = _context.Assignments.Include(a => a.Status).FirstOrDefault(a => a.AssignmentID == assignmentID);
assignment.Status = _context.Status.FirstOrDefault(s => s.CurrentStatus == "Closed");
_context.Entry(userAssignment).State = EntityState.Modified;
// delete the userAssignment-object from the other candidates
List <UserAssignment> userAssignments = _context.UserAssignments.Include(ua => ua.Assignment).Include(ua => ua.User).Where(ua => ua.Assignment.AssignmentID == assignmentID && ua.User.UserID != candidateID).ToList();
foreach (var u in userAssignments)
{
_context.UserAssignments.Remove(u);
}
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> PutUserAssignment(long id, UserAssignment userAssignment)
{
if (id != userAssignment.UserAssignmentID)
{
return(BadRequest());
}
_context.Entry(userAssignment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserAssignmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <UserAssignment> PostUserAssignment(UserAssignment assignment)
{
var updated = _store.UserAssignments.Update(assignment);
var saved = await _store.SaveChangesAsync();
return(updated.Entity);
}
public async Task <IActionResult> StudentAcceptsAssignment(long id)
{
var userID = long.Parse(User.Claims.FirstOrDefault(c => c.Type == "UserID").Value);
User user = await _context.Users.FindAsync(userID);
if (user == null)
{
return(NotFound());
}
UserAssignment ua = new UserAssignment
{
AssignmentID = id,
UserID = userID,
Status = false,
Progress = 0
};
var uas = _context.UserAssignments;
if (uas != null)
{
foreach (UserAssignment uass in uas)
{
if (uass.AssignmentID == ua.AssignmentID && uass.UserID == ua.UserID)
{
return(NoContent()); //User has already accepted this assignment
}
}
}
_context.UserAssignments.Add(ua);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <dynamic> AddUserAssignmentAsync(dynamic model)
{
var userAssignment = new UserAssignment {
CourseId = model.courseId,
UserId = model.userId,
AssignmentId = model.assignmentId,
FileContent = model.fileContent,
TextContent = model.textContent
};
await _repository.AddAsync(userAssignment);
var result = new {
success = true,
id = userAssignment.Id,
courseId = userAssignment.CourseId,
userId = userAssignment.UserId,
assignmentId = userAssignment.AssignmentId,
grade = "",
fileContent = userAssignment.FileContent,
textContent = userAssignment.TextContent
};
return(null);
}
public async Task <ActionResult <UserAssignment> > PostUserAssignment(UserAssignment userAssignment)
{
_context.UserAssignments.Add(userAssignment);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserAssignment", new { id = userAssignment.UserAssignmentID }, userAssignment));
}
public async Task <IActionResult> AssignUsersToAssignment(AssignUsersToAssignmentViewModel newAssignViewModel, Guid id, Guid AssignmentId)
{
ViewBag.AvailableTeamUsers = new SelectList(await _assignmentService.GetListOfAvailableAssignmentUsers(id, AssignmentId), "Id", "MemberName");
if (ModelState.IsValid)
{
Guid guidid = Guid.Parse(newAssignViewModel.AppUserId);
UserAssignment userAssignment = new UserAssignment
{
AppUser = await _userManager.FindByIdAsync(newAssignViewModel.AppUserId),
AppUserId = guidid,
Assignment = await _assignmentService.GetAssignmentById(AssignmentId),
AssignmentId = AssignmentId
};
await _assignmentService.AddUserAssignment(userAssignment);
List <AppUser> AssignmentMemberList = await _assignmentService.GetAssignmentUserList(AssignmentId);
if (AssignmentMemberList.Count > 0)
{
await _assignmentService.ChangeStatusToInProgress(AssignmentId);
}
return(RedirectToAction("AssignUsersToAssignment", new { AssignmentId }));
}
return(RedirectToAction("AssignUsersToAssignment", new { AssignmentId }));
}
public void GetUserAssignmentTest()
{
var options = new DbContextOptionsBuilder <AppDBContext>()
.UseInMemoryDatabase(databaseName: "UserAssignmentGetDatabase")
.Options;
using (var context = new AppDBContext(options))
{
context.UserAssignment.Add(new UserAssignment {
Id = "1", Text = "1"
});
context.UserAssignment.Add(new UserAssignment {
Id = "2", Text = "2"
});
context.UserAssignment.Add(new UserAssignment {
Id = "3", Text = "3"
});
context.UserAssignment.Add(new UserAssignment {
Id = "4", Text = "4"
});
context.SaveChanges();
}
using (var context = new AppDBContext(options))
{
UserAssignmentRepository userAssignmentRepository = new UserAssignmentRepository(context);
UserAssignment userAssignment = userAssignmentRepository.Get("1");
Assert.Equal("1", userAssignment.Text);
}
}
public AssignmentViewModel getAssignmentGrade(int userId, int assignmentId)
{
//Sæki öll gögn í verkefna töfluna
var assignment = (from assign in _db.Assignment
join userAssignment in _db.UserAssignment on assign.assignmentId equals userAssignment.assignmentId
where assign.assignmentId == assignmentId && userAssignment.userId == userId
select new { assign, userAssignment }).SingleOrDefault();
UserAssignment userAssign = null;
if (assignment.assign.gradePublished == 1)
{
userAssign = new UserAssignment
{
userAssignmentId = assignment.userAssignment.userAssignmentId,
userId = assignment.userAssignment.userId,
userGroupId = assignment.userAssignment.userGroupId,
grade = assignment.userAssignment.grade,
gradeComment = assignment.userAssignment.gradeComment
};
}
//Bý til nýtt AssingmentViewModel og set listann inn í það
AssignmentViewModel viewModel = new AssignmentViewModel
{
UserAssignment = userAssign
};
//Returna viewModelinu með listanum
return(viewModel);
}
//Remove UserAssignment. InOtherWords Remove User from an Assigment.
public async Task <int> RemoveUserAssignment(Guid AssignmentId, Assignment assignment, string id, AppUser appUser)
{
Guid userIdGuid = Guid.Parse(id);
UserAssignment userAssignment = _context.UserAssignments.Where(x => x.AssignmentId == AssignmentId && x.Assignment == assignment && x.AppUserId == userIdGuid && x.AppUser == appUser).FirstOrDefault();
_context.UserAssignments.Remove(userAssignment);
return(await _context.SaveChangesAsync());
}
//a user cancels his 'apply' from this assignment
//userAssignment is deleted
//returns Ok
public async Task <ActionResult <UserAssignment> > CancelAssignment(int assignmentID, int userID)
{
UserAssignment userAssignment = _context.UserAssignments.Include(ua => ua.Assignment).FirstOrDefault(ua => ua.Assignment.AssignmentID == assignmentID && ua.User.UserID == userID);
_context.UserAssignments.Remove(userAssignment);
await _context.SaveChangesAsync();
return(Ok());
}
public IActionResult CreateAssignment([FromForm] CreateAssignment model)
{
try
{
Assignment showPiece = db.Assignment
.OrderByDescending(p => p.IdAssignment)
.FirstOrDefault();
string emailCurrentUser = User.FindFirst(ClaimTypes.Name).Value;
Users tempUser = _userService.FindUser(emailCurrentUser, db);
Assignment tempAssg = new Assignment();
if (showPiece == null)
{
tempAssg.IdAssignment = db.Assignment.Count() + 1;
}
else
{
tempAssg.IdAssignment = (showPiece.IdAssignment) + 1;
}
tempAssg.Name = model.NameAsg;
tempAssg.Description = model.Description;
tempAssg.PercentOfFinalGrade = model.Percentage;
tempAssg.Deadline = Convert.ToDateTime(model.Deadline);
tempAssg.IdSubject = model.SubjectName;
tempAssg.Length = model.LengthDur;
tempAssg.Difficulty = model.DifficultyLevel;
tempAssg.Done = false;
db.Assignment.Add(tempAssg);
db.SaveChanges();
UserAssignment showPieceTemp = db.UserAssignment
.OrderByDescending(p => p.IdUserAssignment)
.FirstOrDefault();
UserAssignment tempRel = new UserAssignment();
if (showPieceTemp == null)
{
tempRel.IdUserAssignment = db.UserAssignment.Count() + 1;
}
else
{
tempRel.IdUserAssignment = (showPieceTemp.IdUserAssignment) + 1;
}
tempRel.IdAssignment = tempAssg.IdAssignment;
tempRel.IdUser = tempUser.IdUser;
db.UserAssignment.Add(tempRel);
db.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task UndoTurnIn(int assignmentId, string userId)
{
UserAssignment userAssignment = this.userAssignmentRepository
.All()
.FirstOrDefault(ua => ua.AssignmentId == assignmentId && ua.UserId == userId);
userAssignment.TurnedOn = null;
await this.userAssignmentRepository.SaveChangesAsync();
}
//a company declines this user for the assignment
//UserAssignment gets deleted
//returns ok
public async Task <IActionResult> DeclineAssignmentCandidate(int assignmentID, int candidateID)
{
UserAssignment userAssignment = _context.UserAssignments.Include(ua => ua.Assignment).Include(ua => ua.User).FirstOrDefault(ua => ua.Assignment.AssignmentID == assignmentID && ua.User.UserID == candidateID);
_context.UserAssignments.Remove(userAssignment);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task MarkAsSeen(int assignmentId, string userId)
{
UserAssignment userAssignment = this.userAssignmentRepository
.All()
.FirstOrDefault(ua => ua.AssignmentId == assignmentId && ua.UserId == userId);
userAssignment.Seen = true;
await this.userAssignmentRepository.SaveChangesAsync();
}
public void DeleteUserAssignment(Users user, toDoListConestogaContext db, int idAssgn)
{
UserAssignment tempRelationship = db.UserAssignment.Where(uEntity => uEntity.IdAssignment == idAssgn && uEntity.IdUser == user.IdUser).SingleOrDefault();
Assignment tempAssign = db.Assignment.Where(aEntity => aEntity.IdAssignment == idAssgn).SingleOrDefault();
db.Assignment.Remove(tempAssign);
db.SaveChanges();
db.UserAssignment.Remove(tempRelationship);
db.SaveChanges();
}
// GET: Assignment/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Assignment assignment = db.Assignments.Find(id);
UserAssignment ua = db.UserAssignments.Where(a => a.Assignment.Id == assignment.Id && a.User.UserName == User.Identity.Name).FirstOrDefault();
if (assignment == null)
{
return(HttpNotFound());
}
return(View(ua));
}
public async Task<IActionResult> Register(UserForRegisterDto userForRegisterDto, string userRole)
{
var userToCreate = _mapper.Map<User>(userForRegisterDto);
var assignments = await _context.Assignments.Where(a => a.StudentLevel == userToCreate.StudentLevel).ToListAsync();
var result = await _userManager.CreateAsync(userToCreate, userForRegisterDto.Password);
var userToReturn = _mapper.Map<UserForDetailedDto>(userToCreate);
foreach(var assignment in assignments)
{
var userAssignment = new UserAssignment
{
UserId = userToReturn.Id,
AssignmentId = assignment.Id,
Completed = false
};
_context.Add(userAssignment);
}
if (result.Succeeded)
{
switch (userRole)
{
case "student":
_userManager.AddToRolesAsync(userToCreate, new [] {"Student"}).Wait();
break;
case "tutor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Tutor"}).Wait();
break;
case "mentor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Mentor"}).Wait();
break;
case "admin":
_userManager.AddToRolesAsync(userToCreate, new [] {"Admin"}).Wait();
break;
}
return CreatedAtRoute("GetUser",
new { controller = "Users", id = userToCreate.Id }, userToReturn);
}
return BadRequest(result.Errors);
}
public async Task <IActionResult> CreateAssignment(int creatorId, [FromBody] AssignmentForCreationDto assignmentForCreationDto)
{
var assignmentCreator = await _repo.GetUser(creatorId);
if (assignmentCreator.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
assignmentForCreationDto.CreatedBy = assignmentCreator;
var assignment = _mapper.Map <Assignment>(assignmentForCreationDto);
if (assignment.Assigned)
{
assignment.DateAssigned = DateTime.Now;
}
var students = _repo.GetStudents(assignmentForCreationDto.StudentLevel);
_repo.Add(assignment);
foreach (var student in students.Result)
{
var userAssignment = new UserAssignment()
{
UserId = student.Id,
AssignmentId = assignment.Id,
Completed = false
};
if (!student.UserAssignments.Contains(userAssignment))
{
_repo.Add(userAssignment);
}
}
if (await _repo.SaveAll())
{
// _repo.SqlCmdHelper("SET IDENTITY_INSERT dbo.UserAssignments OFF");
var assignmentToReturn = _mapper.Map <AssignmentToReturnDto>(assignment);
return(CreatedAtRoute("GetAssignment", new { id = assignment.Id }, assignmentToReturn));
}
throw new Exception("Creating the assignment failed on save");
}
public async Task <IActionResult> UpdateUserAssignment(int id, UserAssignment userAssignment)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userAssignmentFromRepo = await _repo.GetUserAssignment(userAssignment.AssignmentId);
userAssignmentFromRepo.Completed = userAssignment.Completed;
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating UserAssignment {id} failed on save");
}
public async Task UpdateCheckedAsync(EditCheckedAssignmentInputModel inputModel)
{
UserAssignment userAssignment = this.userAssignmentRepository
.All()
.FirstOrDefault(ua => ua.AssignmentId == inputModel.AssignmentId && ua.UserId == inputModel.UserId);
userAssignment.Points = inputModel.Points;
userAssignment.Feedback = inputModel.Feedback;
Assignment assignment = this.assignmentRepository.All().FirstOrDefault(a => a.Id == inputModel.AssignmentId);
if (assignment.PossiblePoints < inputModel.Points)
{
throw new ArgumentException("Points must be less than the stated!");
}
await this.userAssignmentRepository.SaveChangesAsync();
}
public void AddUserAssignment(AssignmentDTO assignmentDTO, User user)
{
Assignment assignment = Database.Assignment.Get(assignmentDTO.Id);
if (assignment == null)
{
throw new ValidationException("Assignment not found", "");
}
if (!Database.UserAssignment.GetAll().Where(x => x.User.Id.Equals(user.Id) && x.Assignment.Id.Equals(assignment.Id)).Any())
{
UserAssignment userAssignment = new UserAssignment
{
Id = Guid.NewGuid().ToString(),
Assignment = assignment,
User = user
};
Database.UserAssignment.Create(userAssignment);
Database.Save();
}
}
//user applies for an assignment
//userAssignment-object gets created
//returns OK if succesfull - BadRequest
public async Task <ActionResult <UserAssignment> > ApplyForAssignment(int assignmentID, int userID)
{
Assignment assignment = _context.Assignments.FirstOrDefault(a => a.AssignmentID == assignmentID);
User user = _context.Users.FirstOrDefault(u => u.UserID == userID);
UserAssignment userAssignment = new UserAssignment();
userAssignment.User = user;
userAssignment.Assignment = assignment;
userAssignment.Accepted = false;
if (_context.UserAssignments.FirstOrDefault(ua => ua.Assignment.AssignmentID == assignmentID && ua.User.UserID == userID) == null)
{
_context.UserAssignments.Add(userAssignment);
await _context.SaveChangesAsync();
return(Ok());
}
return(BadRequest());
}
public static WutLinkPoco RetrieveUrlFromDatabase(string internalUrl, WutNuContext models, int?userId = null, string authEmail = null)
{
//todo: need to ensure that this search is case-sensitive - check code page on SQL DB
var item = models.WutLinks.Include("UserAssignments").SingleOrDefault(u => u.ShortUrl == internalUrl);
if (item == null)
{
return(null);
}
UserAssignment user = null;
if (item.IsProtected)
{
user = item.UserAssignments.SingleOrDefault(u => u.UserEmail == authEmail);
if (user == null)
{
//user is authenticated but not authorized for this file
return(null);
}
//feels like I should do this somewhere else but this will work for now
//(refreshing the UserAssignments table with UserID - assigner only had email)
if (userId != null)
{
//user is authenticated but not authorized for this file
user.UserId = userId;
models.SaveChanges();
}
}
var res = WutLinkPoco.GetPocoFromObject(item);
if (user != null)
{
res.UserAuthenticated = true;
}
return(res);
}
public UserAssignmentDTO GetUserAssignment(string id)
{
UserAssignment userAssignment = Database.UserAssignment.Get(id);
UserAssignmentDTO userAssignmentDTO = new UserAssignmentDTO
{
Id = userAssignment.Id,
User = userAssignment.User,
Assignment = new AssignmentDTO
{
Id = userAssignment.Assignment.Id,
Name = userAssignment.Assignment.Name,
Description = userAssignment.Assignment.Description,
StartTime = userAssignment.Assignment.StartTime,
EndTime = userAssignment.Assignment.EndTime
},
IsCompleted = userAssignment.IsCompleted,
Text = userAssignment.Text
};
return(userAssignmentDTO);
}
public async Task <int> MarkSubmittedAssignment(MarkSubmittedAssignmentInputModel inputModel)
{
UserAssignment userAssignment = this.userAssignmentRepository
.All()
.Where(ua => ua.AssignmentId == inputModel.AssignmentId && ua.UserId == inputModel.UserId)
.FirstOrDefault();
userAssignment.Points = inputModel.Points;
userAssignment.Feedback = inputModel.Feedback;
userAssignment.IsChecked = true;
Assignment assignment = this.assignmentRepository.All().FirstOrDefault(a => a.Id == userAssignment.AssignmentId);
if (inputModel.Points > assignment.PossiblePoints)
{
throw new ArgumentException("Points must be less than the stated!");
}
await this.userAssignmentRepository.SaveChangesAsync();
return(assignment.CourseId);
}
public void MarkAsComplete(AssignmentDTO assignmentDTO, User user)
{
Assignment assignment = Database.Assignment.Get(assignmentDTO.Id);
if (assignment == null)
{
throw new ValidationException("Assignment not found", "");
}
UserAssignment userAssignment = Database.UserAssignment.GetAll()
.First(x => x.User.Id.Equals(user.Id) && x.Assignment.Id.Equals(assignment.Id));
if (userAssignment == null)
{
throw new ValidationException("User Assignment not found", "");
}
else
{
userAssignment.IsCompleted = true;
Database.UserAssignment.Update(userAssignment);
Database.Save();
}
}
public async Task <int> TurnIn(FilesToAssignmentInputModel inputModel)
{
Assignment assignment = this.assignmentRepository.All().FirstOrDefault(a => a.Id == inputModel.AssignmentId);
UserAssignment userAssignment = this.userAssignmentRepository
.All()
.FirstOrDefault(ua => ua.AssignmentId == inputModel.AssignmentId && ua.UserId == inputModel.UserId);
userAssignment.TurnedOn = DateTime.UtcNow;
if (inputModel.Files != null)
{
await this.AttachFile(assignment, inputModel.Files, FileType.Submit, inputModel.UserId);
}
await this.assignmentRepository.SaveChangesAsync();
await this.userAssignmentRepository.SaveChangesAsync();
return(assignment.Id);
}
public async Task<IActionResult> MassUpload(int id, string roleToReg, [FromForm]XlsForUploadDto xlsForUploadDto){
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
return Unauthorized();
Stream stream = xlsForUploadDto.File.OpenReadStream();
UserParams userParams = new UserParams();
userParams.RoleName = roleToReg;
List<string> cohorts = new List<string>();
List<string> lastNames = new List<string>();
List<string> firstNames = new List<string>();
List<string> emails = new List<string>();
List<string> streetAdress = new List<string>();
List<string> city = new List<string>();
List<User> userList = new List<User>();
List<string> userNames = new List<string>();
var usersFromDb = _context.Users.ToList();
int it = 1;
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
cohorts.Add(values[0]);
lastNames.Add(values[1]);
firstNames.Add(values[2]);
emails.Add(values[9]);
streetAdress.Add(values[11]);
city.Add(values[12]);
}
Console.WriteLine("Stop");
}
while(it <= lastNames.Count)
{
// if (firstNames[it] == "Eamon")
// {
// Console.WriteLine("Test");
// }
if (lastNames[it] != "")
{
string userName = UserNameGenerator.ReturnUserName(firstNames[it], lastNames[it], usersFromDb, userNames).Trim();
userNames.Add(userName);
string sL = StudLevCalc.ReturnStudLev(cohorts, it);
string pw = UserNameGenerator.ReturnPassword(streetAdress[it], city[it]).Trim();
UserForRegisterDto userFromFile = new UserForRegisterDto
{
FirstName = firstNames[it].Trim(),
LastName = lastNames[it].Trim(),
Email = emails[it].Trim(),
StudentLevel = sL,
Username = userName,
Password = pw,
};
var userToCreate = _mapper.Map<User>(userFromFile);
var assignments = await _context.Assignments.Where(a => a.StudentLevel == userToCreate.StudentLevel).ToListAsync();
var result = await _userManager.CreateAsync(userToCreate, userFromFile.Password);
var userToReturn = _mapper.Map<UserForDetailedDto>(userToCreate);
if (result.Succeeded)
{
foreach(var assignment in assignments)
{
var userAssignment = new UserAssignment
{
UserId = userToReturn.Id,
AssignmentId = assignment.Id,
Completed = false
};
_context.Add(userAssignment);
}
switch (roleToReg)
{
case "student":
_userManager.AddToRolesAsync(userToCreate, new [] {"Student"}).Wait();
break;
case "tutor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Tutor"}).Wait();
break;
case "mentor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Mentor"}).Wait();
break;
case "admin":
_userManager.AddToRolesAsync(userToCreate, new [] {"Admin"}).Wait();
break;
}
}
}
it++;
}
return Ok();
throw new Exception("");
}
//Add new UserAssignment. InOtherWords Assign User to an Assigment.
public async Task AddUserAssignment(UserAssignment userAssignment)
{
_context.UserAssignments.Add(userAssignment);
await _context.SaveChangesAsync();
}
