public async Task OnCommandClicked(CommandClickEventArgs <WorkingLogDetailAdapterModel> args)
        {
            WorkingLogDetailAdapterModel item = args.RowData as WorkingLogDetailAdapterModel;

            if (args.CommandColumn.ButtonOption.IconCss == ButtonIdHelper.ButtonIdEdit)
            {
                CurrentRecord         = item.Clone();
                EditRecordDialogTitle = "修改紀錄";
                IsShowEditRecord      = true;
                isNewRecordMode       = false;
            }
            else if (args.CommandColumn.ButtonOption.IconCss == ButtonIdHelper.ButtonIdDelete)
            {
                CurrentNeedDeleteRecord = item;

                #region 檢查關聯資料是否存在
                var checkedResult = await CurrentService
                                    .BeforeDeleteCheckAsync(CurrentNeedDeleteRecord);

                await Task.Delay(100);

                if (checkedResult.Success == false)
                {
                    MessageBox.Show("400px", "200px", "警告",
                                    ErrorMessageMappingHelper.Instance.GetErrorMessage(checkedResult.MessageId));
                    await Task.Yield();

                    thisRazorComponent.NeedRefresh();
                    return;
                }
                #endregion

                ConfirmMessageBox.Show("400px", "200px", "警告", "確認要刪除這筆紀錄嗎?");
            }
        }
        public async Task <VerifyRecordResult> UpdateAsync(WorkingLogDetailAdapterModel paraObject)
        {
            WorkingLogDetail itemData = Mapper.Map <WorkingLogDetail>(paraObject);

            CleanTrackingHelper.Clean <WorkingLogDetail>(context);
            WorkingLogDetail item = await context.WorkingLogDetail
                                    .AsNoTracking()
                                    .FirstOrDefaultAsync(x => x.Id == paraObject.Id);

            if (item == null)
            {
                return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.無法修改紀錄));
            }
            else
            {
                CleanTrackingHelper.Clean <WorkingLogDetail>(context);
                context.Entry(itemData).State = EntityState.Modified;
                await context.SaveChangesAsync();

                var id = itemData.WorkingLogId;
                CleanTrackingHelper.Clean <WorkingLogDetail>(context);
                await CountingWorkingHour(id);

                return(VerifyRecordResultFactory.Build(true));
            }
        }
        public async Task <WorkingLogDetailAdapterModel> GetAsync(int id)
        {
            WorkingLogDetail item = await context.WorkingLogDetail
                                    .AsNoTracking()
                                    .Include(x => x.Project)
                                    .FirstOrDefaultAsync(x => x.Id == id);

            WorkingLogDetailAdapterModel result = Mapper.Map <WorkingLogDetailAdapterModel>(item);

            await OhterDependencyData(result); return(result);
        }
        public async Task <IActionResult> Put([FromRoute] int id, [FromBody] WorkingLogDetailDto data)
        {
            APIResult apiResult;

            #region 驗證 DTO 物件的資料一致性
            if (!ModelState.IsValid)
            {
                apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                   ErrorMessageEnum.傳送過來的資料有問題, payload: data);
                return(Ok(apiResult));
            }
            #endregion

            var record = await WorkingLogDetailService.GetAsync(id);

            if (record != null)
            {
                WorkingLogDetailAdapterModel recordTarget = mapper.Map <WorkingLogDetailAdapterModel>(data);
                recordTarget.Id = id;
                var result = mapper.Map <WorkingLogDetailDto>(recordTarget);

                #region 修改記錄前的紀錄完整性檢查
                VerifyRecordResult verify = await WorkingLogDetailService.BeforeUpdateCheckAsync(record);

                if (verify.Success == false)
                {
                    apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                       ErrorMessageMappingHelper.Instance.GetErrorMessage(verify.MessageId),
                                                       payload: result);
                    return(Ok(apiResult));
                }
                #endregion

                var verifyRecordResult = await WorkingLogDetailService.UpdateAsync(recordTarget);

                if (verifyRecordResult.Success)
                {
                    apiResult = APIResultFactory.Build(true, StatusCodes.Status202Accepted,
                                                       ErrorMessageEnum.None, payload: null);
                }
                else
                {
                    apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                       ErrorMessageEnum.無法修改紀錄, payload: result);
                }
            }
            else
            {
                apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                   ErrorMessageEnum.沒有任何符合資料存在, payload: data);
            }
            return(Ok(apiResult));
        }
        public async Task <IActionResult> Post([FromBody] WorkingLogDetailDto data)
        {
            APIResult apiResult;

            #region 驗證 DTO 物件的資料一致性
            if (!ModelState.IsValid)
            {
                apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                   ErrorMessageEnum.傳送過來的資料有問題, payload: null);
                return(Ok(apiResult));
            }
            #endregion

            WorkingLogDetailAdapterModel record = mapper.Map <WorkingLogDetailAdapterModel>(data);
            if (record != null)
            {
                var result = mapper.Map <WorkingLogDetailDto>(record);

                #region 新增記錄前的紀錄完整性檢查
                VerifyRecordResult verify = await WorkingLogDetailService.BeforeAddCheckAsync(record);

                if (verify.Success == false)
                {
                    apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                       ErrorMessageMappingHelper.Instance.GetErrorMessage(verify.MessageId),
                                                       payload: result);
                    return(Ok(apiResult));
                }
                #endregion

                var verifyRecordResult = await WorkingLogDetailService.AddAsync(record);

                if (verifyRecordResult.Success)
                {
                    apiResult = APIResultFactory.Build(true, StatusCodes.Status201Created,
                                                       ErrorMessageEnum.None, payload: result);
                }
                else
                {
                    apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                       ErrorMessageEnum.無法新增紀錄, payload: result);
                }
            }
            else
            {
                apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
                                                   ErrorMessageEnum.傳送過來的資料有問題, payload: data);
            }
            return(Ok(apiResult));
        }
        public async Task <VerifyRecordResult> AddAsync(WorkingLogDetailAdapterModel paraObject)
        {
            WorkingLogDetail itemParameter = Mapper.Map <WorkingLogDetail>(paraObject);

            CleanTrackingHelper.Clean <WorkingLogDetail>(context);
            await context.WorkingLogDetail
            .AddAsync(itemParameter);

            await context.SaveChangesAsync();

            var id = itemParameter.WorkingLogId;

            CleanTrackingHelper.Clean <WorkingLogDetail>(context);
            await CountingWorkingHour(id);

            return(VerifyRecordResultFactory.Build(true));
        }
 public void ToolbarClickHandler(Syncfusion.Blazor.Navigations.ClickEventArgs args)
 {
     if (args.Item.Id == ButtonIdHelper.ButtonIdAdd)
     {
         CurrentRecord = new WorkingLogDetailAdapterModel();
         #region 針對新增的紀錄所要做的初始值設定商業邏輯
         #endregion
         EditRecordDialogTitle      = "新增紀錄";
         isNewRecordMode            = true;
         IsShowEditRecord           = true;
         CurrentRecord.WorkingLogId = Header.Id;
         //CurrentRecord.Name = Header.Title;
     }
     else if (args.Item.Id == ButtonIdHelper.ButtonIdRefresh)
     {
         dataGrid.RefreshGrid();
     }
 }
        public async Task <VerifyRecordResult> BeforeAddCheckAsync(WorkingLogDetailAdapterModel paraObject)
        {
            CleanTrackingHelper.Clean <WorkingLogDetail>(context);
            if (paraObject.ProjectId == 0)
            {
                return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.尚未輸入該工作日誌的歸屬專案));
            }
            if (paraObject.Hours <= 0)
            {
                return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.工作時數必須大於0));
            }
            var item = await context.WorkingLogDetail
                       .AsNoTracking()
                       .FirstOrDefaultAsync(x => x.WorkingLogId == paraObject.WorkingLogId &&
                                            x.ProjectId == paraObject.ProjectId);

            if (item != null)
            {
                return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要新增的紀錄已經存在無法新增));
            }
            return(VerifyRecordResultFactory.Build(true));
        }
 Task OhterDependencyData(WorkingLogDetailAdapterModel data)
 {
     data.ProjectName = data.Project.Name;
     return(Task.FromResult(0));
 }
 public Task <VerifyRecordResult> BeforeDeleteCheckAsync(WorkingLogDetailAdapterModel paraObject)
 {
     return(Task.FromResult(VerifyRecordResultFactory.Build(true)));
 }