//Update ImageFileType (async)
        public async Task <ImageFileTypeDTO> UpdateImageFileTypeAsync(ImageFileTypeDTO modelDTO)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.Create())
                {
                    ImageFileTypeModel model = _Mapper_ToModel.Map <ImageFileTypeDTO, ImageFileTypeModel>(modelDTO);

                    bool result = unitOfWork.ImageFileTypeRepository.Update(model);

                    ImageFileTypeDTO modelRTN = null;
                    if (result)
                    {
                        await unitOfWork.SaveChangesAsync();

                        modelRTN = _Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(model);
                    }

                    return(modelRTN);
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
 public void Add(ImageFileTypeModel entity)
 {
     try
     {
         _dbContext.Entry(entity).State = EntityState.Added;
     }
     catch (Exception ex)
     {
         LogException(ex);
         throw ex;
     }
 }
        public void Remove(ImageFileTypeModel entity)
        {
            try
            {
                _dbContext.Entry(entity).State = EntityState.Deleted;

                //return await (_dbContext.SaveChangesAsync());
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
        //Find Single ImageFileType base on "term" (async)
        public async Task <ImageFileTypeDTO> SearchSingleImageFileTypeByIdAsync(int Id)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.Create())
                {
                    ImageFileTypeModel model = await Task.Run(() => unitOfWork.ImageFileTypeRepository.GetSingleOrDefaultImageFileType(x => x.ImageFileTypeId == Id));

                    return(_Mapper_ToDTO.Map <ImageFileTypeModel, ImageFileTypeDTO>(model));
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
        public bool Update(ImageFileTypeModel entity)
        {
            try
            {
                var currentEntity = _dbContext.Set <ImageFileTypeModel>().AsQueryable().FirstOrDefault(x => x.ImageFileTypeId == entity.ImageFileTypeId);
                if (currentEntity == null)
                {
                    return(false);
                }
                currentEntity.Type = entity.Type;

                return(true);
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
        //Add ImageFileType (async)
        public async Task <int> AddImageFileTypeAsync(ImageFileTypeDTO modelDTO)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.Create())
                {
                    ImageFileTypeModel model = _Mapper_ToModel.Map <ImageFileTypeDTO, ImageFileTypeModel>(modelDTO);

                    unitOfWork.ImageFileTypeRepository.Add(model);
                    //unitOfWork.Repository.Add<ImageFileTypeModel>(model);
                    await unitOfWork.SaveChangesAsync();

                    return(model.ImageFileTypeId);
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }