public void ValidateFromAndTo(ClosedMonthViewModel model)
        {
            if (model.From.Value.Month != model.To.Value.Month)
            {
                throw new GeneralException((int)ErrorCodeEnum.FromMonthAndToMonthAreNotTheSame);
            }

            if (model.From.Value.Day != 1)
            {
                throw new GeneralException((int)ErrorCodeEnum.FromDateMustBeTheFirstDayInMonth);
            }

            if (model.To.Value.IsLastDayInMonth() == false)
            {
                throw new GeneralException((int)ErrorCodeEnum.ToDateMustBeTheLastDayInMonth);
            }

            var latest = this._ClosedMonthsRepository.Get(null)
                         .OrderByDescending(entity => entity.Id)
                         .Where(x => x.ParentKeyClosedMonthId == null)
                         .FirstOrDefault();

            bool exist = false;

            if (latest != null)
            {
                exist = (model.From.Value.Month == latest.Month.Value &&
                         model.From.Value.Year == latest.From.Value.Year);
            }

            if (exist == true)
            {
                throw new GeneralException((int)ErrorCodeEnum.ThisMonthHasBeenAddedBefore);
            }
        }
        /// <summary>
        /// Delete an entity.
        /// </summary>
        /// <param name="model"></param>
        public void Delete(ClosedMonthViewModel model)
        {
            var entity = model.ToEntity();

            this._ClosedMonthsRepository.Delete(entity);

            #region Commit Changes
            this._unitOfWork.Commit();
            #endregion
        }
        /// <summary>
        /// Throw an exception if name is exist.
        /// </summary>
        /// <param name="model">ClosedMonth view model</param>
        public void ThrowExceptionIfExist(ClosedMonthViewModel model)
        {
            //ConditionFilter<ClosedMonth, long> condition = new ConditionFilter<ClosedMonth, long>
            //{
            //    Query = (entity =>
            //        entity.Name == model.Name &&
            //        entity.Id != model.Id)
            //};
            //var existEntity = this._ClosedMonthsRepository.Get(condition).FirstOrDefault();

            //if (existEntity != null)
            //    throw new ItemAlreadyExistException();
        }
        /// <summary>
        /// Add an entity.
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ClosedMonthViewModel Add(ClosedMonthViewModel model)
        {
            //model.To = model.To.SetTimeToMax();
            //this.ThrowExceptionIfExist(model);
            this.ValidateFromAndTo(model);

            var entity = model.ToEntity();

            entity.Month = (byte)model.From.Value.Month;
            entity       = this._ClosedMonthsRepository.Add(entity);

            var entityAr = new ClosedMonth
            {
                Id          = entity.Id,
                Name        = model.NameAr,
                Description = model.DescriptionAr,
                Language    = Language.Arabic
            };

            entity.ChildTranslatedClosedMonths.Add(entityAr);
            this._ClosedMonthsRepository.Add(entityAr);

            var entityEn = new ClosedMonth
            {
                Id          = entity.Id,
                Name        = model.NameEn,
                Description = model.DescriptionEn,
                Language    = Language.English
            };

            entity.ChildTranslatedClosedMonths.Add(entityEn);
            this._ClosedMonthsRepository.Add(entityEn);

            #region Commit Changes
            this._unitOfWork.Commit();
            #endregion

            model = entity.ToModel();
            return(model);
        }
        /// <summary>
        /// Update an entity.
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ClosedMonthViewModel Update(ClosedMonthViewModel model)
        {
            //this.ThrowExceptionIfExist(model);
            //this.ValidateFromAndTo(model);

            // var entity = model.ToEntity();
            var entity = this._ClosedMonthsRepository.Get(model.Id);

            entity.IsClosed = model.IsClosed;
            entity          = this._ClosedMonthsRepository.Update(entity);

            ConditionFilter <ClosedMonth, long> conditionFilter = new ConditionFilter <ClosedMonth, long>()
            {
                Query = (x =>
                         x.ParentKeyClosedMonthId == entity.Id)
            };
            var childs = this._ClosedMonthsRepository.Get(conditionFilter);

            if (childs.Count() > 0)
            {
                var ar = childs.FirstOrDefault(x => x.Language == Language.Arabic);
                ar.Name        = model.NameAr;
                ar.Description = model.DescriptionAr;
                this._ClosedMonthsRepository.Update(ar);

                var en = childs.FirstOrDefault(x => x.Language == Language.English);
                en.Name        = model.NameEn;
                en.Description = model.DescriptionEn;
                this._ClosedMonthsRepository.Update(en);
            }

            #region Commit Changes
            this._unitOfWork.Commit();
            #endregion

            model = entity.ToModel();
            return(model);
        }