// GET: TaskItem/Delete/5
public async Task <ActionResult> Delete(string taskItemId)
{
string accessToken = Session["MicrosoftAccessToken"] as string;
var taskItemService = new TaskItemService(accessToken);
var taskItem = await taskItemService.GetTaskItemById(taskItemId);
var taskItemModel = GetTaskItemModel(taskItem);
var statuses = await taskItemService.GetAvailableTaskStatuses();
taskItemModel.Status = statuses.Single(s => s.Id == taskItem.TaskStatusId).Status;
var groupService = new GroupService(accessToken);
taskItemModel.GroupName = await groupService.GroupNameByGroupId(taskItem.GroupId);
if (await AccessAdmin(taskItem.GroupId))
{
return(View(taskItemModel));
}
else
{
return(View("AccessDenied"));
}
}
public void Should_Return_TaskResponse_If_call_TaskByItem_and_No_TaskName_First_Document()
{
var moqDocumentRepositor = new Mock <ITaskRepository>();
var taskId = new Guid("75A55861-4442-4FD1-A150-725CE51186E4");
var Listdata = new List <TasksDB>();
var taskComplition = new TaskCompletionSource <List <TasksDB> >();
taskComplition.SetResult(new List <TasksDB>()
{
new TasksDB()
{
TaskId = new Guid("75A55861-4442-4FD1-A150-725CE51186E4"),
TaskName = "Task 1"
}
});
moqDocumentRepositor.Setup(x => x.GetTaskById(taskId)).Returns(taskComplition.Task);
var moqLogger = new Mock <ILogger>();
string name = null;
var expected = new Guid("75A55861-4442-4FD1-A150-725CE51186E4");
var TaskItemService = new TaskItemService();
// Act
var actual = (ObjectResult)TaskItemService.GetTaskItem(taskId, name, moqDocumentRepositor.Object, moqLogger.Object).Result;
var response = (TaskResponse)actual.Value;
// Assert
Assert.AreEqual(expected, response.TaskId);
}
public void DefaultDataTest()
{
var sut = new TaskItemService();
sut.GetAll()
.Should()
.HaveCount(5);
}
public void TaskItemService_delet_throws_exception()
{
var sut = new TaskItemService();
Action act = () => {
sut.Delete(99);
};
act.Should().Throw <IndexOutOfRangeException>();
}
public void TaskItemService_can_add_task(int id, int expected)
{
var sut = new TaskItemService();
sut.AddOrUpdate(new TaskItem {
Id = id, Title = "This is a test"
})
.Id
.Should()
.Be(expected);
}
public void TaskItemService_new_task_have_new_state()
{
var sut = new TaskItemService();
sut.AddOrUpdate(new TaskItem {
Title = "This is a test"
})
.State
.Should()
.Be(TaskState.New);
}
public void TaskItemService_can_update_item()
{
var sut = new TaskItemService();
var item2 = sut.GetById(2);
item2.Title = "Title is changed by test";
sut.AddOrUpdate(item2);
sut.GetById(2).Title.Should().Be("Title is changed by test");
}
// GET: TaskItem
public async Task <ActionResult> Index(string sortOrder, string searchString)
{
string accessToken = Session["MicrosoftAccessToken"] as string;
UserService userService = new UserService(accessToken);
var userId = await userService.GetUserId(Session["UserId"] as string, UserDomainEnum.Microsoft);
if (String.IsNullOrWhiteSpace(userId))
{
return(RedirectToAction("Login", "Account"));
}
TaskItemService taskItemService = new TaskItemService(accessToken);
var taskItems = await taskItemService.GetTaskItems(userId);
var groupIds = taskItems.Select(t => t.GroupId).Distinct();
Dictionary <string, string> groups = new Dictionary <string, string>();
foreach (var groupId in groupIds)
{
GroupService groupService = new GroupService(accessToken);
string groupName = await groupService.GroupNameByGroupId(groupId);
groups.Add(groupId, groupName);
}
var taskStatuses = await taskItemService.GetAvailableTaskStatuses();
var tasks = new List <TaskItemModel>();
foreach (var taskItem in taskItems)
{
TaskItemModel taskItemModel = GetTaskItemModel(taskItem);
taskItemModel.GroupName = groups[taskItemModel.GroupId];
taskItemModel.Status = taskStatuses.Single(s => s.Id == taskItemModel.StatusId).Status;
tasks.Add(taskItemModel);
}
if (!String.IsNullOrWhiteSpace(searchString))
{
tasks = tasks.Where(t => t.Name.Contains(searchString) || t.GroupName.Contains(searchString)).ToList();
}
ViewBag.TaskNameParam = String.IsNullOrEmpty(sortOrder) ? "taskName_desc" : "";
ViewBag.GroupNameParam = sortOrder == "groupName" ? "groupName_desc" : "groupName";
ViewBag.IsCompletedParam = sortOrder == "isCompleted" ? "isCompleted_desc" : "isCompleted";
ViewBag.StatusParam = sortOrder == "status" ? "status_desc" : "status";
ViewBag.StartDateParam = sortOrder == "startDate" ? "startDate_desc" : "startDate";
ViewBag.EndDateParam = sortOrder == "endDate" ? "endDate_desc" : "endDate";
tasks = OrderTasks(sortOrder, tasks);
return(View(tasks));
}
public async Task <bool> AccessEditor(string taskItemId)
{
var accessToken = Session["MicrosoftAccessToken"] as string;
TaskItemService taskItemService = new TaskItemService(accessToken);
string groupId = (await taskItemService.GetTaskItemById(taskItemId)).GroupId;
UserService userService = new UserService(accessToken);
string userId = await userService.GetUserInternalId(Session["UserId"] as string, UserDomainEnum.Microsoft);
RoleTypeService roleTypeService = new RoleTypeService(accessToken);
return(await roleTypeService.CanUserEditItem(userId, groupId));
}
public void TaskItemService_can_delet_item()
{
var sut = new TaskItemService();
var newItem = sut.AddOrUpdate(new TaskItem {
Title = "This is a test"
});
sut.Delete(newItem.Id);
sut.GetAll()
.Should()
.HaveCount(5);
}
// GET: TaskItem/Create
public async Task <ActionResult> Create()
{
string accessToken = Session["MicrosoftAccessToken"] as string;
var groupService = new GroupService(accessToken);
var groups = await groupService.GetGroupsAvailableForUserWhereUserIsAdmin(Session["UserId"] as string);
var defaultGroup = groups.SingleOrDefault(g => g.GroupName.Contains("Default group for user:"******"Id", "GroupNameTruncated", defaultGroup.Id);
ViewBag.StatusID = new SelectList(statuses, "Id", "Status", defaultStatus.Id);
return(View());
}
public async Task <ActionResult> Delete(string taskItemId, TaskItemModel taskItemModel)
{
try
{
var taskItemService = new TaskItemService(Session["MicrosoftAccessToken"] as string);
var taskItem = await taskItemService.GetTaskItemById(taskItemModel.TaskItemId);
taskItem.IsDeleted = true;
await taskItemService.UpdateTaskItem(taskItem);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Create(TaskItemModel taskItemModel)
{
try
{
string accessToken = Session["MicrosoftAccessToken"] as string;
var taskItem = GetTaskItemFromModel(taskItemModel);
var taskItemService = new TaskItemService(accessToken);
var userService = new UserService(accessToken);
var usrId = await userService.GetUserId(Session["UserId"] as string, UserDomainEnum.Microsoft);
taskItem.Id = Guid.NewGuid().ToString();
await taskItemService.InsertTaskItem(taskItem, usrId);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Edit(string taskItemId, string taskSubitemId, TaskSubitemModel taskSubitemModel)
{
ViewBag.TaskItemId = taskItemId;
var accessToken = Session["MicrosoftAccessToken"] as string;
TaskSubitemService taskSubitemService = new TaskSubitemService(accessToken);
try
{
// TODO: Add update logic here
TaskSubitem taskSubitem = GetTaskSubitemFromModel(taskItemId, taskSubitemModel);
taskSubitem.Id = taskSubitemId;
if (taskSubitem.IsCompleted ||
taskSubitem.TaskStatusId.Equals(((int)TaskStatusEnum.Completed).ToString()))
{
taskSubitem.TaskStatusId = ((int)TaskStatusEnum.Completed).ToString();
taskSubitem.IsCompleted = true;
}
await taskSubitemService.UpdateTaskSubitem(taskSubitem);
var allTaskSubitems = await taskSubitemService.GetTaskSubitems(taskItemId);
if (allTaskSubitems.All(t => t.IsCompleted))
{
var taskItemService = new TaskItemService(accessToken);
var taskItem = await taskItemService.GetTaskItemById(taskItemId);
taskItem.IsCompleted = true;
taskItem.TaskStatusId = ((int)TaskStatusEnum.Completed).ToString();
await taskItemService.UpdateTaskItem(taskItem);
}
return(RedirectToAction("Index", new { taskItemId }));
}
catch
{
return(View(taskSubitemModel));
}
}
public async Task <ActionResult> Edit(string taskItemId, TaskItemModel taskItemModel)
{
try
{
var taskItem = GetTaskItemFromModel(taskItemModel);
var taskItemService = new TaskItemService(Session["MicrosoftAccessToken"] as string);
if (taskItem.IsCompleted ||
taskItem.TaskStatusId.Equals(((int)TaskStatusEnum.Completed).ToString()))
{
taskItem.TaskStatusId = ((int)TaskStatusEnum.Completed).ToString();
taskItem.IsCompleted = true;
}
await taskItemService.UpdateTaskItem(taskItem);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
// GET: TaskItem/Edit/5
public async Task <ActionResult> Edit(string taskItemId)
{
string accessToken = Session["MicrosoftAccessToken"] as string;
//UserService userService = new UserService(accessToken);
//var userId = await userService.GetUserId(Session["UserId"] as string, UserDomainEnum.Microsoft);
var taskItemService = new TaskItemService(accessToken);
var taskItem = await taskItemService.GetTaskItemById(taskItemId);
var groupService = new GroupService(accessToken);
var groups = await groupService.GetGroupsAvailableForUserWhereUserIsAdmin(Session["UserId"] as string);
//var groupName = await groupService.GroupNameByGroupId(taskItem.GroupId);
var statuses = await taskItemService.GetAvailableTaskStatuses();
var status = statuses.Single(s => s.Id == taskItem.TaskStatusId);
ViewBag.GroupId = new SelectList(groups, "Id", "GroupNameTruncated", taskItem.GroupId);
ViewBag.StatusId = new SelectList(statuses, "Id", "Status", status.Id);
var taskItemModel = GetTaskItemModel(taskItem);
//
if (await AccessAdmin(taskItem.GroupId))
{
return(View(taskItemModel));
}
else if (await AccessEditor(taskItem.GroupId))
{
return(View(taskItemModel));
}
else
{
return(View("AccessDenied"));
}
}
public TaskItemController(TaskItemService taskItemService)
{
TaskItemService = taskItemService;
}
// GET: TaskSubitem/Edit/5
public async Task <ActionResult> Edit(string taskItemId, string taskSubitemId)
{
ViewBag.TaskItemId = taskItemId;
string accessToken = Session["MicrosoftAccessToken"] as string;
TaskSubitemService taskSubitemService = new TaskSubitemService(accessToken);
TaskSubitem taskSubitemInfo = await taskSubitemService.GetTaskSubitemById(taskSubitemId);
TaskSubitemModel taskSubitemModel = GetTaskSubitemModel(taskSubitemInfo);
var statuses = await taskSubitemService.GetAvailableTaskStatuses();
var status = statuses.Single(s => s.Id == taskSubitemInfo.TaskStatusId);
ViewBag.StatusID = new SelectList(statuses, "Id", "Status", status.Id);
var tasks = new ObservableCollection <TaskSubitem>()
{
new TaskSubitem()
};
var items = await taskSubitemService.GetTaskSubitems(taskItemId);
items.ForEach(i => tasks.Add(i));
if (String.IsNullOrWhiteSpace(taskSubitemInfo.PredecessorId))
{
ViewBag.PredecessorID = new SelectList(tasks, "Id", "Name", new TaskSubitem());
}
else
{
ViewBag.PredecessorID = new SelectList(tasks, "Id", "Name", taskSubitemInfo.PredecessorId);
}
if (String.IsNullOrWhiteSpace(taskSubitemInfo.SuccessorId))
{
ViewBag.SuccessorID = new SelectList(tasks, "Id", "Name", new TaskSubitem());
}
else
{
ViewBag.SuccessorID = new SelectList(tasks, "Id", "Name", taskSubitemInfo.SuccessorId);
}
UserService userService = new UserService(accessToken);
TaskItemService taskItemService = new TaskItemService(accessToken);
UserGroupService userGroup = new UserGroupService(accessToken);
var itemInfo = await taskItemService.GetTaskItemById(taskItemId);
var groupInfo = await userGroup.GetUserGroupTableForGroup(itemInfo.GroupId);
var userInGroup = groupInfo.Select(u => u.UserId);
List <User> userProp = new List <User>();
userProp.Add(new User());
foreach (var usrId in userInGroup)
{
var user = await userService.GetUserById(usrId);
userProp.Add(user);
}
var userInternalId = await userService.GetUserInternalId(Session["UserId"] as string, UserDomainEnum.Microsoft);
//var defaultExecutor = userProp.Single(i => i.Id == userInternalId);
if (String.IsNullOrWhiteSpace(taskSubitemInfo.ExecutorId))
{
ViewBag.ExecutorID = new SelectList(userProp, "Id", "FullName", new TaskSubitem());
}
else
{
ViewBag.ExecutorID = new SelectList(userProp, "Id", "FullName", taskSubitemInfo.ExecutorId);
}
if (await AccessAdmin(taskItemId))
{
return(View(taskSubitemModel));
}
else if (await AccessEditor(taskItemId))
{
return(View(taskSubitemModel));
}
else
{
return(View("AccessDenied"));
}
}
