public IActionResult Create(Domain.Task task)
{
task.AddedOn = DateTime.UtcNow;
_tasksContext.Tasks.Add(task);
_tasksContext.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Add(string name, DateTime?dateTime, bool priority, int categoryId)
{
var session = DataConfig.GetSession();
var task = new Domain.Task
{
Name = name,
DateTime = dateTime,
Priority = priority,
Category = session.Load <Domain.Category>(categoryId),
Notes = "",
Subtasks = new HashSet <Domain.Subtask>()
};
session.SaveOrUpdate(task);
session.Transaction.Commit();
return(Json(new
{
Id = task.Id,
Name = task.Name,
Completed = task.Completed,
Priority = task.Priority,
DateTime = task.DateTime,
CategoryId = task.Category.Id,
Subtasks = GetJsonSubtasks(task)
}));
}
public void test_ThrowException_TaskName_TooShort()
{
string taskName = new string('A', this.minLengthTaskName - 1);;
const string taskDescription = "A Perfect Description";
var task = new Domain.Task(taskName, taskDescription);
}
// returns all Tasks based on who's email it is
public List <Domain.Task> GetAllTasks(int userId)
{
List <Domain.Task> allTask = new List <Domain.Task>();
using (conn)
{
conn.Open();
using (var cmd = new NpgsqlCommand("SELECT * FROM tasks WHERE @uid = user_id", conn))
{
cmd.Parameters.AddWithValue("uid", userId);
var reader = cmd.ExecuteReader();
while (reader.Read())
{
int id = Convert.ToInt32(reader["task_id"]);
string title = reader["task_title"].ToString();
string description = reader["task_description"].ToString();
//string imgUrl = reader["image_url"].ToString();
Domain.Task task = new Domain.Task(id, title, description);
allTask.Add(task);
}
}
}
return(allTask);
}
public void test_ThrowException_TaskName_Null()
{
const string taskName = null;
const string taskDescription = "A Perfect Description";
var task = new Domain.Task(taskName, taskDescription);
}
protected override async Task <TaskResult.Full> HandleCore(Command command)
{
if (command == null)
{
throw new InvalidArgumentException("The argument is null");
}
var user = await _db.Users.FindAsync(command.UserId);
if (user == null)
{
throw new NotFoundException("The " + nameof(user) + " with id: " + command.UserId + " doesn't exist");
}
var task = new Domain.Task()
{
User = user,
Name = command.Name,
Description = command.Description,
CreatedAt = DateTime.Now
};
await _db.Tasks.AddAsync(task);
await _db.SaveChangesAsync();
return(new TaskResult.Full(task));
}
public async Task AddEvent(Domain.Task ev)
{
if (_eventLog.Count == 0)
{
_eventLog.Add(ev);
}
else
{
var newEvTs = TimeSpan.Parse(ev.EndTime);
for (var x = _eventLog.Count - 1; x > -1; x--)
{
var ts = _eventLog[x].EndTime.ParseEndTime();
if (newEvTs.Hours >= ts.Hours && newEvTs.Minutes >= ts.Minutes)
{
_eventLog.Insert(x + 1, ev);
}
if (x == 0)
{
_eventLog.Insert(0, ev);
}
}
}
}
public void test_ThrowException_TaskDescription_TooLong()
{
const string taskName = "A Perfect Name";
string taskDescription = new string('A', this.maxLengthTaskDescription + 1);;
var task = new Domain.Task(taskName, taskDescription);
}
/// <summary>
/// Save a TaskRepository
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="task"></param>
/// <returns>returns the id of the saved task</returns>
public int Save(DataContext dc, Domain.Task task)
{
dc = dc ?? Conn.GetContext();
var dbTask = dc.Tasks.Where(t => t.TaskID == task.ID).SingleOrDefault();
var isNew = false;
if (dbTask == null)
{
dbTask = new DataAccess.SqlRepository.Task();
isNew = true;
}
dbTask.SectionID = task.SectionID;
dbTask.StartTime = task.StartTime;
dbTask.EndTime = task.StartTime.AddMinutes(task.Interval);
dbTask.TaskTypeID = task.TaskTypeId;
dbTask.DateUpdated = DateTime.Now;
if (isNew)
{
dbTask.DateCreated = DateTime.Now;
dc.Tasks.InsertOnSubmit(dbTask);
}
dc.SubmitChanges();
return(dbTask.TaskID);
}
private Domain.Task GetFunctionalTask()
{
var task = new Domain.Task(validTaskName, validTaskDescription);
new PrivateObject(task).SetPrivateProperty("Id", 1);
return(task);
}
public void Update(TaskDTO taskDTO)
{
taskDTO.ModifiedOn = DateTime.Now;
Domain.Task task = DatabaseAutomapperConfiguration.TaskDTOToTask(taskDTO);
DatabaseContext.Tasks.Update(task);
DatabaseContext.SaveChanges();
return;
}
/// <summary>
/// Facade to Add a SubTask to a Task
/// </summary>
private void AddSubTaskToTask(Domain.Task parentTask, Domain.Task childTask)
{
var subTask = new SubTask(parentTask, childTask);
parentTask.AddSubTask(subTask);
_taskRepository.Update(parentTask);
}
private IEnumerable <object> GetJsonSubtasks(Domain.Task task)
{
return(task.Subtasks.Select(st => new
{
Id = st.Id,
Name = st.Name,
Completed = st.Completed
}));
}
public void Add(TaskDTO taskDTO)
{
Domain.Task task = DatabaseAutomapperConfiguration.TaskDTOToTask(taskDTO);
task.CreatedOn = DateTime.Now;
task.ModifiedOn = DateTime.Now;
DatabaseContext.Tasks.Add(task);
DatabaseContext.SaveChanges();
return;
}
public int Delete(int taskId)
{
Domain.Task task = new Domain.Task {
TaskId = taskId
};
_ternContext.Tasks.Attach(task);
_ternContext.Tasks.Remove(task);
int rowAffected = _ternContext.SaveChanges();
return(rowAffected);
}
public async Task <int> DeleteAsync(int taskId)
{
Domain.Task task = new Domain.Task {
TaskId = taskId
};
_ternContext.Tasks.Attach(task);
_ternContext.Tasks.Remove(task);
int rowAffected = await _ternContext.SaveChangesAsync();
return(rowAffected);
}
public TaskDTO GetById(int id)
{
Domain.Task task = this.DatabaseContext.Tasks.Find(id);
if (task == null)
{
return(null);
}
TaskDTO taskDTO = DatabaseAutomapperConfiguration.TaskToTaskDTO(task);
return(taskDTO);
}
public void Delete(int id)
{
Domain.Task task = this.DatabaseContext.Tasks.Find(id);
if (task == null)
{
return;
}
DatabaseContext.Tasks.Remove(task);
DatabaseContext.SaveChanges();
return;
}
public void InsertOrUpdate(Domain.Task task)
{
if (task.Id == default(int))
{
task.Id = _tasks.Count + 1;
_tasks.Add(task);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Delete a single TaskRepository
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="task"></param>
public void Delete(DataContext dc, Domain.Task task)
{
dc = dc ?? Conn.GetContext();
var dbTask = dc.Tasks.Where(t => t.TaskID == task.ID).SingleOrDefault();
if (dbTask == null)
{
return;
}
//dc.Tasks.Attach(dbTask, true);
dc.Tasks.DeleteOnSubmit(dbTask);
dc.SubmitChanges();
}
public ActionResult Update(Domain.Task item)
{
try
{
_db.Update(item);
return(View("List", _db.getAll().Where(x => x.ApplicationUserId == User.Identity.GetUserId()).ToList()));
}
catch (Exception ex)
{
ModelState.AddModelError("", "işlem yapılırken bir hata oluştu - Hata:" + ex.Message);
return(View(item));
}
}
public async Task Handle(AddTaskCommand command)
{
var conference = await _context.Conferences.SingleOrDefaultAsync(x => x.Id == command.ConferenceId);
if (conference == null)
{
throw new ConferenceNotFoundException(command.ConferenceId);
}
var task = new Domain.Task(command.ConferenceId, command.OriginId, command.Body, command.TaskType);
await _context.Tasks.AddAsync(task);
await _context.SaveChangesAsync();
}
public async Task <int> CreateNewTask(CreateTaskModel taskDetail)
{
var task = new Domain.Task {
TaskName = taskDetail.TaskName,
Description = taskDetail.Description,
ListId = null,
StatusId = 1,
CreatedDate = DateTime.Now
};
_ternContext.Tasks.Add(task);
await _ternContext.SaveChangesAsync();
return(task.TaskId);
}
public ActionResult AddTask(Models.TaskModel model)
{
var task = new Domain.Task
{
Id = model.Id,
TaskDate = model.TaskDate,
StartTime = model.StartTime.TimeOfDay,
EndTime = model.EndTime.TimeOfDay,
DelayTime = model.DelayTime.TimeOfDay,
CategoryId = model.CategoryId
};
_dbContext.Tasks.Add(task);
_dbContext.SaveChanges();
return(Ok());
}
public async Task <int> Update(TaskModel taskDetail)
{
int recordAffected = 0;
Domain.Task task = _ternContext.Tasks.FirstOrDefault(x => x.TaskId == taskDetail.TaskId);
if (task != null)
{
task.TaskName = taskDetail.TaskName;
task.Description = taskDetail.Description;
task.ListId = taskDetail.List.ListId;
task.StatusId = taskDetail.Status.StatusId;
_ternContext.Tasks.Update(task);
recordAffected = await _ternContext.SaveChangesAsync();
}
return(recordAffected);
}
public async Task HandleAsync(CreateTaskCommand command, ICorrelationContext context)
{
var task = new Domain.Task(command.Id, command.Title, command.Description, command.AssignedTo, command.PlannedStartDate,
command.PlannedEndDate, command.ActualStartDate, command.ActualEndDate, command.Status, command.Priority,
command.AttachmentPath, command.Owner, command.EntryDate);
var taskCreated = new TaskCreatedEvent(command.Id, command.Title, command.Description, command.AssignedTo, command.PlannedStartDate,
command.PlannedEndDate, command.ActualStartDate, command.ActualEndDate, command.Status, command.Priority,
command.AttachmentPath, command.Owner, command.EntryDate);
await _taskRepository.AddAsync(task);
await _publisher.PublishAsync(taskCreated, context);
// publish the event to bus
// do some logging
}
public async Task <string> Execute(CreateTaskCommand command)
{
var list = await repo.GetById(command.ListId);
var task = new Domain.Task
{
Id = Guid.NewGuid().ToString(),
Description = command.Description,
Name = command.Name
};
list.Tasks.Add(task);
await repo.Replace(list);
return(task.Id);
}
private void AddFunctionalSubTask_IntoParentTask(Domain.Task parentTask)
{
if (parentTask != null)
{
int childTasknumber = (parentTask.SubTasks?.Count ?? 0) + 1;
string childTaskName = $"A Perfect Name - Child nº {childTasknumber}";
string childTaskDescription = $"A Perfect Description - Child nº {childTasknumber}";
var childTask = new Domain.Task(childTaskName, childTaskDescription);
var subTask = new SubTask(
parentTask: parentTask,
childTask: childTask);
parentTask.AddSubTask(subTask);
}
}
public async Task <IActionResult> CreateTask(Guid id, [FromBody] CreateSchemaTaskEventCommand command)
{
try
{
command.SchemaId = id;
Domain.Task task = await this._mediator.Send(command);
return(Ok(task));
}
catch (SchemaDomainException exception)
{
this._logger.LogError(0, exception, exception.Message);
return(BadRequest(exception.Message));
}
catch (Exception exception)
{
this._logger.LogError(0, exception, exception.Message);
return(BadRequest());
}
}
public MessageFormat <TaskDTO> Update(TaskDTO taskDTO)
{
MessageFormat <TaskDTO> result = new MessageFormat <TaskDTO>();
taskDTO.ModifiedOn = DateTime.Now;
Domain.Task task = DatabaseAutomapperConfiguration.TaskDTOToTask(taskDTO);
try
{
DatabaseContext.Tasks.Update(task);
DatabaseContext.SaveChanges();
result.Message = "Updated Successfully";
result.Data = taskDTO;
result.Success = true;
return(result);
}
catch (Exception exception)
{
throw exception;
}
}
