public async Task <ActionResult <Entities.Task> > PostTask(Entities.Task task)
{
_context.Tasks.Add(task);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTask", new { id = task.Id }, task));
}
public async Task <TaskResponse> ExecuteAsync(int taskId, UpdateTaskRequest request)
{
Entities.Task task = await _factory
.CreateAsyncQueryable(_uow.Tasks.Query())
.FirstOrDefaultAsync(tk => tk.Id == taskId);
if (task == null)
{
return(null);
}
task.Tags = _uow.TagsInTasks.Query(t => t.Tag).Where(t => t.TaskId == task.Id).ToList();
task = _mapper.Map(request, task);
foreach (var tagsInTask in task.Tags)
{
var tag = await _factory
.CreateAsyncQueryable(_uow.Tags.Query())
.FirstOrDefaultAsync(t => t.Name == tagsInTask.Tag.Name);
if (tag != null)
{
tagsInTask.Tag = tag;
}
}
await _uow.CommitAsync();
task.Project = await _factory.CreateAsyncQueryable(_uow.Projects.Query(p => p.Tasks, p => p.User))
.FirstOrDefaultAsync(p => p.Id == task.ProjectId);
return(_mapper.Map <Entities.Task, TaskResponse>(task));
}
public bool AddTaskToRole(Entities.Role role, Entities.Task task)
{
bool res = false;
using (SqlConnection cnn = new SqlConnection(sqlCnnStr))
{
string query =
"INSERT INTO RoleTasks" +
" (RoleId, TaskId)" +
" VALUES " +
" (@RoleId, @TaskId)";
using (SqlCommand cmd = new SqlCommand(query, cnn))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@TaskId", task.Id));
cmd.Parameters.Add(new SqlParameter("@RoleId", role.Id));
cnn.Open();
int affected = cmd.ExecuteNonQuery();
res = (affected > 0);
}
}
return(res);
}
public void Get_Task_Test()
{
fakeTaskRepository = new FakeRepository <Entities.Task>();
var testTasks1 = new Entities.Task {
ID = 1,
AssignedToUserID = 1,
ProjectID = 1,
Detail = "Test Task1",
CreatedOn = DateTime.Now,
Status = Entities.Enums.TaskStatus.New
};
var testTasks2 = new Entities.Task {
ID = 2,
AssignedToUserID = 1,
ProjectID = 1,
Detail = "Test Task2",
CreatedOn = DateTime.Now,
Status = Entities.Enums.TaskStatus.New
};
fakeTaskRepository.Add(testTasks1);
fakeTaskRepository.Add(testTasks2);
mockTask.Setup(m => m.Get()).Returns(fakeTaskRepository);
TaskController tasksController = new TaskController(mockTask.Object);
var result = tasksController.Get();
Assert.NotNull(result);
}
/// <summary>
/// Handles task create.
/// </summary>
/// <param name="command">Command.</param>
/// <param name="uowFactory">Application unit of work factory.</param>
public void HandleCreateTask(CreateTaskCommand command, IAppUnitOfWorkFactory uowFactory)
{
using (var uow = uowFactory.Create())
{
var project = uow.ProjectRepository.Get(command.ProjectId);
if (project != null && project.User.Id != command.UserId)
{
throw new DomainException("User does not own the project.");
}
var user = uow.UserRepository.Get(command.UserId);
var task = new Entities.Task()
{
DueDate = DateTime.MaxValue,
IsDone = command.IsDone,
Text = command.Text.Trim(),
Project = project,
User = user,
};
uow.TaskRepository.Add(task);
uow.SaveChanges();
command.TaskId = task.Id;
}
}
public IActionResult Get(int id)
{
{
if (id > 0)
{
try
{
Entities.Task task = _repositoryTask.FindById(id);
if (task != null)
{
return(Ok(task));
}
else
{
return(BadRequest($"Couldn't find a task with id: {id}"));
}
}
catch (Exception ex)
{
//logger.critical(ex.message);
return(BadRequest("Server error(this is nort correct)"));
}
}
else
{
return(BadRequest("Incorrect id"));
}
}
}
public void UpdateTask(DEV_Library.Models.Task task)
{
Entities.Task currentTask = _context.Task.Find(task.Id);
Entities.Task updatedTask = Mapper.MapTask(task);
_context.Entry(currentTask).CurrentValues.SetValues(updatedTask);
}
public Entities.TaskCollection GetAll()
{
Entities.TaskCollection tasks = new Entities.TaskCollection();
using (SqlConnection cnn = new SqlConnection(sqlCnnStr))
{
string query = "SELECT * FROM Tasks";
using (SqlCommand cmd = new SqlCommand(query, cnn))
{
cmd.CommandType = CommandType.Text;
cnn.Open();
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader != null && reader.HasRows)
{
while (reader.Read())
{
Entities.Task task = new Entities.Task();
task.Id = Utils.GetSafeInt32(reader, "TaskId");
task.Name = Utils.GetSafeString(reader, "TaskName");
tasks.Add(task);
}
}
}
}
}
return(tasks);
}
public static void UpdateEntity(Dtos.Task dto, Entities.Task entity)
{
entity.Id = dto.Id;
entity.Name = dto.Name;
entity.Priority = dto.Priority;
entity.Status = (Entities.TaskStatus)dto.Status;
}
/// <summary>
/// Create a new Workflow and add to db context.
/// </summary>
/// <param name="workflow">New workflow to add</param>
/// <returns>The added workflow, as seen from the db context, or an empty workflow with an error message.</returns>
public async Task <Workflow> Create(Workflow workflow, bool bypass = false)
{
string workflowID = System.Guid.NewGuid().ToString();
workflow.id = workflowID;
workflow.active = true;
try
{
var result = await _context.Workflows.AddAsync(workflow);
await _context.SaveChangesAsync();
string id = System.Guid.NewGuid().ToString();
Log.Information("New LIMS Workflow, ID: {0}, Initial Task ID: {1}", workflowID, id);
if (!bypass)
{
LimsServer.Entities.Task tsk = new Entities.Task(id, workflow.id, workflow.interval);
TaskService ts = new TaskService(this._context);
var task = await ts.Create(tsk);
await _context.SaveChangesAsync();
}
return(result.Entity);
}
catch (Exception ex)
{
var result = new Workflow();
result.message = ex.Message;
Log.Error(ex, "Error attempting to create new workflow and workflow task");
return(result);
}
}
public bool RemoveTaskFromRole(Entities.Role role, Entities.Task task)
{
bool res = false;
using (SqlConnection cnn = new SqlConnection(sqlCnnStr))
{
string query =
"DELETE FROM RoleTasks" +
" WHERE RoleId = @RoleId AND TaskId = @TaskId";
using (SqlCommand cmd = new SqlCommand(query, cnn))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@TaskId", task.Id));
cmd.Parameters.Add(new SqlParameter("@RoleId", role.Id));
cnn.Open();
int affected = cmd.ExecuteNonQuery();
res = (affected > 0);
}
}
return(res);
}
public async Task <IActionResult> PutTask(int id, Entities.Task task)
{
if (id != task.Id)
{
return(BadRequest());
}
_context.Entry(task).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Update a task.
/// </summary>
/// <param name="taskToUpdate"></param>
/// <returns></returns>
public async Task <int> Update(int taskId, TaskDto taskToUpdate)
{
try
{
using (var context = new WorkFlowContext())
{
Entities.Task taskToUpdateFromDb = await context.Task.FindAsync(taskId);
if (taskToUpdateFromDb != null)
{
taskToUpdateFromDb.Description = taskToUpdate.Description;
taskToUpdateFromDb.Assignee = taskToUpdate.Assignee;
taskToUpdateFromDb.AssignedBy = taskToUpdate.AssignedBy;
taskToUpdateFromDb.Status = taskToUpdate.Status;
taskToUpdateFromDb.AgreedCompletionDate = taskToUpdate.AgreedCompletionDate;
return(await context.SaveChangesAsync());
}
else
{
return(0);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void TestUpdate()
{
bool actualResult = true;
bool expectedResult = true;
Entities.Task itemToUpdate = new Entities.Task();
TaskLogic businessObject = new TaskLogic();
List <Entities.Task> taskList = new List <Entities.Task>();
taskList = businessObject.GetAll();
itemToUpdate = taskList.FirstOrDefault();
itemToUpdate.Task_Name = "UpdatedTaskName_Nunit";
businessObject.Update(itemToUpdate);
itemToUpdate = businessObject.GetTaskById(itemToUpdate.Task_Id);
if (!itemToUpdate.Task_Name.Equals("UpdatedTaskName_Nunit"))
{
actualResult = false;
}
itemToUpdate.Parent_Task = "UpdatedParentTask_Nunit";
businessObject.Update(itemToUpdate);
itemToUpdate = businessObject.GetTaskById(itemToUpdate.Task_Id);
if (!itemToUpdate.Parent_Task.Equals("UpdatedParentTask_Nunit"))
{
actualResult = false;
}
Assert.AreEqual(actualResult, expectedResult);
}
public void TestEndTask()
{
bool actualResult = false;
bool expectedResult = true;
Entities.Task itemToEnd = new Entities.Task();
TaskLogic businessObject = new TaskLogic();
List <Entities.Task> taskList = new List <Entities.Task>();
taskList = businessObject.GetAll();
itemToEnd = taskList.Where(item => item.Is_End_Task.Equals(false)).FirstOrDefault();
if (itemToEnd != null)
{
businessObject.EndTask(itemToEnd.Task_Id);
taskList = businessObject.GetAll();
itemToEnd = taskList.Where(item => item.Task_Id.Equals(itemToEnd.Task_Id)).FirstOrDefault();
if (itemToEnd.Is_End_Task ?? true)
{
actualResult = true;
}
}
Assert.AreEqual(actualResult, expectedResult);
}
public IEnumerable <Entities.Task> GetAllTasks()
{
var result = new List <Entities.Task>();
using (var connection = MSSQLdb.GetConnection())
{
SqlCommand cmd = new SqlCommand("GetAllTasks", connection);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
connection.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
var task = new Entities.Task
{
IDTask = (int)reader["IDTask"],
NameOfTask = (string)reader["NameOfTask"]
};
result.Add(task);
}
}
return(result);
}
public async Task <Entities.Task> CreateTask(string taskName, string description, string userId, DateTime?dueDate, int typeTask, ICollection <UserProxyViewModel> selectedUsers, DateTime?nextActionDate = null)
{
ValidationTask.ValidateTaskNameIfIsNull(taskName);
Guid taskId = Guid.NewGuid();
var task = new Entities.Task
{
Id = taskId,
TaskName = taskName,
UserId = Guid.Parse(userId),
Description = description,
TypeTaskId = typeTask,
DueDate = dueDate,
CreatedOn = DateTime.Now,
};
foreach (var selectedUser in selectedUsers)
{
if (selectedUser.IsChecked)
{
var userTask = new UserTask
{
UserId = selectedUser.UserId,
Task = task
};
await this.context.AddAsync(userTask);
}
}
await this.context.Tasks.AddAsync(task);
await this.context.SaveChangesAsync();
return(task);
}
/// <summary>
/// Method parse task entity
/// </summary>
/// <param name="eTask">Task in json entity model</param>
/// <returns>DBEntity parsed model</returns>
public static Database.Entities.Task parseTask(Entities.Task eTask)
{
return(new Database.Entities.Task()
{
Content = eTask.content, Time = eTask.time
});
}
public string Edit(Entities.Task task)
{
TaskBL obj = new TaskBL();
obj.Update(task);
return("Task is updated");
}
public async Task <Comment> CreateComment(string text, string userId, Guid taskId, DateTime?reminderDate, int typeCommentId)
{
ValidationComment.ValidateCommentTextIfIsNullOrEmpty(text);
Entities.Task findTask = await this.taskService.FindTaskById(taskId);
var currentUser = await this.context.Users
.FirstOrDefaultAsync(u => u.Id == userId);
Guid commentId = Guid.NewGuid();
var comment = new Comment
{
Id = commentId,
Text = text,
UserId = userId,
Task = findTask,
TaskId = taskId,
CreatedOn = DateTime.Now,
TypeCommentId = typeCommentId,
User = currentUser,
ReminderDate = reminderDate
};
if (reminderDate != null)
{
comment.Task.NextActionDate = reminderDate;
}
await this.context.Comments.AddAsync(comment);
await this.context.SaveChangesAsync();
return(comment);
}
public bool ModifyTask(int id, String type, String status)
{
Entities.Task task = ctx.Tasks.Find(id);
task.ServiceType = type;
task.Status = status;
return(SaveChanges(1));
}
public static ValidationResult CheckTaskInformation(this Entities.Task task)
{
var validator = new TaskValidator();
ValidationResult result = validator.Validate(task);
return(result);
}
//Testing Purpose
public IHttpActionResult POST(Entities.Task task)
{
TaskBL obj = new TaskBL();
obj.AddTask(task);
return(Ok("Task is Added"));
}
public Task Update(Entities.Task entityToUpdate)
{
DbSet.Attach(entityToUpdate);
Context.Entry(entityToUpdate).State = EntityState.Modified;
Context.SaveChanges();
return(entityToUpdate);
}
//Below code for Testing Purpose
public void AddTask(Entities.Task task)
{
using (TaskManagerContext db = new TaskManagerContext())
{
db.Tasks.Add(task);
db.SaveChanges();
}
}
public bool NewTask(int roomId, String taskType)
{
Entities.Task task = new Entities.Task();
task.Room = ctx.Rooms.Where(r => r.Id == roomId).First();
task.ServiceType = taskType;
task.Status = TaskStatus.New;
ctx.Tasks.Add(task);
return(SaveChanges(1));
}
public void DeleteTaskById(int Id)
{
using (TaskManagerContext db = new TaskManagerContext())
{
Entities.Task ts = db.Tasks.Find(Id);
db.Tasks.Remove(ts);
db.SaveChanges();
}
}
public Entities.Task Update(Entities.Task task)
{
using (TaskManagerContext db = new TaskManagerContext())
{
db.Entry(task).State = EntityState.Modified;
db.SaveChanges();
return(task);
}
}
/// <summary>
/// Constructor
/// </summary>
public Cache()
{
Entities.Task task = new Entities.Task();
task.Job = CheckAllExpired;
task.UseLimit = false;
task.WorkInterval = TimeSpan.FromSeconds(Parameter.GetCacheTime);
task.Hierarchy = 0;
Scheduler.AddTask(task);
}
public ActionResult CreateTask([FromBody] Entities.Task task)
{
if (tasksList.Exists(p => p.ID == task.ID))
{
return(Conflict());
}
tasksList.Add(task);
return(CreatedAtAction(nameof(Get), new { id = task.ID }, tasksList));
}
