Unit of Work

#region Using Namespaces...

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Data.Entity.Validation;
using DataModel.GenericRepository;
using BusinessEntities;

#endregion

namespace DataModel.UnitOfWork
{
    /// <summary>
    /// Unit of Work class responsible for DB transactions
    /// </summary>
    public class UnitOfWork : IDisposable
    {
        #region Private member variables...

        private HrmsEntities _context = null;
        private GenericRepository<City> _cityRepository;
        private GenericRepository<EducationCategory> _educationCatagoryRepository;
        private GenericRepository<BoardUniversity> _boardUniversityRepository;
        private GenericRepository<Skill> _SkillRepository;
        private GenericRepository<SkillLevel> _SkillLevelRepository;
        private GenericRepository<SkillGroup> _SkillGroupRepository;
        private GenericRepository<SkillType> _skillTypepRepository;
        private GenericRepository<KRAGroup> _kraGroupRepository;
        private GenericRepository<Qualification> _QualificationRepository;
        private GenericRepository<JobCode> _JobCodeRepository;
        private GenericRepository<Caste> _CasteRepository;
        private GenericRepository<QualificationCategory> _QualificationCategoryRepository;
        private GenericRepository<Scale> _scaleRepository;
        private GenericRepository<ScaleDtl> _scaledetailsRepository;
        //private GenericRepository<State> _stateRepository;
        private GenericRepository<Education> _educationRepository;
        private GenericRepository<EducationDetail> _educationDetailRepository;
        private GenericRepository<EarningDeductionCode> _earningDeductionCodeRepository;
        private GenericRepository<KRA> _kraRepository;
        private GenericRepository<KRAGroupDtl> _kraGroupDtlRepository;
        private GenericRepository<QualificationDimension> _QualificationDimensionRepository;
        private GenericRepository<HRMS_EmployeeProfessionalDetails> _HRMS_EmployeeProfessionalDetailsRepository;
        private GenericRepository<Grade> _GradeRepository;
        private GenericRepository<LinkScalewithGrade> _LinkScalewithGradeRepository;
        private GenericRepository<QualificationSpecialization> _QualificationSpecializationRepository;
        private GenericRepository<Certificate> _CertificateRepository;
        private GenericRepository<LeaveType> _leaveTypeRepository;
        private GenericRepository<JobType> _JobTypeRepository;
        private GenericRepository<HRMS_InterviewRound>_InterviewRoundRepository;
        private GenericRepository<HRMS_ExpenseType> _HRMS_ExpenseTypeRepository;
        private GenericRepository<HRMS_InterviewVenueFloor> _HRMS_InterviewVenueFloor;
        private GenericRepository<HRMS_InterviewVenueRoom> _HRMS_InterviewVenueRoom;
        private GenericRepository<Relationship> _relationshipRepository;
        private GenericRepository<HRMS_JobTasks> _HRMS_jobTasksRepository;
        private GenericRepository<HRMS_InterviewExpense> _HRMS_InterviewExpenseRepository;
        private GenericRepository<HRMS_InterviewVenue> _hrms_InterviewVenuRepository;
        private GenericRepository<JobFunction> _jobFunctionRepository;
        #endregion

        public UnitOfWork()
        {
            _context = new HrmsEntities();
        }

        #region Public Repository Creation properties...

        /// <summary>
        /// Get/Set Property for city repository.
        /// </summary>

        public GenericRepository<JobFunction> JobFunctionRepository
        {
            get
            {
                if (this._jobFunctionRepository == null)
                    this._jobFunctionRepository = new GenericRepository<JobFunction>(_context);
                return _jobFunctionRepository;
            }
        }

        public GenericRepository<HRMS_InterviewExpense> HRMS_InterviewExpenseRepository
        {
            get
            {
                if (this._HRMS_InterviewExpenseRepository == null)
                    this._HRMS_InterviewExpenseRepository = new GenericRepository<HRMS_InterviewExpense>(_context);
                return _HRMS_InterviewExpenseRepository;
            }
        }
        public GenericRepository<HRMS_ExpenseType> HRMS_ExpenseTypeRepository
        {
            get
            {
                if (this._HRMS_ExpenseTypeRepository == null)
                    this._HRMS_ExpenseTypeRepository = new GenericRepository<HRMS_ExpenseType>(_context);
                return _HRMS_ExpenseTypeRepository;
            }
        }

        public GenericRepository<JobCode> JobcodeRepository
        {
            get
            {
                if (this._JobCodeRepository == null)
                    this._JobCodeRepository = new GenericRepository<JobCode>(_context);
                return _JobCodeRepository;
            }
        }

        public GenericRepository<Certificate> CertificateRepository
        {
            get
            {
                if (this._CertificateRepository == null)
                    this._CertificateRepository = new GenericRepository<Certificate>(_context);
                return _CertificateRepository;
            }
        }

        public GenericRepository<City> CityRepository
        {
            get
            {
                if (this._cityRepository == null)
                    this._cityRepository = new GenericRepository<City>(_context);
                return _cityRepository;
            }
        }

