public void UpdateEnrolmentAndPlantask(Enrolment upEnrolment, PlanTask upPlantask, Assay myAssay)
{
_unitOfWork.AddAction(myAssay, DataActions.Update);
_unitOfWork.AddAction(upEnrolment, DataActions.Update);
_unitOfWork.AddAction(upPlantask, DataActions.Update);
_unitOfWork.Save();
}
public async Task <bool> AddTaskToPlanAsync(TaskDTO taskDTO, int?selectedPriority, int?selectedSection)
{
StudentTask task = new StudentTask
{
Name = taskDTO.Name,
Description = taskDTO.Description,
Private = taskDTO.Private,
Create_Id = taskDTO.CreatorId,
Create_Date = taskDTO.CreateDate,
};
await db.Tasks.AddAsync(task);
db.Save();
int taskId = await db.Tasks.GetTaskIdAsync(task);
PlanTask planTask = new PlanTask
{
Plan_Id = taskDTO.PlanTaskId.Value,
Task_Id = taskId,
Priority = selectedPriority,
Section_Id = selectedSection
};
await db.PlanTasks.AddAsync(planTask);
db.Save();
return(true);
}
private void SetPlanTaskOutWarehouse(PlanTask plantask, List <PlanTaskOutWarehouse> plantaskOutHouseList)
{
PlanTaskBatch planTaskBatch = plantask.PlanTaskBatches.LastOrDefault();
List <PlanTaskOutWarehouse> oldPlanTaskOutWarehouse = planTaskBatch.PlanTaskOutWarehouses.ToList();
if (oldPlanTaskOutWarehouse != null && oldPlanTaskOutWarehouse.Count > 0)
{
foreach (PlanTaskOutWarehouse planTaskOutWarehouse in plantaskOutHouseList)
{
//查找选择的菜单是否已存在
if (!oldPlanTaskOutWarehouse.Any(d => d.plantask_batch_number == planTaskOutWarehouse.plantask_batch_number && d.warehouse_id == planTaskOutWarehouse.warehouse_id && d.vehicle_id == planTaskOutWarehouse.vehicle_id))
{
_unitOfWork.AddAction(planTaskOutWarehouse, DataActions.Add);
}
}
}
else
{
foreach (PlanTaskOutWarehouse planTaskOutWarehouse in plantaskOutHouseList)
{
_unitOfWork.AddAction(planTaskOutWarehouse, DataActions.Add);
}
}
//查找之前选择的菜单是否已删除
if (oldPlanTaskOutWarehouse != null)
{
//原有单头所含明细不为空，则需要判断是否有删除项
foreach (PlanTaskOutWarehouse planTaskOutWarehouseRemove in oldPlanTaskOutWarehouse.Where(x => !plantaskOutHouseList.Any(u => u.warehouse_id == x.warehouse_id && u.plantask_batch_number == x.plantask_batch_number && u.vehicle_id == x.vehicle_id)).ToList())
{
_unitOfWork.AddAction(planTaskOutWarehouseRemove, DataActions.Delete);
}
}
}
public async Task AddCommentToPlanTask_ShouldReturnFalseBecauseNoPlanTask()
{
int planTaskId = 3;
int creatorID = 1;
string creatorFullName = "Full Name";
var comment = new CommentDTO(3, "test text", creatorID, creatorFullName, DateTime.Now, null);
PlanTask planTask = null;
var creator = new User {
Id = creatorID
};
uowMock
.Setup(u => u.PlanTasks.Get(It.IsAny <int>()))
.ReturnsAsync(planTask);
uowMock
.Setup(u => u.Users.GetAsync(It.IsAny <int>()))
.ReturnsAsync(creator);
uowMock
.Setup(u => u.Comments.AddAsync(It.IsAny <Comment>()))
.Callback <Comment>(c => planTask.Comments.Add(new Comment
{
Id = c.Id
}));
var result = await commentService.AddCommentToPlanTaskAsync(planTaskId, comment);
Assert.IsFalse(result);
}
public TaskDTO GetTaskForPlan(int planTaskId)
{
PlanTask planTask = db.PlanTasks.Get(planTaskId);
if (planTask == null)
{
throw new InternalServiceException($"PlanTask with ID:{planTask.Id} does not exist.", "");
}
Task task = planTask.Tasks;
var taskDTO = new TaskDTO(task.Id,
task.Name,
task.Description,
task.Private,
task.Create_Id,
db.Users.ExtractFullName(task.Create_Id),
task.Mod_Id,
db.Users.ExtractFullName(task.Mod_Id),
task.Create_Date,
task.Mod_Date,
planTask.Priority,
planTask.Section_Id,
planTask.Id);
return(taskDTO);
}
public async Task <IActionResult> Edit(int id, PlanTaskViewModel view)
{
if (id != view.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
PlanTask planTask = this.ToPlanTask(view);
context.Update(planTask);
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlanTaskExists(view.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Details), new { id }));
}
FillData(ref view);
return(View(view));
}
public async Task GetCommentsForPlanTask_ShouldReturnComments()
{
int planTaskId = 3;
var planTask = new PlanTask
{
Id = planTaskId,
Comments = new Comment[]
{
new Comment {
Id = 0, Text = "Comment 1"
},
new Comment {
Id = 1, Text = "Comment 2"
}
}
};
uowMock
.Setup(u => u.PlanTasks.Get(It.IsAny <int>()))
.ReturnsAsync(planTask);
uowMock
.Setup(u => u.Users.ExtractFullNameAsync(It.IsAny <int>()))
.ReturnsAsync("Creator Full Name");
var result = await commentService.GetCommentsForPlanTaskAsync(planTaskId);
Assert.AreEqual(2, result.ToList().Count);
for (int i = 0; i < planTask.Comments.Count; i++)
{
Assert.AreEqual(planTask.Comments.ToList()[i].Id, result.ToList()[i].Id);
Assert.AreEqual(planTask.Comments.ToList()[i].Text, result.ToList()[i].Text);
}
}
private void DoPlanTask(ref PlanTask plantask, ref PlanTaskBatch plantaskbatch)
{
string plantaskNumber = plantask.plantask_number;
//更新计划编辑
plantask.real_start_time = _sPGetSysDateTimeService.GetSysDateTime();
if (plantaskbatch.need_bor.HasValue && plantaskbatch.need_bor.Value == true)
{
plantask.plan_status = (int)PlanTaskStatus.达;
}
else
{
plantask.plan_status = (int)PlanTaskStatus.执行;
}
//更新计划批次
plantaskbatch.batch_start_time = _sPGetSysDateTimeService.GetSysDateTime();
//更新报港单状态
if (plantask.PlanTaskType.warehouse_control_mode != (int)WarehouseControlMode.出入仓)
{
plantask.Enrolment.status = (int)EnrolmentStatue.执行中;
_unitOfWork.AddAction(plantask.Enrolment, DataActions.Update);
}
PlanTaskStepStatu getplanstep = plantask.PlanTaskStepStatus.Single(d => d.step_code == "作业计划执行" && d.plantask_number == plantaskNumber);
if (getplanstep.operate_time == null)
{
getplanstep.operate_time = _sPGetSysDateTimeService.GetSysDateTime();
getplanstep.status = true;
_unitOfWork.AddAction(getplanstep, DataActions.Update);
}
}
public void SetTaskForToday(int Id, bool setForToday)
{
PlanTask task = DAL_Get(Id);
task.SelectedForToday = setForToday;
_context.SaveChanges();
}
private PlanTask FindNearestTargetParent(PlanTask forTask)
{
if (forTask.Parent != null)
{
return(FindNearestParentRecursive(forTask.Parent));
}
throw new Exception("Цель не найдена!!!");
}
public void UpdatePlanTask(PlanTask plantask, List <PlanTaskInWarehouse> plantaskInHouseList, List <PlanTaskOutWarehouse> plantaskoutHouseList, List <PlanTaskBatchSiteScale> planSiteList, List <PlanTaskBatchVehicle> planvehicleList, List <PlanTaskBatchWorkPlace> workplaceList, string OrgDepCode, bool isRun)
{
try
{
PlanTaskBatch planTaskBatch = plantask.PlanTaskBatches.LastOrDefault();
//更新出入库仓房
if (plantaskInHouseList != null && plantaskInHouseList.Count > 0)
{
SetPlanTaskInWarehouse(plantask, plantaskInHouseList);
}
if (plantaskoutHouseList != null && plantaskoutHouseList.Count > 0)
{
SetPlanTaskOutWarehouse(plantask, plantaskoutHouseList);
}
//磅点信息
if (planSiteList != null && planSiteList.Count > 0)
{
_planScaleService.UpPlanTaskBatchSiteScale(plantask.PlanTaskBatches.LastOrDefault(), planSiteList);
}
//码头加卸粮坑
if (workplaceList != null && workplaceList.Count > 0)
{
_planWorkPlaceService.UpdatePlanTaskBatchWorkPlace(plantask.PlanTaskBatches.LastOrDefault(), workplaceList);
}
PlanTaskStepStatu getplanstep = plantask.PlanTaskStepStatus.Single(d => d.step_code == "作业计划编制" && d.plantask_number == plantask.plantask_number);
if (getplanstep.operate_time == null)
{
getplanstep.operate_time = _sPGetSysDateTimeService.GetSysDateTime();
getplanstep.status = true;
_unitOfWork.AddAction(getplanstep, DataActions.Update);
}
if (isRun)
{
DoPlanTask(ref plantask, ref planTaskBatch);
}
//内部车辆信息，必须放在计划可能执行之后，否则不能拿到计划执行状态，就无法更新车辆在线状态
if (planvehicleList != null && planvehicleList.Count > 0)
{
_planVehicleService.UpdatePlanTaskBatchVehicle(plantask.PlanTaskBatches.LastOrDefault(), planvehicleList);
}
_unitOfWork.AddAction(planTaskBatch, DataActions.Update);
_unitOfWork.AddAction(plantask, DataActions.Update);
_unitOfWork.Save();
}
catch (RepositoryException ex)
{
throw ex;
}
}
private void GetAllChilds(PlanTask task, List <PlanTask> total)
{
var children = _context.TasksAndTargets.Include(x => x.Parent).Where(x => x.Parent != null && x.Parent.Id == task.Id).ToList();
total.AddRange(children);
foreach (var child in children)
{
GetAllChilds(child, total);
}
}
public void GetAllParentsRecursive(PlanTask planTask, List <PlanTask> totalList)
{
if (planTask.Parent != null)
{
if (!totalList.Contains(planTask.Parent))
{
totalList.Add(planTask.Parent);
}
GetAllParentsRecursive(planTask.Parent, totalList);
}
}
private PlanTask FindNearestParentRecursive(PlanTask forTask)
{
if (!forTask.IsTask)
{
return(forTask);
}
if (forTask.Parent != null)
{
return(FindNearestParentRecursive(forTask.Parent));
}
return(null);
}
public void AddPlantaskInWarehouse(PlanTask plantask, List <PlanTaskInWarehouse> plantaskInHouseList, List <PlanTaskBatchSiteScale> planSiteList, List <PlanTaskBatchVehicle> planvehicleList, List <PlanTaskBatchWorkPlace> planworkplaceList, string OrgDepCode, bool needQuality)
{
//PlanTaskInWarehouse rtplabinhouse = null;
try
{
PlanTaskBatch planTaskBatch = plantask.PlanTaskBatches.LastOrDefault();
planTaskBatch.need_quality_test = needQuality;
SetPlanTaskInWarehouse(plantask, plantaskInHouseList);
//磅点信息
if (planSiteList != null)
{
if (planSiteList.Count > 0)
{
_planScaleService.AddPlanTaskBatchSiteScale(plantask.PlanTaskBatches.LastOrDefault(), planSiteList);
}
}
//内部车辆信息
if (planvehicleList != null)
{
if (planvehicleList.Count > 0)
{
_planVehicleService.AddPlanTaskBatchVehicle(plantask.PlanTaskBatches.LastOrDefault(), planvehicleList);
for (int i = 0; i < planvehicleList.Count; i++)
{
planvehicleList[i].InnerVehicle.inner_vehicle_online = true;
_innervehicle.Update(planvehicleList[i].InnerVehicle);
}
}
}
//码头加卸粮坑
if (planworkplaceList != null)
{
if (planworkplaceList.Count > 0)
{
_planWorkPlaceService.AddPlanTaskBatchWorkPlace(plantask.PlanTaskBatches.LastOrDefault(), planworkplaceList);
}
}
_unitOfWork.AddAction(planTaskBatch, DataActions.Update);
_planTaskDal.Update(plantask);
_unitOfWork.Save();
}
catch (RepositoryException ex)
{
throw ex;
}
}
public void AddPlanTaskOutWarehouse(PlanTask plantask, List <PlanTaskOutWarehouse> plantaskoutHouseList, List <PlanTaskBatchSiteScale> planSiteList, List <PlanTaskBatchVehicle> planvehicleList, List <PlanTaskBatchWorkPlace> planworkplaceList, string OrgDepCode)
{
//PlanTaskOutWarehouse rtnplanouthouse = null;
try
{
SetPlanTaskOutWarehouse(plantask, plantaskoutHouseList);
//磅点信息
if (planSiteList != null)
{
if (planSiteList.Count > 0)
{
_planScaleService.AddPlanTaskBatchSiteScale(plantask.PlanTaskBatches.LastOrDefault(), planSiteList);
}
}
//内部车辆信息
if (planvehicleList != null)
{
if (planvehicleList.Count > 0)
{
_planVehicleService.AddPlanTaskBatchVehicle(plantask.PlanTaskBatches.LastOrDefault(), planvehicleList);
for (int i = 0; i < planvehicleList.Count; i++)
{
planvehicleList[i].InnerVehicle.inner_vehicle_online = true;
_innervehicle.Update(planvehicleList[i].InnerVehicle);
}
}
}
//码头加卸粮坑
if (planworkplaceList != null)
{
if (planworkplaceList.Count > 0)
{
_planWorkPlaceService.AddPlanTaskBatchWorkPlace(plantask.PlanTaskBatches.LastOrDefault(), planworkplaceList);
}
}
_planTaskDal.Update(plantask);
_unitOfWork.Save();
}
catch (RepositoryException ex)
{
throw ex;
}
//return rtnplanouthouse;
}
public async Task GetCommentsForPlanTask_ShouldReturnNullBecausePlanTaskIsNull()
{
int planTaskId = 3;
PlanTask planTask = null;
uowMock
.Setup(u => u.PlanTasks.Get(It.IsAny <int>()))
.ReturnsAsync(planTask);
uowMock
.Setup(u => u.Users.ExtractFullNameAsync(It.IsAny <int>()))
.ReturnsAsync("Creator Full Name");
var result = await commentService.GetCommentsForPlanTaskAsync(planTaskId);
Assert.IsNull(result);
}
private PlanTask LoadAllParentsRecursive(PlanTask task)
{
var _task = _context.TasksAndTargets.Include(q => q.Creator).Include(z => z.AccessRights).ThenInclude(z => z.User)
.Include(y => y.Parent).
ThenInclude(q => q.AccessRights).ThenInclude(q => q.User)
.FirstOrDefault(x => x.Id == task.Id);
_userService.SetPasswordHashAndSaltUnModified(_task.Creator);
if (_task.Parent != null)
{
_task.Parent = LoadAllParentsRecursive(task.Parent);
}
return(_task);
}
public async Task <IActionResult> Create(PlanTaskViewModel view)
{
if (ModelState.IsValid)
{
PlanTask planTask = this.ToPlanTask(view);
planTask.ID = 0;
context.Add(planTask);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { planTask.ID }));
}
FillData(ref view);
return(View(view));
}
private PlanTaskDto GetSharedTasksForTask(TaskFilter filter, PlanTask task)
{
var currentUserId = _userService.GetCurrentUser().Id;
if (task.AccessRights.Where(x => x.User != null).Count(x => x.User.Id == currentUserId) > 0)
{
List <PlanTask> total = new List <PlanTask>();
GetAllChilds(task, total);
var totalDto = total.DistinctBy(x => x.Id).Select(x => x.ToDto()).ToList();
totalDto.Add(task.ToDto());
SetChildren(totalDto, totalDto);
return(totalDto.FirstOrDefault(x => x.Id == filter.TaskId.Value));
}
else
{
throw new Exception("Access denined!");
}
}
public async Task GetCommentsForPlanTask_ShouldReturnEmptyCollectionBecauseNoComments()
{
int planTaskId = 3;
var planTask = new PlanTask
{
Id = planTaskId
};
uowMock
.Setup(u => u.PlanTasks.Get(It.IsAny <int>()))
.ReturnsAsync(planTask);
uowMock
.Setup(u => u.Users.ExtractFullNameAsync(It.IsAny <int>()))
.ReturnsAsync("Creator Full Name");
var result = await commentService.GetCommentsForPlanTaskAsync(planTaskId);
Assert.AreEqual(0, result.ToList().Count);
}
public void LogUserActivity(PlanTask entity,
DAL.enums.ActionTypeEnum actionType, bool onCreate = false)
{
ActivityAction activityAction = new ActivityAction();
activityAction.ForTask = entity;
if (entity.IsTask)
{
activityAction.ForTarget = FindNearestTargetParent(activityAction.ForTask);
}
else
{
activityAction.ForTarget = entity;
}
_context.Entry(activityAction.ForTarget.Creator).State = EntityState.Unchanged;
activityAction.ActionObjectType = DAL.enums.ActionObjectTypeEnum.task;
activityAction.ActionType = actionType;
activityAction.ByUser = _userService.GetCurrentUser();
activityAction.ActivityDate = DateTime.UtcNow;
checkOnCreateBase(onCreate, activityAction);
if (entity.Status == DAL.enums.TaskStatus.Complete)
{
if (entity.IsTask)
{
activityAction.ActionType = DAL.enums.ActionTypeEnum.CompletedTask;
}
else
{
activityAction.ActionType = DAL.enums.ActionTypeEnum.CompletedTarget;
}
}
_context.ActivityActions.Add(activityAction);
_context.SaveChanges();
}
public PlanTaskBatch AddPlanTaskBatchWithCreate(PlanTask plantask, PlanTaskBatch newPlanTaskBatch)
{
try
{
//设置是否需要工艺路线，工艺路线上是否有计量，创建时间，是否值仓，是否需要内部车辆，是否经过作业点
//复制计划编号
//计划批次编号为计划编号+流水号，默认为第一流水号，补足三位
newPlanTaskBatch.create_time = plantask.create_time.Value;
newPlanTaskBatch.plantask_batch_number = plantask.plantask_number + string.Format("{0:D3}", 1);
newPlanTaskBatch.plantask_number = plantask.plantask_number;
newPlanTaskBatch.is_settlemented = false;
_unitOfWork.AddAction(newPlanTaskBatch, DAL.Enums.DataActions.Add);
}
catch (RepositoryException ex)
{
throw ex;
}
return(newPlanTaskBatch);
}
public bool AddTaskToPlan(int planId, int taskId, int?sectionId, int?priority)
{
var taskAdd = Context.Tasks.FirstOrDefault(task => task.Id == taskId);
var planAdd = Context.Plans.FirstOrDefault(plan => plan.Id == planId);
var section = sectionId != null?Context.Sections.FirstOrDefault(s => s.Id == sectionId) : Context.Sections.First();
if (taskAdd == null || planAdd == null)
{
return(false);
}
PlanTask toInsert = new PlanTask()
{
Plan_Id = planId,
Task_Id = taskId,
Priority = priority,
Section_Id = section?.Id
};
Context.PlanTasks.Add(toInsert);
return(true);
}
/// <summary>
/// 根据计划创建计划批次
/// 一般用于计划第一次创建的时候
/// </summary>
/// <param name="planTask">传入的计划</param>
/// <returns></returns>
public PlanTaskBatch AddPlanTaskBatchWithPlanTask(PlanTask planTask, PlanTaskType planTaskType)
{
PlanTaskBatch newPlanTaskBatch = null;
try
{
//设置是否需要工艺路线，工艺路线上是否有计量，创建时间，是否值仓，是否需要内部车辆，是否经过作业点
//复制计划编号
//计划批次编号为计划编号+流水号，默认为第一流水号，补足三位
newPlanTaskBatch = new PlanTaskBatch();
newPlanTaskBatch.bor_weight = planTaskType.bor_weight;
newPlanTaskBatch.create_time = planTask.create_time.Value;
newPlanTaskBatch.need_bor = planTaskType.need_bor;
newPlanTaskBatch.need_onduty = planTaskType.need_onduty;
newPlanTaskBatch.need_vehicle = planTaskType.need_vehicle;
newPlanTaskBatch.need_workplace = planTaskType.need_workplace;
newPlanTaskBatch.plantask_batch_number = planTask.plantask_number + string.Format("{0:D3}", planTask.PlanTaskBatches.Count + 1);
newPlanTaskBatch.plantask_number = planTask.plantask_number;
if (planTask.Enrolment != null)
{
newPlanTaskBatch.need_quality_test = planTask.Enrolment.EnrolmentType.need_quality_test;
}
else
{
newPlanTaskBatch.need_quality_test = false;
}
if (planTask != null && planTask.unit_price != null)
{
newPlanTaskBatch.unit_price = planTask.unit_price;
}
newPlanTaskBatch.is_settlemented = false;
_unitOfWork.AddAction(newPlanTaskBatch, DAL.Enums.DataActions.Add);
}
catch (RepositoryException ex)
{
throw ex;
}
return(newPlanTaskBatch);
}
private PlanTaskViewModel ToPlanTaskViewModel(PlanTask planTask)
{
var model = new PlanTaskViewModel()
{
ID = planTask.ID,
Name = planTask.Name,
Description = planTask.Description,
Priority = planTask.Priority,
Status = planTask.Status,
StartDate = planTask.StartDate,
EndDate = planTask.EndDate,
ResponsableID = planTask.ResponsableID,
Users = combosHelper.GetComboUsers(),
Plan = planTask.Plan,
PlanID = planTask.PlanID
};
return(model);
}
public void AddOrUpdate(CommentDto commentDto)
{
// TODO RIGHTS CHECK ON ADD
Comment entity = null;
if (commentDto.Id > 0)
{
entity = GetEntityById(commentDto.Id);
entity.Edited = true;
}
else
{
entity = new Comment();
entity.Author = _userService.GetCurrentUser();
entity.CreatedDate = DateTime.Now.ToUniversalTime();
}
PlanTask parentTask = _taskService.GetEntityById(commentDto.ToTaskOrTarget.Id);
entity.Text = commentDto.Text;
entity.ToTaskOrTarget = parentTask;
_context.Entry(entity.ToTaskOrTarget.Creator).State = EntityState.Unchanged;
bool onCreate = false;
if (entity.Id == 0)
{
_context.Comments.Add(entity);
onCreate = true;
}
_context.SaveChanges();
_activityService.LogUserActivity(entity, DAL.enums.ActionTypeEnum.Added, onCreate);
}
private async Task OnCreateTaskDialogResume(IDialogContext context,
IAwaitable <string> result)
{
// Get data needed to create a new task.
var text = await result;
var user = context.ConversationData.Get <User>("Me");
var plan = context.ConversationData.Get <Plan>("Plan");
var bucket = context.ConversationData.Get <Bucket>("Bucket");
// Create the task data.
var task = new PlanTask
{
AssignedTo = user.id,
PlanId = plan.Id,
BucketId = bucket.Id,
Title = text
};
var httpClient = new HttpClient();
var accessToken = await context.GetAccessToken();
// Create the task.
await context.PostAsync("Creating task...");
var response = await httpClient.MSGraphPOST(accessToken,
"https://graph.microsoft.com/beta/tasks", task);
await context.PostAsync(response? "Task created!" : "Creation failed!");
// Clear data.
context.ConversationData.RemoveValue("Plan");
context.ConversationData.RemoveValue("Bucket");
// Show operations.
await ShowOperationsAsync(context);
}
public void UpdAssayPlanTaskInUnitOfWork(Assay oldAssay, PlanTask oldPlanTask, PlanTaskBatch oldPlanTaskBatch)
{
_unitOfWork.AddAction(oldAssay, DataActions.Update);
_unitOfWork.AddAction(oldPlanTask, DataActions.Update);
_unitOfWork.AddAction(oldPlanTaskBatch, DataActions.Update);
}
public void AddOrUpdate(PlanTaskDto taskForEdit)
{
//_context.ChangeTracker.LazyLoadingEnabled = false;
//_context.ChangeTracker.AutoDetectChangesEnabled = false;
if (taskForEdit == null)
{
throw new Exception("PlanTaskDto NULL");
}
var entity = _context.TasksAndTargets.Include(x => x.Creator).
FirstOrDefault(x => x.Id == taskForEdit.Id);
if (entity == null)
{
entity = new PlanTask();
}
if (taskForEdit.makeReminder.HasValue)
{
if (taskForEdit.makeReminder.Value)
{
entity.RemindAt = taskForEdit.RemindAt.ToUtc();
}
else
{
entity.RemindAt = null;
}
}
entity.IsTask = taskForEdit.IsTask;
if (taskForEdit.ParentTaskId.HasValue)
{
var parentEntity = _context.TasksAndTargets.
FirstOrDefault(x => x.Id == taskForEdit.ParentTaskId.Value);
if (parentEntity != null)
{
entity.Parent = parentEntity;
}
}
entity.SelectedForToday = taskForEdit.SelectedForToday;
entity.Status = taskForEdit.Status;
entity.Title = taskForEdit.Title;
entity.Description = taskForEdit.Description;
// Date changed - reset status
if (entity.PlannedBeginDate != taskForEdit.PlannedBeginDate.ToUtc())
{
entity.PlannedDateProcessed = taskForEdit.PlannedDateProcessed = false;
}
entity.PlannedBeginDate = taskForEdit.PlannedBeginDate.ToUtc();
entity.PlannedDateProcessed = taskForEdit.PlannedDateProcessed;
entity.Deadline = taskForEdit.Deadline.ToUtc();
entity.CompleteDate = taskForEdit.CompleteDate.ToUtc();
if (entity.Id == 0)
{
entity.CreatedDate = DateTime.Now.ToUniversalTime();
}
// TODO set real creator
if (entity.Id == 0)
{
DAL.Users.User creator = _userService.GetCurrentUser();
entity.Creator = creator ?? throw new Exception("Creator user id null");
}
_userService.SetPasswordHashAndSaltUnModified(entity.Creator);
_context.Entry(entity.Creator).State = EntityState.Unchanged;
bool taskOrTargetCreated = false;
if (entity.Id == 0)
{
taskOrTargetCreated = true;
_context.TasksAndTargets.Add(entity);
}
_context.SaveChanges();
_activityService.LogUserActivity(entity,
taskOrTargetCreated ? DAL.enums.ActionTypeEnum.Added : DAL.enums.ActionTypeEnum.Edited);
taskForEdit.Id = entity.Id;
}
