/// <summary>
        ///     Marks the status of a <see cref="ProjectTask"/>.
        /// </summary>
        /// <param name="id">Internal project id.</param>
        /// <param name="status">The new <see cref="ProjectTaskStatus"/>.</param>
        /// <param name="token">The cancellation token.</param>
        /// <returns>The <see cref="ProjectTask"/> after the status update.</returns>
        public async Task <ProjectTask> MarkStatusAsync(Guid id, ProjectTaskStatus status, CancellationToken token)
        {
            if (id == null || id == Guid.Empty)
            {
                throw new ArgumentNullException(nameof(id));
            }
            if (token == null)
            {
                throw new ArgumentNullException(nameof(token));
            }

            var sql = @"
                UPDATE  entities.project_task
                SET     project_task_status = @project_task_status
                WHERE   id = @id";

            await using var connection = await _provider.OpenConnectionScopeAsync(token);

            await using var command = _provider.CreateCommand(sql, connection);

            command.AddParameterWithValue("id", id);
            command.AddParameterWithValue("project_task_status", status);

            var affected = await command.ExecuteNonQueryAsync(token);

            if (affected == 0)
            {
                throw new EntityNotFoundException(nameof(Project));
            }

            // Get the updated object from the datastore.
            return(await GetAsync(id, token));
        }
        public async Task <ActionResult <ProjectTaskStatus> > CreateItem([FromForm] ProjectTaskStatus item)
        {
            try
            {
                var existItems = await _projectTaskStatusRepository
                                 .FindAsync(e => e.StatusName.ToLower().Equals(item.StatusName.ToLower()) && !e.Deleted);

                if (existItems.Count > 0)
                {
                    return(BadRequest("Статус с таким наименованием уже существует"));
                }

                if (item.ProjectTaskStatusId > 0)
                {
                    return(BadRequest("Идентификатор записи должен быть равен 0"));
                }

                await _projectTaskStatusRepository.CreateAsync(item);

                return(item);
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Esempio n. 3
0
        public void SetStatus(ProjectTaskStatus newStatus)
        {
            var oldStatus = newStatus;

            Status = newStatus;
            _events.Add(new TaskStatusChanged(Id, oldStatus, newStatus));
        }
        public async Task <ActionResult <ProjectTaskStatus> > UpdateItem([FromForm] ProjectTaskStatus item)
        {
            try
            {
                var existItem = await _projectTaskStatusRepository.FindByIdAsync(item.ProjectTaskStatusId);

                if (existItem == null)
                {
                    return(NotFound());
                }

                existItem.StatusName  = item.StatusName;
                existItem.StatusColor = item.StatusColor;
                existItem.Order       = item.Order;

                await _projectTaskStatusRepository.EditAsync(existItem);

                return(existItem);
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Esempio n. 5
0
        private ProjectTask CreateProjectTask(Project project, string subject, string notes, ProjectTaskStatus status, Person assignedTo)
        {
            ProjectTask task = ObjectSpace.FindObject <ProjectTask>(new BinaryOperator("Subject", subject));

            if (task == null)
            {
                task            = ObjectSpace.CreateObject <ProjectTask>();
                task.Project    = project;
                task.Subject    = subject;
                task.Notes      = notes;
                task.Status     = status;
                task.AssignedTo = assignedTo;
                if (task.Status == ProjectTaskStatus.InProgress || task.Status == ProjectTaskStatus.Completed)
                {
                    task.StartDate = DateTime.Now.AddDays(rnd.Next(1) * (-1));
                }
                if (task.Status == ProjectTaskStatus.Completed)
                {
                    task.EndDate = DateTime.Now.AddDays(rnd.Next(2));
                }
                task.Save();
            }
            return(task);
        }
Esempio n. 6
0
 public TaskStatusChanged(int id, ProjectTaskStatus oldStatus, ProjectTaskStatus newStatus)
 {
     Id        = id;
     OldStatus = oldStatus;
     NewStatus = newStatus;
 }
 private string GetTaskStatusUriString(ProjectTaskStatus status)
 {
     string result = "";
     switch (status)
     {
         case ProjectTaskStatus.NotAccept:
             result = "notaccept";
             break;
         case ProjectTaskStatus.Open:
             result = "open";
             break;
         case ProjectTaskStatus.Closed:
             result = "closed";
             break;
         case ProjectTaskStatus.Disable:
             result = "disable";
             break;
         case ProjectTaskStatus.Unclassified:
             result = "unclassified";
             break;
         case ProjectTaskStatus.NotInMilestone:
             result = "notinmilestone";
             break;
     }
     return result;
 }
 /// <summary>
 /// Returns the list with the detailed information about the tasks for the current user 
 /// within specified project
 /// </summary>
 /// <param name="id">Project ID</param>
 /// <param name="status">Task status</param>
 /// <returns>Tasks collection</returns>
 public ProjectTaskCollection GetTasksMyByProject(int id, ProjectTaskStatus status = ProjectTaskStatus.Open)
 {
     return GetRESTCollection<ProjectTaskCollection>("api/1.0/project/{0}/task/@self/{1}",
         id, GetTaskStatusUriString(status));
 }
 /// <summary>
 /// Returns the list with the detailed information about the tasks for the current user 
 /// within specified project
 /// </summary>
 /// <param name="project">Project</param>
 /// <param name="status">Task status</param>
 /// <returns>Tasks collection</returns>
 public ProjectTaskCollection GetTasksMyByProject(ProjectBrief project, ProjectTaskStatus status)
 {
     return GetTasksMyByProject(project.ID, status);
 }
Esempio n. 10
0
 /// <summary>
 /// Returns the list with the detailed information about the tasks for the current user
 /// </summary>
 /// <param name="status">Task status</param>
 /// <returns>Tasks collection</returns>
 public ProjectTaskCollection GetTasksMy(ProjectTaskStatus status)
 {
     return GetRESTCollection<ProjectTaskCollection>("api/1.0/project/task/@self/{0}", GetTaskStatusUriString(status));
 }
Esempio n. 11
0
 /// <summary>
 /// Returns the list of all tasks with the selected status in the project with the 
 /// ID specified in the request 
 /// </summary>
 /// <param name="projectID">Project ID</param>
 /// <param name="status">Task status</param>
 /// <returns>Tasks collection</returns>
 public ProjectTaskCollection GetTasksByProject(int projectID, ProjectTaskStatus status)
 {
     return GetRESTCollection<ProjectTaskCollection>("api/1.0/project/{0}/task/{1}",
         projectID, GetTaskStatusUriString(status));
 }
Esempio n. 12
0
        public async Task <SaveProjectTaskResponse> Handle(SaveProjectTaskRequest request, CancellationToken cancellationToken)
        {
            var validationFailures  = new List <ValidationFailure>();
            var isProjectIdDefault  = request.ProjectId == default;
            var isStatusIdDefault   = request.StatusId != default;
            var isTaskIdDefault     = request.TaskId == default;
            var isCommentDefault    = string.IsNullOrWhiteSpace(request.Comment);
            var isReferencesDefault = string.IsNullOrWhiteSpace(request.References);

            if (isProjectIdDefault && string.IsNullOrWhiteSpace(request.ProjectName))
            {
                validationFailures.Add(new ValidationFailure(nameof(request.ProjectName),
                                                             "Unable to create project with an empty project name"));
            }

            if (isTaskIdDefault && string.IsNullOrWhiteSpace(request.TaskReference))
            {
                validationFailures.Add(new ValidationFailure(nameof(request.TaskReference),
                                                             "Unable to create task with an empty task reference"));
            }

            if (validationFailures.Count > 0)
            {
                return(Response.Failed <SaveProjectTaskResponse>(validationFailures.ToArray()));
            }

            var project = (isProjectIdDefault)
                ? await _projectService.Save(new Project { Name = request.ProjectName }, false, cancellationToken)
                : await _projectService.GetProject(request.ProjectId, cancellationToken);

            var task = (isTaskIdDefault)
                ? await _taskService.Save(new Domains.Data.Task {
                Reference   = request.TaskReference,
                Description = request.TaskDescription
            }, false, cancellationToken)
                : await _taskService.GetTask(request.TaskId, cancellationToken);

            var projectTask = (isProjectIdDefault || isTaskIdDefault)
                ? await _projectTaskService.Save(new ProjectTask { Project = project, Task = task }, false,
                                                 cancellationToken)
                : await _projectTaskService.GetProjectTask(project.Id, task.Id, cancellationToken);

            if (!isReferencesDefault &&
                _taskReferenceService.TryGetReferences(request.References, out var taskReferences))
            {
                foreach (var taskReference in taskReferences)
                {
                    await _taskReferenceService.Save(taskReference, false, cancellationToken);
                }
            }

            if (!isStatusIdDefault)
            {
                ProjectTaskStatus currentStatus = await _projectTaskStatusService.GetCurrentStatus(projectTask.Id, cancellationToken);

                if (currentStatus.StatusId != request.StatusId)
                {
                    await _projectTaskStatusService.Save(new ProjectTaskStatus { StatusId = request.StatusId, ProjectTask = projectTask },
                                                         false, cancellationToken);
                }
            }

            if (!isCommentDefault)
            {
                var projectTaskComment =
                    await _projectTaskCommentService.Save(new ProjectTaskComment { Comment = request.Comment }, false, cancellationToken);
            }

            await _projectTaskService.Commit(cancellationToken);

            return(Response.Success <SaveProjectTaskResponse>(projectTask));
        }
Esempio n. 13
0
 public async Task AddTaskStatus(ProjectTaskStatus status)
 {
     await _context.ProjectTaskStatuses.AddAsync(status);
 }
Esempio n. 14
0
        /// <summary>
        /// Returns tasks with the project which have specified status
        /// </summary>
        /// <param name="status">Task status</param>
        /// <returns>Collection of tasks</returns>
        public ProjectTaskCollection GetTasks(ProjectTaskStatus status)
        {
            if (Connection == null)
                throw new Exception("GetTasks(): Connection property can not be null!");

            return Connection.GetTasksByProject(this, status);
        }
 public async Task <ProjectTaskStatus> Save(ProjectTaskStatus projectTaskStatus, bool saveChanges, CancellationToken cancellationToken)
 {
     return(await _projectTaskStatusRepository
            .SaveChanges(projectTaskStatus, saveChanges, true, cancellationToken));
 }