Example #1
0
        public async Task <ServerResponse <bool> > UpdateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest)
        {
            var serverResponse = await _mhTaskService.UpdateMhTaskAsync(mhTaskRequest);

            await _sendEndpointProvider.Send(_mhTaskService.CreateFeedMessage(mhTaskRequest, EFeedAction.Update));

            return(serverResponse);
        }
Example #2
0
        public async Task <ServerResponse <long> > CreateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest)
        {
            var serverResponse = await _mhTaskService.CreateMhTaskAsync(mhTaskRequest);

            mhTaskRequest.Id = serverResponse.Result;
            await _sendEndpointProvider.Send(_mhTaskService.CreateFeedMessage(mhTaskRequest, EFeedAction.Create));

            return(serverResponse);
        }
        public async Task <ServerResponse> CreateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest)
        {
            return(AOResultToServerResponse(await _mhTaskService.CreateMhTaskAsync(mhTaskRequest).ContinueWith(x =>
            {
                var request = _requestClient.Create(_mhTaskService.CreateMhTaskFeedMessage(mhTaskRequest, x.Result.Result));

                request.GetResponse <FeedMessage>();

                return x.Result;
            })));
        }
Example #4
0
        public async Task <ServerResponse <long> > CreateMhTaskAsync(MhTaskRequest mhTaskRequest, MhTask parentMhTask = null)
        {
            return(await BaseInvokeAsync(async() =>
            {
                var mhTask = new MhTask
                {
                    Name = mhTaskRequest.Name,
                    Description = mhTaskRequest.Description,
                    StartDate = mhTaskRequest.StartDate >= DateTime.Now ? mhTaskRequest.StartDate : DateTime.Now,
                    IsRecurring = mhTaskRequest.IsRecurring,
                    VisibleType = mhTaskRequest.VisibleType,
                    AppUserId = mhTaskRequest.AppUserId
                };

                if (parentMhTask != null)
                {
                    mhTask.Parent = parentMhTask;
                }

                await DbContext.MhTasks.AddAsync(mhTask);

                if (mhTaskRequest.IsRecurring)
                {
                    var scheduleMhTask = new ScheduleMhTask
                    {
                        MhTask = mhTask,
                        MaxCount = mhTaskRequest.ScheduleMhTaskViewModel.MaxCount ?? 0,
                        ScheduleMhTaskType = mhTaskRequest.ScheduleMhTaskViewModel.ScheduleMhTaskType
                    };

                    await DbContext.ScheduleMhTasks.AddAsync(scheduleMhTask);
                }

                if (mhTaskRequest.TagIds.Any())
                {
                    var mhTaskTags = mhTaskRequest.TagIds
                                     .Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
                                     .Select(x => new MhTaskTag
                    {
                        MhTask = mhTask,
                        Tag = x
                    });

                    await DbContext.MhTaskTags.AddRangeAsync(mhTaskTags);
                }

                await AddToUpdateMhTask(DbContext, mhTask, Constants.Updates.CreateMhTask);
                await DbContext.SaveChangesAsync();

                return ServerResponseBuilder.Build(mhTask.Id);
            }, mhTaskRequest));
        }
Example #5
0
        public FeedMessage CreateMhTaskFeedMessage(MhTaskRequest noteRequest, long sourceId)
        {
            var mhTaskFeedData = new MhTaskFeedData
            {
                SourceId    = sourceId,
                Name        = noteRequest.Name,
                Description = noteRequest.Description,
                IsReccuring = noteRequest.IsRecurring
            };
            var mhTaskFeedDataJson = JsonConvert.SerializeObject(mhTaskFeedData);

            return(new FeedMessage()
            {
                AppUserId = noteRequest.AppUserId,
                CreateDate = DateTime.Now,
                FeedType = EFeedType.CreateMhTask,
                FeedData = mhTaskFeedDataJson
            });
        }