        public GenericRepository<QualificationSpecialization> QualificationSpecializationRepository
        {
            get
            {
                if (this._QualificationSpecializationRepository == null)
                    this._QualificationSpecializationRepository = new GenericRepository<QualificationSpecialization>(_context);
                return _QualificationSpecializationRepository;
            }
        }

        public GenericRepository<EducationCategory> EducationCategoryRepository
        {
            get
            {
                if (this._educationCatagoryRepository == null)
                    this._educationCatagoryRepository = new GenericRepository<EducationCategory>(_context);
                return _educationCatagoryRepository;
            }
        }

        public GenericRepository<BoardUniversity> BoardUniversityRepository
        {
            get
            {
                if (this._boardUniversityRepository == null)
                    this._boardUniversityRepository = new GenericRepository<BoardUniversity>(_context);
                return _boardUniversityRepository;
            }
        }

        public GenericRepository<Skill> SkillRepository
        {
            get
            {
                if (this._SkillRepository == null)
                    this._SkillRepository = new GenericRepository<Skill>(_context);
                return _SkillRepository;
            }
        }

        public GenericRepository<SkillLevel> SkillLevelRepository
        {
            get
            {
                if (this._SkillLevelRepository == null)
                    this._SkillLevelRepository = new GenericRepository<SkillLevel>(_context);
                return _SkillLevelRepository;
            }
        }

        public GenericRepository<SkillGroup> SkillGroupRepository
        {
            get
            {
                if (this._SkillGroupRepository == null)
                    this._SkillGroupRepository = new GenericRepository<SkillGroup>(_context);
                return _SkillGroupRepository;
            }
        }

        public GenericRepository<SkillType> SkillTypeRepository
        {
            get
            {
                if (this._skillTypepRepository == null)
                    this._skillTypepRepository = new GenericRepository<SkillType>(_context);
                return _skillTypepRepository;
            }
        }

        public GenericRepository<KRAGroup> KRAGroupRepository
        {
            get
            {
                if (this._kraGroupRepository == null)
                    this._kraGroupRepository = new GenericRepository<KRAGroup>(_context);
                return _kraGroupRepository;
            }
        }

        public GenericRepository<KRAGroupDtl> KRAGroupDtlRepository
        {
            get
            {
                if (this._kraGroupDtlRepository == null)
                    this._kraGroupDtlRepository = new GenericRepository<KRAGroupDtl>(_context);
                return _kraGroupDtlRepository;
            }
        }

        public GenericRepository<KRA> KRARepository
        {
            get
            {
                if (this._kraRepository == null)
                    this._kraRepository = new GenericRepository<KRA>(_context);
                return _kraRepository;
            }
        }

        public GenericRepository<Qualification> QualificationRepository
        {
            get
            {
                if (this._QualificationRepository == null)
                    this._QualificationRepository = new GenericRepository<Qualification>(_context);
                return _QualificationRepository;
            }
        }

        public GenericRepository<Caste> CasteRepository
        {
            get
            {
                if (this._CasteRepository == null)
                    this._CasteRepository = new GenericRepository<Caste>(_context);
                return _CasteRepository;
            }
        }

        public GenericRepository<QualificationCategory> QualificationCategoryRepository
        {
            get
            {
                if (this._QualificationCategoryRepository == null)
                    this._QualificationCategoryRepository = new GenericRepository<QualificationCategory>(_context);
                return _QualificationCategoryRepository;
            }
        }

        public GenericRepository<Scale> scaleRepository
        {
            get
            {
                if (this._scaleRepository == null)
                    this._scaleRepository = new GenericRepository<Scale>(_context);
                return _scaleRepository;
            }
        }

        public GenericRepository<ScaleDtl> scaledetailsRepository
        {
            get
            {
                if (this._scaledetailsRepository == null)
                    this._scaledetailsRepository = new GenericRepository<ScaleDtl>(_context);
                return _scaledetailsRepository;
            }
        }

        public GenericRepository<Education> EducationRepository
        {
            get
            {
                if (this._educationRepository == null)
                    this._educationRepository = new GenericRepository<Education>(_context);
                return _educationRepository;
            }
        }

        public GenericRepository<EducationDetail> EducationDetailRepository
        {
            get
            {
                if (this._educationDetailRepository == null)
                    this._educationDetailRepository = new GenericRepository<EducationDetail>(_context);
                return _educationDetailRepository;
            }
        }

        public GenericRepository<EarningDeductionCode> EarningDeductionCodeRepository
        {
            get
            {
                if (this._earningDeductionCodeRepository == null)
                    this._earningDeductionCodeRepository = new GenericRepository<EarningDeductionCode>(_context);
                return _earningDeductionCodeRepository;
            }
        }

        public GenericRepository<QualificationDimension> QualificationDimensionRepository
        {
            get
            {
                if (this._QualificationDimensionRepository == null)
                    this._QualificationDimensionRepository = new GenericRepository<QualificationDimension>(_context);
                return _QualificationDimensionRepository;
            }
        }

