private async Task CompleteWorkItemAnyAssigned(WorkItem item, IEnumerable <WorkItemAssignment> assignments, int userId, string workNotes)
{
var assignment = assignments.SingleOrDefault(x => x.UserId == userId);
if (assignment == null)
{
assignment = new WorkItemAssignment()
{
UserId = userId,
WorkItemId = item.Id
};
}
if (!assignment.CompletedAt.HasValue)
{
var now = _clock.UtcNow.UtcDateTime;
assignment.CompletedAt = now;
assignment.WorkNotes = workNotes;
if (assignment.Id == default(int))
{
await _workItemRepository.InsertWorkItemAssignment(assignment);
}
else
{
await _workItemRepository.UpdateWorkItemAssignment(assignment);
}
item.CompletedAt = now;
item.CompletedByUserId = userId;
await _workItemRepository.UpdateWorkItem(item);
}
}
public ActionResult UpdateWorkitem(FormCollection data, HttpPostedFileBase myFile)
{
try
{
if (!ModelState.IsValid)
{
return(Json("Error"));
}
else
{
WorkItemAssignment assignData = new WorkItemAssignment();
int Workid = Convert.ToInt32(data["Workid"].ToString());
var fileName = Path.GetFileName(myFile.FileName);
var path = Path.Combine(Server.MapPath("~/work/Download/"), fileName);
myFile.SaveAs(path);
assignData.WorkItemID = Workid;
assignData.UserID = Convert.ToInt32(Session["UserID"]);
assignData.IsRewarded = false;
assignData.SubmissionDateTime = DateTime.Now;
assignData.SubmissionPath = path;
var putAssignData = workbountyRepo.UpdateWorkitems(assignData);
return(View());
}
}
catch (Exception)
{
return(View());
}
}
public ActionResult UpdateWorkitem(FormCollection data, HttpPostedFileBase myFile)
{
try
{
if (!ModelState.IsValid)
{
return(Json("Error"));
}
else
{
int currentUserID = Convert.ToInt32(Session["UserID"]);
int currentWorkitemID = Convert.ToInt32(Session["UploadWorkitemID"]);
var getDataofUploadDocument = workbountyRepo.UserUploadDocument(currentWorkitemID, currentUserID);
ViewBag.dateOfSubmittedWork = getDataofUploadDocument;
WorkItemAssignment assignData = new WorkItemAssignment();
int Workid = Convert.ToInt32(data["Workid"].ToString());
var fileName = Path.GetFileName(myFile.FileName);
var path = Path.Combine(Server.MapPath("~/work1/Download/"), fileName);
myFile.SaveAs(path);
assignData.WorkItemID = Workid;
assignData.UserID = Convert.ToInt32(Session["UserID"]);
assignData.IsRewarded = false;
assignData.SubmissionDateTime = DateTime.Now;
assignData.SubmissionPath = path;
var putAssignData = workbountyRepo.UpdateWorkitems(assignData);
return(RedirectToAction("dashboard", "home"));
}
}
catch (Exception)
{
ViewBag.blankDataMessage = "Blank data";
return(View());
}
}
public string ApplyReward(Rewards id)
{
try
{
using (WorkBountyDBEntities entities = new WorkBountyDBEntities())
{
entities.Configuration.ValidateOnSaveEnabled = false;
string remarks = id.Remarks.ToString();
Workitem remark = new Workitem()
{
WorkitemID = id.WorkItemID, Remarks = id.Remarks
};
entities.Workitems.Attach(remark);
entities.Entry(remark).Property(u => u.Remarks).IsModified = true;
entities.SaveChanges();
}
List <WorkItemAssignment> checkUploadedWorkitem = entity.WorkItemAssignments.Where(s => s.WorkItemID == id.WorkItemID && s.UserID == id.UserID).ToList();
foreach (var data in checkUploadedWorkitem)
{
WorkItemAssignment item = entity.WorkItemAssignments.Where(s => s.WorkItemID == id.WorkItemID && s.UserID == id.UserID).FirstOrDefault();
item.IsRewarded = true;
entity.SaveChanges();
}
return("Success");
}
catch (Exception)
{
return("Error");
}
}
public async Task CanUpdateWorkItemAssignment()
{
var workItem = new WorkItem()
{
PatrolId = 1,
CreatedAt = DateTime.Now,
ScheduledAt = DateTime.Now,
CreatedByUserId = 1,
Name = "Name",
Location = "Location",
CompletionMode = CompletionMode.Any,
DescriptionMarkup = "Markup",
AdminGroupId = 1
};
await _workItemRepository.InsertWorkItem(workItem);
var assignment = new WorkItemAssignment()
{
UserId = 1,
WorkItemId = workItem.Id,
};
await _workItemRepository.InsertWorkItemAssignment(assignment);
assignment.UserId = 2;
await _workItemRepository.UpdateWorkItemAssignment(assignment);
var inserted = await _workItemRepository.GetWorkItemAssignment(assignment.Id);
Assert.AreEqual(assignment.UserId, inserted.UserId);
Assert.AreEqual(assignment.WorkItemId, inserted.WorkItemId);
}
public string UpdateWorkitems(WorkItemAssignment data)
{
try
{
entity.WorkItemAssignments.Add(data);
entity.SaveChanges();
return("Success");
}
catch (Exception)
{
return("Error");
}
}
public string ApplyReward(Rewards id)
{
try
{
WorkItemAssignment item = entity.WorkItemAssignments.Where(s => s.WorkItemID == id.WorkItemID && s.UserID == id.UserID).First();
item.IsRewarded = true;
entity.SaveChanges();
return("Success");
}
catch (Exception)
{
return("Error");
}
}
/// <summary>
/// used when the work item is completion mode "admin only", and also used to do "admin completion" for any WI
/// </summary>
/// <param name="item"></param>
/// <param name="assignments"></param>
/// <param name="userId"></param>
/// <param name="workNotes"></param>
/// <param name="onBehalfOfUserId"></param>
/// <returns></returns>
private async Task CompleteWorkItemAdminOnly(WorkItem item, IEnumerable <WorkItemAssignment> assignments, int userId, string workNotes, int?onBehalfOfUserId = null)
{
if (!onBehalfOfUserId.HasValue)
{
onBehalfOfUserId = userId;
}
var assignment = assignments.SingleOrDefault(x => x.UserId == onBehalfOfUserId.Value);
if (assignment == null)
{
assignment = new WorkItemAssignment()
{
UserId = onBehalfOfUserId.Value,
WorkItemId = item.Id
};
}
var now = _clock.UtcNow.UtcDateTime;
assignment.CompletedAt = now;
assignment.WorkNotes = workNotes;
if (assignment.Id == default(int))
{
await _workItemRepository.InsertWorkItemAssignment(assignment);
}
else
{
await _workItemRepository.UpdateWorkItemAssignment(assignment);
}
if (onBehalfOfUserId.HasValue && onBehalfOfUserId != userId)
{
var assignment2 = assignments.SingleOrDefault(x => x.UserId == userId);
if (assignment2 == null)
{
assignment2 = new WorkItemAssignment()
{
UserId = userId,
WorkItemId = item.Id
};
}
assignment2.CompletedAt = now;
assignment2.WorkNotes = workNotes;
if (assignment2.Id == default(int))
{
await _workItemRepository.InsertWorkItemAssignment(assignment2);
}
else
{
await _workItemRepository.UpdateWorkItemAssignment(assignment2);
}
}
item.CompletedAt = now;
item.CompletedByUserId = onBehalfOfUserId.Value;
await _workItemRepository.UpdateWorkItem(item);
}
public async Task PopulateTimedWorkItemOccurences(RecurringWorkItem workItem, int userId, List <int> assigneeUserIds, DateTime now, bool populateWorkItemAssignments = true)
{
var existingWorkItems = (await _workItemRepository.GetWorkItems(workItem.Id, now)).ToList();
var calculatedWorkItems = new List <WorkItem>();
for (var scheduledAt = workItem.RecurStart.Value; scheduledAt <= workItem.RecurEnd.Value; scheduledAt = AddInterval(scheduledAt, workItem.RecurInterval.Value, workItem.RecurIntervalCount.Value))
{
if (scheduledAt >= now)
{
calculatedWorkItems.Add(new WorkItem()
{
AdminGroupId = workItem.AdminGroupId,
CompletionMode = workItem.CompletionMode,
CreatedAt = now,
CreatedByUserId = userId,
DescriptionMarkup = workItem.DescriptionMarkup,
Location = workItem.Location,
Name = workItem.Name,
PatrolId = workItem.PatrolId,
RecurringWorkItemId = workItem.Id,
ScheduledAt = scheduledAt,
});
}
}
var allAssignments = await _workItemRepository.GetWorkItemAssignments(workItem.Id, now);
var missing = calculatedWorkItems.Where(x => !existingWorkItems.Any(y => y.ScheduledAt == x.ScheduledAt)).ToList();
var toRemove = existingWorkItems.Where(x => x.ScheduledAt > now && !calculatedWorkItems.Any(y => y.ScheduledAt == x.ScheduledAt));
var toUpdate = existingWorkItems.Where(x => x.ScheduledAt > now && calculatedWorkItems.Any(y => y.ScheduledAt == x.ScheduledAt));
foreach (var wi in missing)
{
await _workItemRepository.InsertWorkItem(wi);
if (populateWorkItemAssignments && assigneeUserIds != null)
{
foreach (var uid in assigneeUserIds)
{
var assignment = new WorkItemAssignment()
{
WorkItemId = wi.Id,
UserId = uid
};
await _workItemRepository.InsertWorkItemAssignment(assignment);
}
}
}
foreach (var wi in toRemove)
{
var toRemoveAssignments = allAssignments.Where(x => x.WorkItemId == wi.Id).ToList();
foreach (var wis in toRemoveAssignments)
{
await _workItemRepository.DeleteWorkItemAssignment(wis);
}
await _workItemRepository.DeleteWorkItem(wi);
}
foreach (var wi in toUpdate)
{
wi.AdminGroupId = workItem.AdminGroupId;
wi.CompletionMode = workItem.CompletionMode;
wi.DescriptionMarkup = workItem.DescriptionMarkup;
wi.Location = workItem.Location;
wi.Name = workItem.Name;
await _workItemRepository.UpdateWorkItem(wi);
if (populateWorkItemAssignments)
{
var assignees = allAssignments.Where(x => x.WorkItemId == wi.Id).ToList();
if (assigneeUserIds != null)
{
await assignees.DifferenceWith(assigneeUserIds,
(a, id) => a.UserId == id,
id => _workItemRepository.InsertWorkItemAssignment(new WorkItemAssignment()
{
WorkItemId = wi.Id,
UserId = id
}), wia => _workItemRepository.DeleteWorkItemAssignment(wia));
}
}
}
}
private async Task RecalculateSingleShiftWorkItemAssignments(int scheduledShiftId, List <ScheduledShiftAssignmentDto> scheduledShiftAssignments, List <WorkItem> workItems, List <WorkItemAssignment> assignments, List <RecurringWorkItem> recurringWorkItems, List <ShiftRecurringWorkItem> shiftRecurringWorkItems)
{
var random = new Random();
//find work items for shift
var scheduledShiftWorkItems = workItems.Where(x => x.ScheduledShiftId == scheduledShiftId).ToList();
//find auto assigned work items
var autoShiftWorkItems = scheduledShiftWorkItems//.Where(wi => shiftRecurringWorkItems.Single(r => r.RecurringWorkItemId == wi.RecurringWorkItemId.Value).ShiftAssignmentMode == ShiftAssignmentMode.Random)
.Select(x => new
{
WorkItem = x,
RecurringWorkItem = recurringWorkItems.Single(y => y.Id == x.RecurringWorkItemId.Value),
Assignments = assignments.Where(z => z.WorkItemId == x.Id).ToList(),
ShiftRecurringWorkItem = shiftRecurringWorkItems.First(y => y.RecurringWorkItemId == x.RecurringWorkItemId)
})
.ToList();
//dictionary of user ids with assignments
var shiftAssignments = scheduledShiftAssignments.Where(x => x.ScheduledShiftId == scheduledShiftId && x.AssignedUser != null)
.Select(x => x.AssignedUser.Id).Distinct().Select(x => new { Id = x, Assignments = assignments.Where(y => y.UserId == x).ToList() })
.ToDictionary(x => x.Id, x => x.Assignments.ToList());
//assignments.Where(x => scheduledShiftWorkItems.Any(y => y.Id == x.WorkItemId)).GroupBy(x => new { x.UserId })
//.ToDictionary(x=>x.Key.UserId,x=>x.ToList());
var desiredUsersPerWorkItem = 0;
if (scheduledShiftWorkItems.Count() > scheduledShiftAssignments.Count() && scheduledShiftAssignments.Any())
{
desiredUsersPerWorkItem = scheduledShiftWorkItems.Count() / scheduledShiftAssignments.Count();
}
else if (scheduledShiftWorkItems.Any())
{
desiredUsersPerWorkItem = scheduledShiftAssignments.Count() / scheduledShiftWorkItems.Count();
}
//round up / ensure nonzero
desiredUsersPerWorkItem++;
//loop through work items for the shift and assign users
foreach (var wi in autoShiftWorkItems)
{
if (wi.ShiftRecurringWorkItem.ShiftAssignmentMode == ShiftAssignmentMode.Auto)
{
for (var i = wi.Assignments.Count; i < desiredUsersPerWorkItem && (!wi.RecurringWorkItem.MaximumRandomCount.HasValue || wi.Assignments.Count < wi.RecurringWorkItem.MaximumRandomCount.Value); i++)
{
//find users not already used on this work item
var unusedUsers = shiftAssignments.Where(x => !wi.Assignments.Any(y => y.UserId == x.Key && x.Value.Any(z => z.WorkItemId == wi.WorkItem.Id)));
//find users with the least assignments
if (unusedUsers.Any())
{
var minAssigned = unusedUsers.Min(x => x.Value.Count);
//make a pool of the users with equal, least assignments
var userIdPool = unusedUsers.Where(x => x.Value.Count == minAssigned)
.Select(x => x.Key).ToList();
if (userIdPool.Any())
{
var index = random.Next(userIdPool.Count());
var assignment = new WorkItemAssignment()
{
UserId = userIdPool[index],
WorkItemId = wi.WorkItem.Id
};
await _workItemRepository.InsertWorkItemAssignment(assignment);
shiftAssignments[userIdPool[index]].Add(assignment);
wi.Assignments.Add(assignment);
}
else
{
break;
}
}
else
{
break;
}
}
}
else if (wi.ShiftRecurringWorkItem.ShiftAssignmentMode == ShiftAssignmentMode.CopyPrevious)
{
var previous = workItems.Where(x => x.RecurringWorkItemId == wi.WorkItem.RecurringWorkItemId && x.ScheduledAt < wi.WorkItem.ScheduledAt)
.OrderByDescending(x => x.ScheduledAt).FirstOrDefault();
if (previous != null)
{
//find users assigned to most recent work item
var previousAssignments = assignments.Where(x => x.WorkItemId == previous.Id).ToList();
//find users in specified shift
var ssas = scheduledShiftAssignments.Where(x => x.ScheduledShiftId == scheduledShiftId).ToList();
//find users in previous work item assignment that exist in current shift
var assignUserIds = previousAssignments.Where(x => ssas.Any(y => y.AssignedUser != null && y.AssignedUser.Id == x.UserId)).Select(x => x.UserId).ToList();
//find users that already are assigned to the wi
var existingAssignments = assignments.Where(x => x.WorkItemId == wi.WorkItem.Id).Select(x => x.UserId).ToList();
//find users that need to be assigned that aren't already assigned
var missingUserIds = assignUserIds.Where(x => !existingAssignments.Any(y => y == x)).ToList();
foreach (var id in missingUserIds)
{
var assignment = new WorkItemAssignment()
{
WorkItemId = wi.WorkItem.Id,
UserId = id
};
await _workItemRepository.InsertWorkItemAssignment(assignment);
wi.Assignments.Add(assignment);
shiftAssignments[id].Add(assignment);
}
}
}
}
}
public Task UpdateWorkItemAssignment(WorkItemAssignment item)
{
return(_connection.UpdateAsync(item));
}
public async Task InsertWorkItemAssignment(WorkItemAssignment item)
{
int id = (int)await _connection.InsertAsync(item);
item.Id = id;
}
public string UpdateWorkitems(WorkItemAssignment data)
{
try
{
entity.WorkItemAssignments.Add(data);
entity.SaveChanges();
return "Success";
}
catch (Exception)
{
return "Error";
}
}