Example #6
0
        public async Task <ServerResponse <bool> > UpdateMhTaskAsync(MhTaskRequest mhTaskRequest)
        {
            return(await BaseInvokeAsync(async() =>
            {
                MhTask mhTask;

                if (mhTaskRequest.IsRecurring)
                {
                    mhTask = await DbContext.MhTasks.Include(x => x.ScheduleMhTask)
                             .FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
                }
                else
                {
                    mhTask = await DbContext.MhTasks
                             .AsQueryable()
                             .FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
                }

                if (mhTask == null)
                {
                    throw new NotFoundException(Constants.Errors.TaskNotExists);
                }

                if (mhTask.MhTaskState == EMhTaskState.ReSchedule)
                {
                    throw new ConflictException(Constants.Errors.TaskReSheduleCannotBeUpdated);
                }

                mhTask.Name = mhTaskRequest.Name;
                mhTask.Description = mhTaskRequest.Description;
                mhTask.StartDate = mhTaskRequest.StartDate;
                mhTask.IsRecurring = mhTaskRequest.IsRecurring;
                mhTask.VisibleType = mhTaskRequest.VisibleType;

                if (mhTaskRequest.IsRecurring)
                {
                    if (mhTask.ScheduleMhTask == null)
                    {
                        mhTask.ScheduleMhTask = new ScheduleMhTask();
                    }

                    mhTask.ScheduleMhTask.MaxCount = mhTaskRequest.ScheduleMhTaskViewModel.MaxCount ?? 0;
                    mhTask.ScheduleMhTask.ScheduleMhTaskType = mhTaskRequest.ScheduleMhTaskViewModel.ScheduleMhTaskType;
                }

                DbContext.MhTasks.Update(mhTask);

                var mhTaskTags = await DbContext.MhTaskTags
                                 .AsQueryable()
                                 .Where(x => x.MhTaskId == mhTask.Id).ToListAsync();
                DbContext.MhTaskTags.RemoveRange(mhTaskTags.Where(x => !mhTaskRequest.TagIds.Contains(x.TagId)));

                await DbContext.MhTaskTags.AddRangeAsync(
                    mhTaskRequest.TagIds
                    .Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
                    .Where(x => !mhTaskTags.Select(y => y.TagId).Contains(x.Id))
                    .Select(x => new MhTaskTag {
                    Tag = x, MhTask = mhTask
                }));

                await AddToUpdateMhTask(DbContext, mhTask, Constants.Updates.UpdateEntireMhTask);
                await DbContext.SaveChangesAsync();

                return ServerResponseBuilder.Build(true);
            }, mhTaskRequest));
        }
Example #7
0
        public async Task <AOResult> UpdateMhTaskAsync(MhTaskRequest mhTaskRequest)
        {
            return(await BaseInvokeAsync(async() =>
            {
                MhTask mhTask;

                if (mhTaskRequest.IsRecurring)
                {
                    mhTask = await _myHelperDbContext.MhTasks.Include(x => x.ScheduleMhTask)
                             .FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
                }
                else
                {
                    mhTask = await _myHelperDbContext.MhTasks.FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
                }

                if (mhTask == null)
                {
                    return AOBuilder.SetError(Constants.Errors.TaskNotExists);
                }

                if (mhTask.MhTaskState == EMhTaskState.ReSchedule)
                {
                    return AOBuilder.SetError(Constants.Errors.TaskReShedule);
                }

                mhTask.Name = mhTaskRequest.Name;
                mhTask.Description = mhTaskRequest.Description;
                mhTask.StartDate = mhTaskRequest.StartDate;
                mhTask.IsRecurring = mhTaskRequest.IsRecurring;
                mhTask.MhTaskVisibleType = mhTaskRequest.MhTaskVisibleType;

                if (mhTaskRequest.IsRecurring)
                {
                    if (mhTask.ScheduleMhTask == null)
                    {
                        mhTask.ScheduleMhTask = new ScheduleMhTask();
                    }

                    mhTask.ScheduleMhTask.MaxCount = mhTaskRequest.ScheduleMhTaskViewModel.MaxCount ?? 0;
                    mhTask.ScheduleMhTask.ScheduleMhTaskType = mhTaskRequest.ScheduleMhTaskViewModel.ScheduleMhTaskType;
                }

                _myHelperDbContext.MhTasks.Update(mhTask);

                var mhTaskTags = await _myHelperDbContext.MhTaskTags.Where(x => x.MhTaskId == mhTask.Id).ToListAsync();
                _myHelperDbContext.MhTaskTags.RemoveRange(mhTaskTags.Where(x => !mhTaskRequest.TagIds.Contains(x.TagId)));

                await _myHelperDbContext.MhTaskTags.AddRangeAsync(
                    mhTaskRequest.TagIds
                    .Join(_myHelperDbContext.Tags, o => o, i => i.Id, (o, i) => i)
                    .Where(x => !mhTaskTags.Select(y => y.TagId).Contains(x.Id))
                    .Select(x => new MhTaskTag {
                    Tag = x, MhTask = mhTask
                }));

                await AddToUpdateMhTask(_myHelperDbContext, mhTask, Constants.Updates.UpdateEntireMhTask);
                await _myHelperDbContext.SaveChangesAsync();

                return AOBuilder.SetSuccess();
            }, mhTaskRequest));
        }
 public async Task <ServerResponse> UpdateMhTaskAsync([FromBody] MhTaskRequest mhTaskRequest)
 {
     return(AOResultToServerResponse(await _mhTaskService.UpdateMhTaskAsync(mhTaskRequest)));
 }