//public static void AddTaskToList(TaskContainer task)
//{
// TaskContainer.Items.Add(task);
//}
//public static void SaveToDataBase(List<TaskContainer> list )
//{
// Serv.SaveToDataBase(list);
//}
public static void AddTag(TaskContainer task, TaskTag tag)
{
Task_To_Tag tasktag = new Task_To_Tag(task, tag);
Task_To_Tag.Items.Add(tasktag.Id, tasktag);
TaskTag.Items.Add(tag.Id, tag);
Console.WriteLine(tasktag);
}
public IActionResult AddStudentTag(AddTaskTagViewModel viewModel)
{
if (ModelState.IsValid)
{
int studentTaskId = viewModel.StudentTaskId;
int studentTagId = viewModel.StudentTagId;
List <TaskTag> existingItems = context.TaskTags
.Where(et => et.StudentTaskId == studentTaskId)
.Where(et => et.StudentTagId == studentTagId)
.ToList();
if (existingItems.Count == 0)
{
TaskTag taskTag = new TaskTag
{
StudentTaskId = studentTaskId,
StudentTagId = studentTagId
};
context.TaskTags.Add(taskTag);
context.SaveChanges();
}
return(Redirect("/StudentTask/Detail/" + studentTaskId));
}
return(View(viewModel));
}
public void Delete(int tagId)
{
try
{
if (tagId <= 0)
{
throw new ArgumentNullException();
}
Tag tag = context.Tags.GetAll().FirstOrDefault(f => f.Id == tagId);
TaskTag taskTag = context.TaskTags.GetAll().FirstOrDefault(t => t.TagId == tagId);
if (tag == null || taskTag == null)
{
throw new ArgumentNullException();
}
if (!checkUserService.AccessGrantedForUser(taskTag.MyTaskId))
{
throw new UnauthorizedAccessException();
}
context.Tags.Delete(tag);
context.TaskTags.Delete(taskTag);
context.SaveChanges();
}
catch (Exception)
{
throw;
}
}
public void Edit(int tagId, string tagName)
{
try
{
if (tagId <= 0 || tagName == null || tagName == "")
{
throw new ArgumentNullException();
}
Tag tagForTask = context.Tags.GetAll().FirstOrDefault(t => t.Id == tagId);
TaskTag taskTag = context.TaskTags.GetAll().FirstOrDefault(t => t.TagId == tagId);
if (tagForTask == null || taskTag == null)
{
throw new ArgumentNullException();
}
if (!checkUserService.AccessGrantedForUser(taskTag.MyTaskId))
{
throw new UnauthorizedAccessException();
}
tagForTask.Name = tagName;
context.Tags.Update(tagForTask);
context.SaveChanges();
}
catch (Exception)
{
throw;
}
}
public TaskTag AddTaskTag(string projectUId, TaskTag newtag)
{
authorizationService.VerifyPermissionAtProject(projectUId, new PermissionSets[] { PermissionSets.TEAM, PermissionSets.SCRUM_MASTER });
newtag.CreatedAt = DateTime.Now;
tasksRepository.SaveTaskTag(newtag);
return(newtag);
}
public TaskTag AddTaskTag(string projectUId, TaskTag newtag)
{
authorizationService.VerifyPermissionAtProject(projectUId, new PermissionSets[] { PermissionSets.TEAM, PermissionSets.SCRUM_MASTER });
newtag.CreatedAt = DateTime.Now;
tasksRepository.SaveTaskTag(newtag);
return newtag;
}
public ActionResult <TaskListReadDto> PostTaskList(TaskListCreateDto taskListCreateDto)
{
_logger.LogInformation("Mapeando a lista de tarefas a ser cadastrada para a model");
TaskList taskList = _mapper.Map <TaskList>(taskListCreateDto);
_logger.LogInformation("Cadastrando a lista de tarefas no banco de dados");
_taskListsRepo.PostTaskList(taskList);
_taskListsRepo.SaveChanges();
if (taskListCreateDto.Tasks != null && taskListCreateDto.Tasks.Count > 0)
{
Tag tag;
TaskTag taskTag;
for (int i = 0; i < taskListCreateDto.Tasks.Count; i++)
{
if (taskListCreateDto.Tasks[i].Tags != null && taskListCreateDto.Tasks[i].Tags.Count > 0)
{
taskTag = new TaskTag()
{
TaskId = taskList.Tasks[i].Id
};
_logger.LogInformation("Cadastrando as tags da tarefa de Id: {id} no banco de dados", taskList.Tasks[i].Id);
foreach (TagCreateDto tagCreateDto in taskListCreateDto.Tasks[i].Tags)
{
tag = _mapper.Map <Tag>(tagCreateDto);
_tagsRepo.PostTag(tag);
_tagsRepo.SaveChanges();
taskTag.TagId = tag.Id;
_taskTagsRepo.PostTaskTag(taskTag);
_taskTagsRepo.SaveChanges();
}
}
}
}
_logger.LogInformation("Montando objeto de retorno");
TaskList taskListCreated = _taskListsRepo.GetTaskListById(taskList.Id);
TaskListReadDto taskListReadDto = _mapper.Map <TaskListReadDto>(taskListCreated);
if (taskListCreated.Tasks != null && taskListCreated.Tasks.Count > 0)
{
List <Tag> tags;
for (int i = 0; i < taskListCreated.Tasks.Count; i++)
{
if (taskListCreated.Tasks[i].TaskTags != null && taskListCreated.Tasks[i].TaskTags.Count > 0)
{
tags = taskListCreated.Tasks[i].TaskTags.Select(tt => tt.Tag).ToList();
taskListReadDto.Tasks[i].Tags = _mapper.Map <List <TagReadDto> >(tags);
}
}
}
return(CreatedAtAction("GetTaskListById", new { id = taskListReadDto.Id }, taskListReadDto));
}
public async Task <ActionResult <TaskDtoToReturn> > AddTask(TaskDtoForCreate taskDto)
{
var userId = HttpContext.User?.Claims?.FirstOrDefault(c => c.Type == "userid")?.Value;
if (string.IsNullOrEmpty(userId))
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Invalid token"
}));
}
var task = mapper.Map <TaskC>(taskDto);
await context.Tasks.AddAsync(task);
task.UserId = userId;
task.TaskTags = new List <TaskTag>();
if (taskDto.TagIds != null)
{
foreach (var tagId in taskDto.TagIds)
{
var tag = await context.Tags.FindAsync(tagId);
if (tag == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Failed to find tag"
}));
}
if (tag.UserId != userId)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Unauthorized tag id"
}));
}
var taskTag = new TaskTag()
{
Tag = tag,
Task = task
};
task.TaskTags.Add(taskTag);
}
}
if (await context.SaveChangesAsync() == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Failed to create task"
}));
}
return(mapper.Map <TaskDtoToReturn>(task));
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
TaskTag taskTag = await db.TaskTags.FindAsync(id);
db.TaskTags.Remove(taskTag);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public TaskTag AddTaskTag(string projectUId, TaskTag newtag)
{
var client = ClientHelper.GetClient(authorizator);
HttpResponseMessage response = client.Post(Url("TaskTags/" + projectUId), new ObjectContent<TaskTag>(newtag, JsonValueMediaTypeFormatter.DefaultMediaType));
ClientHelper.HandleHTTPErrorCode(response, true);
if (response.StatusCode == System.Net.HttpStatusCode.NotFound) {
throw new ScrumFactory.Exceptions.OldServerException();
}
return response.Content.ReadAs<TaskTag>();
}
private void TagFilter(TaskItem ts, List <string> tags)
{
if (ts.TaskTags == null)
{
ts.TaskTags = new List <TaskTag>();
}
List <string> newTags = new List <string>();
List <TaskTag> removeTags = new List <TaskTag>();
if (ts.TaskId != 0)
{
foreach (var s in ts.TaskTags)
{
if (s.Tag.Name != tags.SingleOrDefault(t => t == s.Tag.Name))
{
removeTags.Add(s);
}
}
foreach (var d in removeTags)
{
ts.TaskTags.Remove(d);
}
}
for (int i = 0; i < tags.Count; i++)
{
var temp = _db.Tags.SingleOrDefault(t => t.Name == tags[i]);
if (temp != null && ts.TaskTags.SingleOrDefault(t => t.Tag.Name == tags[i]) == null)
{
TaskTag tasktag = new TaskTag {
Task = ts, Tag = temp
};
ts.TaskTags.Add(tasktag);
}
else if (ts.TaskTags.SingleOrDefault(t => t.Tag.Name == tags[i]) == null)
{
newTags.Add(tags[i]);
}
}
if (newTags.Count != 0)
{
for (int i = 0; i < newTags.Count; i++)
{
var tag = new Tag {
Name = newTags[i]
};
_db.Tags.Add(tag);
TaskTag tasktag2 = new TaskTag {
Task = ts, Tag = tag
};
ts.TaskTags.Add(tasktag2);
}
}
}
public async Task <ActionResult> Edit([Bind(Include = "AppTaskId,TagTaskId")] TaskTag taskTag)
{
if (ModelState.IsValid)
{
db.Entry(taskTag).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.AppTaskId = new SelectList(db.AppTasks, "Id", "Name", taskTag.AppTaskId);
ViewBag.TagTaskId = new SelectList(db.TagTasks, "Id", "Name", taskTag.TagTaskId);
return(View(taskTag));
}
public ActionResult <TaskReadDto> PostTask(TaskCreateDto taskCreateDto)
{
_logger.LogInformation("Consultando a lista de tarefas de Id: {id}", taskCreateDto.TaskListId);
TaskList taskList = _taskListsRepo.GetTaskListById(taskCreateDto.TaskListId);
if (taskList == null)
{
_logger.LogWarning("A lista de tarefas de Id: {id} não existe", taskCreateDto.TaskListId);
return(NotFound());
}
_logger.LogInformation("Mapeando a tarefa a ser cadastrada para a model");
Models.Task task = _mapper.Map <Models.Task>(taskCreateDto);
_logger.LogInformation("Cadastrando a tarefa no banco de dados");
_tasksRepo.PostTask(task);
_tasksRepo.SaveChanges();
if (taskCreateDto.Tags != null && taskCreateDto.Tags.Count > 0)
{
Tag tag;
TaskTag taskTag = new TaskTag()
{
TaskId = task.Id
};
_logger.LogInformation("Cadastrando as tags da tarefa e fazendo os relacionamentos no banco de dados");
foreach (TagCreateDto tagCreateDto in taskCreateDto.Tags)
{
tag = _mapper.Map <Tag>(tagCreateDto);
_tagsRepo.PostTag(tag);
_tagsRepo.SaveChanges();
taskTag.TagId = tag.Id;
_taskTagsRepo.PostTaskTag(taskTag);
_taskTagsRepo.SaveChanges();
}
}
_logger.LogInformation("Montando objeto de retorno");
Models.Task taskCreated = _tasksRepo.GetTaskById(task.Id);
TaskReadDto taskReadDto = _mapper.Map <TaskReadDto>(taskCreated);
if (taskCreated.TaskTags != null && taskCreated.TaskTags.Count > 0)
{
List <Tag> tags = taskCreated.TaskTags.Select(tt => tt.Tag).ToList();
taskReadDto.Tags = _mapper.Map <List <TagReadDto> >(tags);
}
return(CreatedAtAction("GetTaskById", new { id = taskReadDto.Id }, taskReadDto));
}
// GET: Admin/TaskTags/Details/5
public async Task <ActionResult> Details(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TaskTag taskTag = await db.TaskTags.FindAsync(id);
if (taskTag == null)
{
return(HttpNotFound());
}
return(View(taskTag));
}
// GET: Admin/TaskTags/Edit/5
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TaskTag taskTag = await db.TaskTags.FindAsync(id);
if (taskTag == null)
{
return(HttpNotFound());
}
ViewBag.AppTaskId = new SelectList(db.AppTasks, "Id", "Name", taskTag.AppTaskId);
ViewBag.TagTaskId = new SelectList(db.TagTasks, "Id", "Name", taskTag.TagTaskId);
return(View(taskTag));
}
public ActionResult PutTask(long id, TaskUpdateDto taskUpdateDto)
{
_logger.LogInformation("Consultando a tarefa de Id: {id}", id);
Models.Task task = _tasksRepo.GetTaskById(id);
if (task == null)
{
_logger.LogWarning("A tarefa de Id: {id} não existe", id);
return(NotFound());
}
_logger.LogInformation("Editando a tarefa de Id: {id}", id);
_mapper.Map(taskUpdateDto, task);
_tasksRepo.SaveChanges();
if (task.TaskTags != null && task.TaskTags.Count > 0)
{
_logger.LogInformation("Deletando as tags atuais da tarefa de Id: {id}", id);
_taskTagsRepo.DeleteTaskTags(task.TaskTags);
_taskTagsRepo.SaveChanges();
}
if (taskUpdateDto.Tags != null && taskUpdateDto.Tags.Count > 0)
{
Tag tag;
TaskTag taskTag = new TaskTag()
{
TaskId = task.Id
};
_logger.LogInformation("Cadastrando as novas tags da tarefa de Id: {id}", id);
foreach (TagUpdateDto tagUpdateDto in taskUpdateDto.Tags)
{
tag = _mapper.Map <Tag>(tagUpdateDto);
_tagsRepo.PostTag(tag);
_tagsRepo.SaveChanges();
taskTag.TagId = tag.Id;
_taskTagsRepo.PostTaskTag(taskTag);
_taskTagsRepo.SaveChanges();
}
}
return(NoContent());
}
public void AddTag([FromBody] AddTagParameters inc)
{
var tag = context.Tags.Where(t => t.Id == inc.TagId).Include(t => t.Tasks).Single();
var task = context.Tasks.Where(tt => tt.Id == inc.TaskId).Include(t => t.Tags).Single();
if (tag != null && task != null)
{
var tasktag = new TaskTag
{
TagId = tag.Id,
TaskId = task.Id
};
task.Tags.Add(tasktag);
tag.Tasks.Add(tasktag);
context.SaveChanges();
}
}
public IActionResult AddEvent(AddTaskTagViewModel viewModel)
{
if (ModelState.IsValid)
{
int taskId = viewModel.TaskId;
int tagId = viewModel.TagId;
List <TaskTag> existingItems = context.TaskTags
.Where(et => et.TaskId == taskId)
.Where(et => et.TagId == tagId)
.ToList();
if (existingItems.Count == 0)
{
TaskTag taskTag = new TaskTag
{
TaskId = taskId,
TagId = tagId
};
context.TaskTags.Add(taskTag);
context.SaveChanges();
}
TaskTag eventTag = new TaskTag
{
TaskId = taskId,
TagId = tagId
};
context.TaskTags.Add(eventTag);
context.SaveChanges();
return(Redirect("/Tasks/Detail/" + taskId));
}
return(View(viewModel));
}
public void PostTaskTag(TaskTag taskTag)
{
_context.TaskTags.Add(taskTag);
}
public void SaveTaskTag(TaskTag tag)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
var oldTag = context.TaskTags.SingleOrDefault(t => t.TagUId == tag.TagUId);
if (oldTag == null) {
context.TaskTags.AddObject(tag);
} else {
context.AttachTo("TaskTags", oldTag);
context.ApplyCurrentValues<TaskTag>("TaskTags", tag);
}
context.SaveChanges();
}
}
public async Task <ActionResult <TaskDtoToReturn> > UpdateTask(TaskDtoToUpdate taskDto)
{
var userId = HttpContext.User?.Claims?.FirstOrDefault(c => c.Type == "userid")?.Value;
if (string.IsNullOrEmpty(userId))
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Invalid token"
}));
}
var task = await context.Tasks.Include("TaskTags.Tag").Include(t => t.SubTasks).SingleOrDefaultAsync(t => t.Id == taskDto.Id);
if (task == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Failed to find task"
}));
}
if (task.UserId != userId)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Unathorized task id"
}));
}
//update single value properties
mapper.Map <TaskDtoToUpdate, TaskC>(taskDto, task);
//remove the deleted subtasks
foreach (var subtask in task.SubTasks)
{
if (taskDto.SubTasks.Find(s => s.Id == subtask.Id) == null)
{
context.SubTasks.Remove(subtask);
}
}
foreach (var subtaskDto in taskDto.SubTasks)
{
var subtask = task.SubTasks.Find(s => s.Id == subtaskDto.Id); //compare subtasks from DTO with subtasks from DB
if (subtaskDto.Id <= 0) //subtasks from DTO with id 0 or less are treated as new subtasks
{
var newSubTask = mapper.Map <SubTask>(mapper.Map <SubTaskDtoForCreate>(subtaskDto));
task.SubTasks.Add(newSubTask);
}
else if (subtask != null) //if the substask id is a match, update the properties
{
mapper.Map <SubTaskDtoToReturn, SubTask>(subtaskDto, subtask);
}
else // if the id from the DTO subtask does not match any task from the DB, send error
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Invalid subtask id"
}));
}
}
//remove the deleted task-tag relationships
var tasktagsToDelete = new List <TaskTag>();
foreach (var taskTag in task.TaskTags)
{
if (taskDto.Tags.Find(t => t.Id == taskTag.TagId) == null)
{
tasktagsToDelete.Add(taskTag);
}
}
foreach (var taskTag in tasktagsToDelete)
{
task.TaskTags.Remove(taskTag);
}
foreach (var tagDto in taskDto.Tags)
{
var subtask = task.TaskTags.Find(s => s.TagId == tagDto.Id); //compare subtasks from DTO with subtasks from DB
if (subtask == null) //if the substask id is a match, update the properties
{
var tag = await context.Tags.FindAsync(tagDto.Id);
if (tag == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Failed to find tag"
}));
}
if (tag.UserId != userId)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Unathorized tag id"
}));
}
var taskTag = new TaskTag()
{
Tag = tag,
Task = task
};
task.TaskTags.Add(taskTag);
}
}
if (await context.SaveChangesAsync() == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, new Response {
Status = "Error", Message = "Failed to update task"
}));
}
return(mapper.Map <TaskDtoToReturn>(task));
}
public async Task Update(MTask entityToUpdate)
{
var task = await FindById(entityToUpdate.TaskId);
if (task is null)
{
throw new ArgumentException("Task with the specified ID not found!!!");
}
_context.Tasks.Attach(task);
foreach (var file in task.AttachedFiles)
{
// если в списке отсутствует прикрепленный файл то удаляем его из списка прикрепленных
if (entityToUpdate.AttachedFiles.FirstOrDefault(f => f.AttachedFileId == file.AttachedFileId) is null)
{
var attachedFile = await _context.AttachedFiles.FirstOrDefaultAsync(f => f.AttachedFileId == file.AttachedFileId);
_context.AttachedFiles.Remove(attachedFile);
var taskAttachedFile = await _context.TaskAttachedFiles.FirstOrDefaultAsync(f => f.AttachedFileId == file.AttachedFileId);
_context.TaskAttachedFiles.Remove(taskAttachedFile);
}
}
foreach (var file in entityToUpdate.AttachedFiles)
{
if (file.AttachedFileId <= 0)
{
file.Task = task;
task.AttachedFiles.Add(file);
}
}
task.Name = entityToUpdate.Name;
task.Body = entityToUpdate.Body;
task.Deadline = entityToUpdate.Deadline;
task.IsImportant = entityToUpdate.IsImportant;
task.CoExecutors.Clear();
task.CoExecutors = entityToUpdate.CoExecutors;
task.Observers.Clear();
task.Observers = entityToUpdate.Observers;
task.ResponsiblesForExecution.Clear();
task.ResponsiblesForExecution = entityToUpdate.ResponsiblesForExecution;
if (entityToUpdate.TaskTags != null)
{
foreach (var taskTag in task.TaskTags)
{
// Находим тег в БД
var tag = await _context.Tags.FirstOrDefaultAsync(t => t.TagId == taskTag.TagId);
int taskCount = _context.TaskTags.Where(t => t.TagId == taskTag.TagId).Count();
int companyCount = _context.CompanyTags.Where(t => t.TagId == taskTag.TagId).Count();
// Если у тега есть только одна связь с текущей задачей
// и одна связь с компанией
// и при обновлении этот тег не используется
// то удаляем этот тег
if (taskCount <= 1 &&
companyCount <= 1 &&
taskTag.TaskId == entityToUpdate.TaskId &&
entityToUpdate.TaskTags.FirstOrDefault(t => t.Tag.Name.Equals(tag.Name)) is null)
{
TaskTag searchTaskTag = await _context.TaskTags.FirstOrDefaultAsync(t => t.Id == taskTag.Id);
if (searchTaskTag != null)
{
_context.TaskTags.Remove(searchTaskTag);
}
CompanyTag companyTag = await _context.CompanyTags.FirstOrDefaultAsync(t => t.TagId == taskTag.TagId);
_context.Tags.Remove(tag);
}
else
{
_context.TaskTags.Remove(taskTag);
}
}
await _context.SaveChangesAsync();
task.TaskTags.Clear();
for (int i = 0; i < entityToUpdate.TaskTags.Count; i++)
{
// Ищем тег
var tag = await _context.Tags.FirstOrDefaultAsync(t => t.Name.ToLower().Equals(entityToUpdate.TaskTags[i].Tag.Name.ToLower()));
// Если тег найден
if (tag != null)
{
// Связываем тег с задачей
task.TaskTags.Add(new TaskTag
{
TagId = tag.TagId,
TaskId = task.TaskId
});
}
else
{
task.TaskTags.Add(entityToUpdate.TaskTags[i]);
}
var companyTag = await _context.CompanyTags.FirstOrDefaultAsync(ct => ct.CompanyId == task.Company.CompanyId && ct.TagId == tag.TagId);
// Если указанный тег не связан с текущей компанией то тогда связываем их
if (companyTag is null)
{
await _context.CompanyTags.AddAsync(new CompanyTag
{
CompanyId = task.Company.CompanyId,
TagId = tag.TagId
});
}
}
}
await _context.SaveChangesAsync();
}
public override string ToString()
{
return(string.Format("{0}:{1}", nodeConfig.ToString(), TaskTag == null?"none": TaskTag.ToString()));
}
public void UpdateTaskTag(string projectUId, string tagUId, TaskTag tag)
{
var client = ClientHelper.GetClient(authorizator);
HttpResponseMessage response = client.Put(Url("TaskTags/" + projectUId + "/" + tagUId), new ObjectContent<TaskTag>(tag, JsonValueMediaTypeFormatter.DefaultMediaType));
ClientHelper.HandleHTTPErrorCode(response);
}
public void UpdateTaskTag(string projectUId, string tagUId, TaskTag tag)
{
authorizationService.VerifyPermissionAtProject(projectUId, new PermissionSets[] { PermissionSets.TEAM, PermissionSets.SCRUM_MASTER });
tasksRepository.SaveTaskTag(tag);
}
private void AddNewTag()
{
var newTag = new TaskTag() { ProjectUId = Project.ProjectUId, TagUId = Guid.NewGuid().ToString() };
newTag.Name = GetNewTagName();
executor.StartBackgroundTask<TaskTag>(() => { return tasksService.AddTaskTag(Project.ProjectUId, newTag); },
t => {
((ObservableCollection<TaskTag>)TaskTags).Insert(0, t);
allTaskTags.Add(t);
FilterTag = t;
});
}
private void UpdateTag(TaskTag tag)
{
executor.StartBackgroundTask(() => { tasksService.UpdateTaskTag(Project.ProjectUId, tag.TagUId, tag); }, () => { });
}
private void RemoveTag(TaskTag tag)
{
System.Windows.MessageBoxResult confirm = dialogs.ShowMessageBox(Properties.Resources.Remove_review_tag, String.Format(Properties.Resources.Confirm_remove_review_tag_N, tag.Name), System.Windows.MessageBoxButton.YesNo);
if (confirm == System.Windows.MessageBoxResult.No)
return;
executor.StartBackgroundTask(() => { tasksService.RemoveTaskTag(Project.ProjectUId, tag.TagUId); },
() => {
allTaskTags.Remove(tag);
((ObservableCollection<TaskTag>)TaskTags).Remove(tag);
foreach (var vm in Tasks.Where(t => t.Task.TagUId==tag.TagUId))
vm.Task.TagUId = null;
});
}
public void UpdateTaskTag(string projectUId, string tagUId, TaskTag tag)
{
authorizationService.VerifyPermissionAtProject(projectUId, new PermissionSets[] { PermissionSets.TEAM, PermissionSets.SCRUM_MASTER });
tasksRepository.SaveTaskTag(tag);
}
