private bool ValidateDateTime(ExamPeriod examPeriod)
 {
     if (examPeriod.StartHour < 0 || examPeriod.StartHour >= 24)
     {
         examPeriod.AddError(nameof(ExamPeriodValidator), nameof(examPeriod.StartHour), ERROR.StartHourInvalid);
         return(false);
     }
     if (examPeriod.FinishHour < 0 || examPeriod.FinishHour >= 24)
     {
         examPeriod.AddError(nameof(ExamPeriodValidator), nameof(examPeriod.FinishHour), ERROR.FinishHourInvalid);
         return(false);
     }
     return(true);
 }
        private async Task <bool> ValidateNotExist(ExamPeriod examPeriod)
        {
            ExamPeriodFilter filter = new ExamPeriodFilter
            {
                Take     = Int32.MaxValue,
                ExamDate = new DateTimeFilter {
                    Equal = examPeriod.ExamDate
                },                                                             // Kiểm tra trùng lịch
                StartHour  = examPeriod.StartHour,
                FinishHour = examPeriod.FinishHour,
                TermId     = new GuidFilter {
                    Equal = examPeriod.TermId
                },
                ExamProgramId = new GuidFilter {
                    Equal = examPeriod.ExamProgramId
                }
            };

            int count = await UOW.ExamPeriodRepository.Count(filter);

            if (count > 0)
            {
                examPeriod.AddError(nameof(ExamPeriodValidator), nameof(examPeriod), ERROR.ExamPeriodExisted);
                return(false);
            }
            return(true);
        }
Esempio n. 3
0
        public async Task <ExamPeriod> Delete(ExamPeriod examPeriod)
        {
            if (!await ExamPeriodValidator.Delete(examPeriod))
            {
                return(examPeriod);
            }

            using (UOW.Begin())
            {
                try
                {
                    examPeriod = await UOW.ExamPeriodRepository.Get(examPeriod.Id);

                    await UOW.ExamPeriodRepository.Delete(examPeriod.Id);

                    await UOW.Commit();
                }
                catch (Exception e)
                {
                    await UOW.Rollback();

                    examPeriod.AddError(nameof(ExamPeriodService), nameof(Delete), CommonEnum.ErrorCode.SystemError);
                }
            }
            return(examPeriod);
        }
Esempio n. 4
0
        public async Task <ExamPeriod> Update(ExamPeriod examPeriod)
        {
            if (!await ExamPeriodValidator.Update(examPeriod))
            {
                return(examPeriod);
            }

            using (UOW.Begin())
            {
                try
                {
                    //examPeriod = await GetTermIdExamProgramId(examPeriod);

                    await UOW.ExamPeriodRepository.Update(examPeriod);

                    await UOW.Commit();

                    return(await UOW.ExamPeriodRepository.Get(examPeriod.Id));
                }
                catch (Exception e)
                {
                    await UOW.Rollback();

                    examPeriod.AddError(nameof(ExamPeriodService), nameof(Update), CommonEnum.ErrorCode.SystemError);
                    return(examPeriod);
                }
            }
        }
        /*private async Task<bool> ValidateExist(ExamPeriod examPeriod)
         * {
         *  ExamPeriodFilter filter = new ExamPeriodFilter
         *  {
         *      Take = Int32.MaxValue,
         *      ExamDate = new DateTimeFilter { Equal = examPeriod.ExamDate },
         *      StartHour = examPeriod.StartHour,
         *      FinishHour = examPeriod.FinishHour,
         *      TermId = new GuidFilter { Equal = examPeriod.TermId },
         *      ExamProgramId = new GuidFilter { Equal = examPeriod.ExamProgramId }
         *  };
         *
         *  int count = await UOW.ExamPeriodRepository.Count(filter);
         *  if (count == 0)
         *  {
         *      examPeriod.AddError(nameof(ExamPeriodValidator), nameof(examPeriod), ERROR.NotExisted);
         *      return false;
         *  }
         *  return true;
         * }*/
        private async Task <bool> ValidateId(ExamPeriod ExamPeriod)
        {
            ExamPeriodFilter filter = new ExamPeriodFilter
            {
                Id = new GuidFilter {
                    Equal = ExamPeriod.Id
                }
            };
            int count = await UOW.ExamPeriodRepository.Count(filter);

            if (count == 0)
            {
                ExamPeriod.AddError(nameof(ExamPeriodValidator), nameof(ExamPeriod), ERROR.IdNotFound);
            }

            return(count == 1);
        }