/// <summary>
        /// Delete User Action Activity Log
        /// </summary>
        /// <param name=></param>
        /// <returns>bool</returns>
        public async Task <bool> DeleteJobSeekerTypeOfJob(int JobSeekerTypeOfJobId)
        {
            #region Declare a return type with initial value.
            bool isJobSeekerTypeOfJobDeleted = default(bool);
            #endregion
            try
            {
                if (JobSeekerTypeOfJobId > default(int))
                {
                    #region Vars
                    JobSeekerTypeOfJob JobSeekerTypeOfJob = null;
                    #endregion
                    #region Get JobSeekerTypeOfJob by id
                    JobSeekerTypeOfJob = await UnitOfWork.JobSeekerTypeOfJobRepository.GetById(JobSeekerTypeOfJobId);

                    #endregion
                    #region check if object is not null
                    if (JobSeekerTypeOfJob != null)
                    {
                        JobSeekerTypeOfJob.IsDeleted = (byte)DeleteStatusEnum.Deleted;
                        #region Apply the changes to the database
                        UnitOfWork.JobSeekerTypeOfJobRepository.Update(JobSeekerTypeOfJob);
                        isJobSeekerTypeOfJobDeleted = await UnitOfWork.Commit() > default(int);

                        #endregion
                    }
                    #endregion
                }
            }
            catch (Exception exception)
            {
            }
            return(isJobSeekerTypeOfJobDeleted);
        }
 /// <summary>
 /// Mapping User Activity Log DTO to Action
 /// </summary>
 /// <param name=></param>
 /// <param name=></param>
 /// <returns></returns>
 public JobSeekerTypeOfJob MappingJobSeekerTypeOfJobupdateDTOToJobSeekerTypeOfJob(JobSeekerTypeOfJob jobSeekerTypeOfJob, JobSeekerTypeOfJobUpdateDTO JobSeekerTypeOfJobUpdateDTO)
 {
     #region Declare Return Var with Intial Value
     JobSeekerTypeOfJob JobSeekerTypeOfJob = jobSeekerTypeOfJob;
     #endregion
     try
     {
         if (JobSeekerTypeOfJobUpdateDTO.JobSeekerTypeOfJobId > default(int))
         {
             JobSeekerTypeOfJob.JobSeekerId          = JobSeekerTypeOfJobUpdateDTO.JobSeekerId;
             JobSeekerTypeOfJob.TypeOfJobId          = JobSeekerTypeOfJobUpdateDTO.TypeOfJobId;
             JobSeekerTypeOfJob.JobSeekerTypeOfJobId = JobSeekerTypeOfJobUpdateDTO.JobSeekerTypeOfJobId;
         }
     }
     catch (Exception exception) { }
     return(JobSeekerTypeOfJob);
 }
 /// <summary>
 /// Mapping user Action Actitvity Log
 /// </summary>
 /// <param name=></ param >
 /// <returns>Task<JobSeekerTypeOfJob></returns>
 public JobSeekerTypeOfJob MappingJobSeekerTypeOfJobAddDTOToJobSeekerTypeOfJob(JobSeekerTypeOfJobAddDTO JobSeekerTypeOfJobAddDTO)
 {
     #region Declare a return type with initial value.
     JobSeekerTypeOfJob JobSeekerTypeOfJob = null;
     #endregion
     try
     {
         JobSeekerTypeOfJob = new JobSeekerTypeOfJob
         {
             JobSeekerId  = JobSeekerTypeOfJobAddDTO.JobSeekerId,
             TypeOfJobId  = JobSeekerTypeOfJobAddDTO.TypeOfJobId,
             CreationDate = DateTime.Now,
             IsDeleted    = (byte)DeleteStatusEnum.NotDeleted
         };
     }
     catch (Exception exception) { }
     return(JobSeekerTypeOfJob);
 }
        /// <summary>
        /// Get user Action Activity Log By Id
        /// </summary>
        /// <returns>List<JobSeekerTypeOfJobReturnDTO></returns>
        public async Task <JobSeekerTypeOfJobReturnDTO> GetJobSeekerTypeOfJobById(int JobSeekerTypeOfJobId)
        {
            #region Declare a return type with initial value.
            JobSeekerTypeOfJobReturnDTO JobSeekerTypeOfJob = new JobSeekerTypeOfJobReturnDTO();
            #endregion
            try
            {
                JobSeekerTypeOfJob jobSeekerTypeOfJob = await UnitOfWork.JobSeekerTypeOfJobRepository.GetById(JobSeekerTypeOfJobId);

                if (jobSeekerTypeOfJob != null)
                {
                    if (jobSeekerTypeOfJob.IsDeleted != (byte)DeleteStatusEnum.Deleted)
                    {
                        JobSeekerTypeOfJob = JobSeekerTypeOfJobMapping.MappingJobSeekerTypeOfJobToJobSeekerTypeOfJobReturnDTO(jobSeekerTypeOfJob);
                    }
                }
            }
            catch (Exception exception)
            {
            }
            return(JobSeekerTypeOfJob);
        }
        /// <summary>
        /// Create User Action Activity Log
        /// </summary>
        /// <param name=></param>
        /// <returns>bool</returns>
        public async Task <bool> AddJobSeekerTypeOfJob(JobSeekerTypeOfJobAddDTO JobSeekerTypeOfJobAddDTO)
        {
            #region Declare a return type with initial value.
            bool isJobSeekerTypeOfJobCreated = default(bool);
            #endregion
            try
            {
                #region Vars
                JobSeekerTypeOfJob JobSeekerTypeOfJob = null;
                #endregion
                JobSeekerTypeOfJob = JobSeekerTypeOfJobMapping.MappingJobSeekerTypeOfJobAddDTOToJobSeekerTypeOfJob(JobSeekerTypeOfJobAddDTO);
                if (JobSeekerTypeOfJob != null)
                {
                    await UnitOfWork.JobSeekerTypeOfJobRepository.Insert(JobSeekerTypeOfJob);

                    isJobSeekerTypeOfJobCreated = await UnitOfWork.Commit() > default(int);
                }
            }
            catch (Exception exception)
            {
            }
            return(isJobSeekerTypeOfJobCreated);
        }
        /// <summary>
        /// Update User Action Activity Log
        /// </summary>
        /// <param name=></param>
        /// <returns>bool</returns>
        public async Task <bool> UpdateJobSeekerTypeOfJob(JobSeekerTypeOfJobUpdateDTO JobSeekerTypeOfJobUpdateDTO)
        {
            #region Declare a return type with initial value.
            bool isJobSeekerTypeOfJobUpdated = default(bool);
            #endregion
            try
            {
                if (JobSeekerTypeOfJobUpdateDTO != null)
                {
                    #region Vars
                    JobSeekerTypeOfJob JobSeekerTypeOfJob = null;
                    #endregion
                    #region Get Activity By Id
                    JobSeekerTypeOfJob = await UnitOfWork.JobSeekerTypeOfJobRepository.GetById(JobSeekerTypeOfJobUpdateDTO.JobSeekerTypeOfJobId);

                    #endregion
                    if (JobSeekerTypeOfJob != null)
                    {
                        #region  Mapping
                        JobSeekerTypeOfJob = JobSeekerTypeOfJobMapping.MappingJobSeekerTypeOfJobupdateDTOToJobSeekerTypeOfJob(JobSeekerTypeOfJob, JobSeekerTypeOfJobUpdateDTO);
                        #endregion
                        if (JobSeekerTypeOfJob != null)
                        {
                            #region  Update Entity
                            UnitOfWork.JobSeekerTypeOfJobRepository.Update(JobSeekerTypeOfJob);
                            isJobSeekerTypeOfJobUpdated = await UnitOfWork.Commit() > default(int);

                            #endregion
                        }
                    }
                }
            }
            catch (Exception exception)
            {
            }
            return(isJobSeekerTypeOfJobUpdated);
        }
 public JobSeekerTypeOfJobReturnDTO MappingJobSeekerTypeOfJobToJobSeekerTypeOfJobReturnDTO(JobSeekerTypeOfJob JobSeekerTypeOfJob)
 {
     #region Declare a return type with initial value.
     JobSeekerTypeOfJobReturnDTO JobSeekerTypeOfJobReturnDTO = null;
     #endregion
     try
     {
         if (JobSeekerTypeOfJob != null)
         {
             JobSeekerTypeOfJobReturnDTO = new JobSeekerTypeOfJobReturnDTO
             {
                 JobSeekerId          = JobSeekerTypeOfJob.JobSeekerId,
                 TypeOfJobId          = JobSeekerTypeOfJob.TypeOfJobId,
                 JobSeekerTypeOfJobId = JobSeekerTypeOfJob.JobSeekerTypeOfJobId
             };
         }
     }
     catch (Exception exception)
     { }
     return(JobSeekerTypeOfJobReturnDTO);
 }