        public GenericRepository<HRMS_EmployeeProfessionalDetails> HRMS_EmployeeProfessionalDetailsRepository
        {
            get
            {
                if (this._HRMS_EmployeeProfessionalDetailsRepository == null)
                    this._HRMS_EmployeeProfessionalDetailsRepository = new GenericRepository<HRMS_EmployeeProfessionalDetails>(_context);
                return _HRMS_EmployeeProfessionalDetailsRepository;
            }
        }

        public GenericRepository<Grade> GradeRepository
        {
            get
            {
                if (this._GradeRepository == null)
                    this._GradeRepository = new GenericRepository<Grade>(_context);
                return _GradeRepository;
            }
        }

        public GenericRepository<LinkScalewithGrade> LinkScalewithGradeRepository
        {
            get
            {
                if (this._LinkScalewithGradeRepository == null)
                    this._LinkScalewithGradeRepository = new GenericRepository<LinkScalewithGrade>(_context);
                return _LinkScalewithGradeRepository;
            }
        }

        public GenericRepository<LeaveType> LeaveTypeRepository
        {
            get
            {
                if (this._leaveTypeRepository == null)
                    this._leaveTypeRepository = new GenericRepository<LeaveType>(_context);
                return _leaveTypeRepository;
            }
        }

        public GenericRepository<JobType> JobTypeRepository
        {
            get
            {
                if (this._JobTypeRepository == null)
                    this._JobTypeRepository = new GenericRepository<JobType>(_context);
                return _JobTypeRepository;
            }
        }

        public GenericRepository<HRMS_InterviewRound> InterviewRoundRepository
        {
            get
            {
                if (this._InterviewRoundRepository == null)
                    this._InterviewRoundRepository = new GenericRepository<HRMS_InterviewRound>(_context);
                return _InterviewRoundRepository;
            }
        }

        public GenericRepository<HRMS_InterviewVenueFloor> InterviewVenueFloorRepository
        {
            get
            {
                if (this._HRMS_InterviewVenueFloor == null)
                    this._HRMS_InterviewVenueFloor = new GenericRepository<HRMS_InterviewVenueFloor>(_context);
                return _HRMS_InterviewVenueFloor;
            }
        }

        public GenericRepository<HRMS_InterviewVenueRoom> InterviewVenueRoomRepository
        {
            get
            {
                if (this._HRMS_InterviewVenueRoom == null)
                    this._HRMS_InterviewVenueRoom = new GenericRepository<HRMS_InterviewVenueRoom>(_context);
                return _HRMS_InterviewVenueRoom;
            }
        }

        public GenericRepository<Relationship> RelationshipRepository
        {
            get
            {
                if (this._relationshipRepository == null)
                    this._relationshipRepository = new GenericRepository<Relationship>(_context);
                return _relationshipRepository;
            }
        }

        public GenericRepository<HRMS_JobTasks> HRMS_JobTasksRepository
        {
            get
            {
                if (this._HRMS_jobTasksRepository == null)
                    this._HRMS_jobTasksRepository = new GenericRepository<HRMS_JobTasks>(_context);
                return _HRMS_jobTasksRepository;
            }
        }
        public GenericRepository<HRMS_InterviewVenue> InterviewVenueRepository
        {
            get
            {
                if (this._hrms_InterviewVenuRepository == null)
                    this._hrms_InterviewVenuRepository = new GenericRepository<HRMS_InterviewVenue>(_context);
                return _hrms_InterviewVenuRepository;
            }
        }
        ///// <summary>
        ///// Get/Set Property for State repository.
        ///// </summary>
        //public GenericRepository<State> StateRepository
        //{
        //    get
        //    {
        //        if (this._stateRepository == null)
        //            this._stateRepository = new GenericRepository<State>(_context);
        //        return _stateRepository;
        //    }
        //}

        /// <summary>
        /// Get/Set Property for token repository.
        /// </summary>
        //public GenericRepository<Token> TokenRepository
        //{
        //    get
        //    {
        //        if (this._tokenRepository == null)
        //            this._tokenRepository = new GenericRepository<Token>(_context);
        //        return _tokenRepository;
        //    }
        //}
        #endregion

        #region Public member methods...
        /// <summary>
        /// Save method.
        /// </summary>
        public void Save()
        {
            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {

                var outputLines = new List<string>();
                foreach (var eve in e.EntityValidationErrors)
                {
                    outputLines.Add(string.Format("{0}: Entity of type \"{1}\" in state \"{2}\" has the following validation errors:", DateTime.Now, eve.Entry.Entity.GetType().Name, eve.Entry.State));
                    foreach (var ve in eve.ValidationErrors)
                    {
                        outputLines.Add(string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage));
                    }
                }
                //System.IO.File.AppendAllLines(@"C:\errors.txt", outputLines);

                throw e;
            }

        }

        #endregion

        #region Implementing IDiosposable...

        #region private dispose variable declaration...
        private bool disposed = false;
        #endregion

        /// <summary>
        /// Protected Virtual Dispose method
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    Debug.WriteLine("UnitOfWork is being disposed");
                    _context.Dispose();
                }
            }
            this.disposed = true;
        }

        /// <summary>
        /// Dispose method
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }
}