using HRM.BO;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Data;
using HRM.BO.Configuration;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using HRM.DA;
using System.Linq;
using static iTextSharp.text.pdf.AcroFields;
using AutoMapper.Internal;
using NPOI.SS.Formula.Functions;
using System.IO;


namespace HRM.UI.Controllers.Talent_Management
{
    [Route("api/Pmp")]
    [ApiController]
    [Authorize]
    public class PmpController : ControllerBase
    {
        private readonly IEmployeeService _EmployeeService;
        private readonly IPMPProcessService _pmpProcessService;
        private readonly IObjectiveTypeService _objectiveTypeService;
        private readonly IOrganogramService _organogramService;
        private readonly IObjectiveCategoryService _objectiveCategoryService;
        private readonly IObjectiveCategoryGradesService _objectiveCategoryGradesService;
        private readonly IObjectiveService _objectiveService;
        private readonly IEmployeeService _employeeService;
        private readonly IObjectiveSetService _objectiveSetService;
        private readonly IObjectiveSetRemarksService _objectiveSetRemarksService;
        private readonly IAssesmentValueDetailsService _assesmentValueDetailsService;
        private readonly IAppraisalPointRatingService _appraisalPointRatingService;
        private readonly IAppraisalPointService _appraisalPointService;
        private readonly IEmpAppraisalRatingService _empAppraisalRatingService;
        private readonly IEmployeeAppraisalService _employeeAppraisalService;
        private readonly IYearEndValuesRatingService _yearEndValuesRatingService;
        private readonly IOptions<EmailSettings> _emailSettings;
        private readonly ICompetencyService _competencyService;
        private readonly IQuestionnaireService _questionnaireService;
        private readonly IPMPValueBehaviorService _pmpValueBehaviorService;
        private readonly IDevelopmentPlanService _developmentPlanService;
        private readonly IPMPValueBehaviorSettingService _pmpValueBehaviorSettingService;
        private readonly ISuccessionRoleService _successionRoleService;
        private readonly ISuccessionPlanningService _successionPlanningService;
        private readonly IPMPRatingService _pmpRatingService;
        private readonly IPMSObjectiveProgressService _pmsObjectiveProgressService;
        private readonly IPMSObjectiveProgressAttachmentService _pmsObjectiveProgressAttachmentService;


        public PmpController(IPMPProcessService pmpProcessService,
            IObjectiveTypeService objectiveTypeService,
            IOrganogramService organogramService,
            IObjectiveCategoryService objectiveCategoryService,
            IObjectiveCategoryGradesService objectiveCategoryGradesService,
            IObjectiveService objectiveService,
            IEmployeeService employeeService,
            IObjectiveSetService objectiveSetService,
            IObjectiveSetRemarksService objectiveSetRemarksService,
            IAssesmentValueDetailsService assesmentValueDetailsService,
            IAppraisalPointRatingService appraisalPointRatingService,
            IAppraisalPointService appraisalPointService,
            IEmpAppraisalRatingService empAppraisalRatingService,
            IEmployeeAppraisalService employeeAppraisalService,
            IYearEndValuesRatingService yearEndValuesRatingService,
            IOptions<EmailSettings> emailSettings,
            ICompetencyService competencyService,
            IQuestionnaireService questionnaireService,
            IPMPValueBehaviorService pmpValueBehaviorService,
            IDevelopmentPlanService developmentPlanService,
            IEmployeeService empService,
            IPMPValueBehaviorSettingService pmpValueBehaviorSettingService,
            ISuccessionRoleService successionRoleService,
            ISuccessionPlanningService successionPlanningService,
            IPMPRatingService pmpRatingService,
            IPMSObjectiveProgressService pmsObjectiveProgressService,
            IPMSObjectiveProgressAttachmentService pmsObjectiveProgressAttachmentService)
        {
            _pmpProcessService = pmpProcessService;
            _objectiveTypeService = objectiveTypeService;
            _organogramService = organogramService;
            _objectiveCategoryService = objectiveCategoryService;
            _objectiveCategoryGradesService = objectiveCategoryGradesService;
            _objectiveService = objectiveService;
            _employeeService = employeeService;
            _objectiveSetService = objectiveSetService;
            _objectiveSetRemarksService = objectiveSetRemarksService;
            _assesmentValueDetailsService = assesmentValueDetailsService;
            _appraisalPointRatingService = appraisalPointRatingService;
            _appraisalPointService = appraisalPointService;
            _yearEndValuesRatingService = yearEndValuesRatingService;
            _emailSettings = emailSettings;
            _competencyService = competencyService;
            _questionnaireService = questionnaireService;
            _empAppraisalRatingService = empAppraisalRatingService;
            _employeeAppraisalService = employeeAppraisalService;
            _pmpValueBehaviorService = pmpValueBehaviorService;
            _developmentPlanService = developmentPlanService;
            _pmpValueBehaviorSettingService = pmpValueBehaviorSettingService;
            _EmployeeService = empService;
            _successionRoleService = successionRoleService;
            _successionPlanningService = successionPlanningService;
            _pmpRatingService = pmpRatingService;
            _pmsObjectiveProgressService = pmsObjectiveProgressService;
            _pmsObjectiveProgressAttachmentService = pmsObjectiveProgressAttachmentService;
        }

        // PMPProcess
        [HttpGet]
        [Route("getAllPmpProcess")]
        public ActionResult GetAllPmpProcess()
        {
            List<PMPProcess> items = new List<PMPProcess>();
            try
            {
                items = _pmpProcessService.Get(EnumStatus.Regardless);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpPost]
        [Route("savePmpProcess")]
        public ActionResult SavePmpProcess(PMPProcess item)
        {
            int ans;
            try
            {
                ans = _pmpProcessService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpPost]
        [Route("deletePmpProcess")]
        public ActionResult DeletePmpProcess(PMPProcess item)
        {
            try
            {
                _pmpProcessService.Delete(item.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getCurrentYear")]
        public ActionResult GetCurrentYear()
        {
            PMPProcess item = new PMPProcess();
            try
            {
                item = _pmpProcessService.GetCurrentPMPYear(false);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        [HttpGet]
        [Route("getPmpProcessByYear/{pmpYear}")]
        public ActionResult GetPmpProcessByYear(int pmpYear)
        {
            PMPProcess item = new PMPProcess();
            try
            {
                item = _pmpProcessService.GetByYear(pmpYear);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        [HttpGet]
        [Route("getAllObjectiveTypes")]
        public ActionResult GetAllObjectiveTypes()
        {
            List<ObjectiveType> items = new List<ObjectiveType>();
            try
            {
                items = _objectiveTypeService.Get(EnumStatus.Regardless);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getMaxTier")]
        public ActionResult GetMaxTier()
        {
            int ans = 0;
            try
            {
                ans = _organogramService.MaxTier();
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpPost]
        [Route("saveObjectiveCategory")]
        public ActionResult SaveObjectiveCategoryGrade(ObjectiveCategory item)
        {
            try
            {
                this._objectiveCategoryService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        // ObjectiveCategoryGrades
        [HttpGet]
        [Route("getObjectiveCategoryGradesByPmpYearIdAndCategory/{pmpYearId}/{categoryId}")]
        public ActionResult GetObjectiveCategoryGradesByPmpYearIdAndCategory(int pmpYearId, int categoryId)
        {
            List<ObjectiveCategoryGrades> items = new List<ObjectiveCategoryGrades>();
            try
            {
                items = _objectiveCategoryGradesService.Get(pmpYearId, categoryId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getByGradeId/{gradeId}/{pmpYearId}")]
        public ActionResult GetByGradeId(int gradeId, int pmpYearId)
        {
            List<ObjectiveCategoryGrades> items = new List<ObjectiveCategoryGrades>();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();
            Employee employee = new Employee();
            try
            {
                if (gradeId == 0)
                {
                    employee = _employeeService.Get(employeeId);
                    gradeId = employee.GradeID.GetValueOrDefault();
                }

                items = _objectiveCategoryGradesService.GetByGradeId(gradeId, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // Objective
        [HttpPost]
        [Route("saveObjective")]
        public ActionResult SaveObjective(Objective item)
        {
            int ans;
            if (item.EmployeeID <= 0)
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
                int employeeId = currentUser.EmployeeID.GetValueOrDefault();
                item.EmployeeID = employeeId;
            }

            try
            {
                ans = this._objectiveService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }


        [HttpPost]
        [Route("DeleteObjective")]
        public ActionResult DeleteObjective(Objective item)
        {
            try
            {
                this._objectiveService.Delete(item.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(true);
        }

        [HttpGet]
        [Route("getForValidation/{empId}/{pmpYearId}/{objectiveTypeId}")]
        public ActionResult GetForValidation(int empId, int pmpYearId, int objectiveTypeId)
        {
            List<Objective> items = new List<Objective>();
            try
            {
                items = _objectiveService.GetForValidation(empId, pmpYearId, objectiveTypeId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getObjectiveListByEmployeeId/{pmpYearId}/{employeeId}")]
        public ActionResult GetObjectiveListByEmployeeId(int pmpYearId, int employeeId)
        {
            List<Objective> items = new List<Objective>();
            if (employeeId == 0)
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
                employeeId = currentUser.EmployeeID.GetValueOrDefault();
            }

            try
            {
                items = _objectiveService.GetByEmployeeID(employeeId, pmpYearId, false);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpPost]
        [Route("getObjectiveByEmpIds")]
        public ActionResult GetObjectiveByEmpIds(dynamic data)
        {
            List<Objective> items = new List<Objective>();
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            string empIds = (string)item["ids"].ToObject<string>();
            int pmpYearId = item["selectedYear"].ToObject<int>();
            ;
            try
            {
                items = _objectiveService.GetByEmployeeID(empIds, pmpYearId, false);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // ObjectiveSet
        [HttpGet]
        [Route("getObjectiveSetByEmpId/{pmpYearId}/{employeeId}")]
        public ActionResult GetObjectiveSetByEmpId(int pmpYearId, int employeeId)
        {
            ObjectiveSet item = new ObjectiveSet();
            if (employeeId == 0)
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
                employeeId = currentUser.EmployeeID.GetValueOrDefault();
            }

            try
            {
                item = _objectiveSetService.GetByEmployeeID(employeeId, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        [HttpPost]
        [Route("getObjectiveSetByEmpIds")]
        public ActionResult GetObjectiveSetByEmpIds(dynamic data)
        {
            List<ObjectiveSet> items = new List<ObjectiveSet>();
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            string empIds = (string)item["ids"].ToObject<string>();
            int pmpYearId = item["selectedYear"].ToObject<int>();
            ;
            try
            {
                items = _objectiveSetService.GetByEmpIds(pmpYearId, empIds);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getAllObjectiveSet")]
        public ActionResult GetAllObjectiveSet()
        {
            List<ObjectiveSet> items = new List<ObjectiveSet>();
            try
            {
                items = _objectiveSetService.Get();
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getObjectiveSetWithChild/{employeeId}/{pmpYearId}")]
        public ActionResult GetObjectiveSetWithChild(int employeeId, int pmpYearId)
        {
            ObjectiveSet item = new ObjectiveSet();
            if (employeeId == 0)
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
                employeeId = currentUser.EmployeeID.GetValueOrDefault();
            }

            try
            {
                item = _objectiveSetService.GetObjectiveSetWithChild(employeeId, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        [HttpGet]
        [Route("getObjectiveSetByDepartment/{pmpYearId}")]
        public ActionResult GetObjectiveSetByDepartment(int pmpYearId)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int empId = currentUser.EmployeeID.GetValueOrDefault();
            List<ObjectiveSet> items = new List<ObjectiveSet>();
            Employee employee = null;
            try
            {
                employee = _employeeService.Get(empId);
                if (employee.DepartmentID == null)
                    throw new Exception("No Department Found");
                int deptId = employee.DepartmentID.GetValueOrDefault();
                items = _objectiveSetService.GetObjectiveSetByDepartment(deptId, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpPost]
        [Route("saveObjectiveSet")]
        public ActionResult SaveObjectiveSet(ObjectiveSet item)
        {
            int ans;
            try
            {
                ans = _objectiveSetService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpPost]
        [Route("saveObjSetWithChild")]
        public ActionResult SaveObjSetWithChild(ObjectiveSet item)
        {
            try
            {
                _objectiveSetService.SaveWithChild(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getByPMPYear/{pmpYearId}/{empIds}")]
        public ActionResult GetByPMPYear(int pmpYearId, string empIds)
        {
            List<ObjectiveSet> items = new List<ObjectiveSet>();
            try
            {
                items = _objectiveSetService.GetByPMPYear(pmpYearId, empIds);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getObjectiveSetByPMPYear/{pmpYearId}")]
        public ActionResult GetObjectiveSetByPMPYear(int pmpYearId)
        {
            List<ObjectiveSet> items = new List<ObjectiveSet>();
            try
            {
                items = _objectiveSetService.GetByPMPYear(pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // ObjectiveSetRemarks
        [HttpGet]
        [Route("getByObjectiveSetId/{objSetId}")]
        public ActionResult GetByObjectiveSetId(int objSetId)
        {
            ObjectiveSetRemarks item = new ObjectiveSetRemarks();
            try
            {
                item = _objectiveSetRemarksService.GetByObjectiveSetID(objSetId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        // AssesmentValueDetails
        [HttpGet]
        [Route("getAllAssessmentDetails")]
        public ActionResult GetAllAssessmentDetails()
        {
            List<AssesmentValueDetails> items = new List<AssesmentValueDetails>();
            try
            {
                items = _assesmentValueDetailsService.Get(EnumStatus.Regardless);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // AppraisalPointRating
        [HttpGet]
        [Route("getAllAppraisalPointRating")]
        public ActionResult GetAllAppraisalPointRating()
        {
            List<AppraisalPointRating> items = new List<AppraisalPointRating>();
            try
            {
                items = _appraisalPointRatingService.Get();
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }
        [HttpGet]
        [Route("getAllAppraisalPointRatings/{year}")]
        public ActionResult GetAllAppraisalPointRatings(DateTime year)
        {
            List<AppraisalPointRating> items = new List<AppraisalPointRating>();
            try
            {
                items = _appraisalPointRatingService.Get(year);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }
        [HttpGet]
        [Route("getAllAppraisalPointRatingsTypeWise/{type}")]
        [Route("getAllAppraisalPointRatingsTypeWise/{type}/{year}")]
        public ActionResult getAllAppraisalPointRatingsTypeWise(EnumAppraisalPointType type, DateTime? year)
        {
            List<AppraisalPointRating> items = new List<AppraisalPointRating>();
            try
            {
                items = _appraisalPointRatingService.Get(type, year);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }
        [HttpPost]
        [Route("saveAppraisalPointRating")]
        public ActionResult saveAppraisalPointRating(AppraisalPointRating oAppraisalPointRating)
        {
            int item;
            try
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

                if (oAppraisalPointRating.IsNew == true)
                {
                    oAppraisalPointRating.CreatedBy = currentUser.UserID;
                    oAppraisalPointRating.CreatedDate = DateTime.Today;
                }
                else
                {
                    oAppraisalPointRating.ModifiedBy = currentUser.UserID;
                    oAppraisalPointRating.ModifiedDate = DateTime.Today;
                }
                item = _appraisalPointRatingService.Save(oAppraisalPointRating);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }
        [HttpPost]
        [Route("deleteAppraisalPointRatingbyId")]
        public ActionResult deleteAppraisalPointRatingbyId(AppraisalPointRating oAppraisalPointRating)
        {
            try
            {
                _appraisalPointRatingService.Delete(oAppraisalPointRating.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        // AppraisalPoint
        [HttpGet]
        [Route("getAllAppraisalPoint")]
        public ActionResult GetAllAppraisalPoint()
        {
            List<AppraisalPoint> items = new List<AppraisalPoint>();
            try
            {
                items = _appraisalPointService.Get(EnumStatus.Regardless);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // PMPRating
        [HttpGet]
        [Route("getAllPMPRating")]
        public ActionResult GetAllPMPRating()
        {
            List<PMPRating> items = new List<PMPRating>();
            List<PMPProcess> processItems = _pmpProcessService.Get(EnumStatus.Regardless);
            try
            {
                items = new PMPRatingService().Get(EnumStatus.Regardless);
                foreach (PMPRating item in items)
                {
                    if (item.PMPYearId > 0)
                        item.PMPYear = processItems.FirstOrDefault(i => i.ID == item.PMPYearId).PmpYear;
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpPost]
        [Route("savePmpRating")]
        public ActionResult SavePmpRating(PMPRating item)
        {
            int ans;
            try
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

                if (item.IsNew == true)
                {
                    item.CreatedBy = currentUser.UserID;
                    item.CreatedDate = DateTime.Today;
                }
                else
                {
                    item.ModifiedBy = currentUser.UserID;
                    item.ModifiedDate = DateTime.Today;
                }
                ans = new PMPRatingService().Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpPost]
        [Route("deletePmpRating")]
        public ActionResult DeletePmpRating(PMPRating item)
        {
            try
            {
                new PMPRatingService().Delete(item.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getPMPRatingByTypeAndYear/{type}/{pmpYearId}")]
        public ActionResult GetPMPRatingByTypeAndYear(EnumPMPRatingType type, int pmpYearId)
        {
            List<PMPRating> items = new List<PMPRating>();
            try
            {
                items = _pmpRatingService.GetPMPRatingByTypeAndYear(type, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        // Send Email
        [HttpPost]
        [Route("sendEmailForPMS")]
        public ActionResult SendEmailForPms(dynamic data)
        {
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            int empId = item["employeeId"].ToObject<int>();
            string message = (string)item["message"].ToObject<string>();
            string subject = (string)item["subject"].ToObject<string>();
            Employee employee = new Employee();
            EmailSettings emailSettings = _emailSettings.Value;
            try
            {
                if (empId == 0)
                {
                    CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
                    empId = currentUser.EmployeeID.GetValueOrDefault();
                    employee = _employeeService.GetLineManager(empId);
                }
                else
                {
                    employee = _employeeService.Get(empId);
                }

                MailSender mailSender = new MailSender();
                mailSender.AddTo(employee.EmailAddress);
                mailSender.Subject = subject;
                mailSender.Body = "<p>" + message + "</p>";
                mailSender.SendMail(emailSettings);
                System.Threading.Thread.Sleep(500);

                /*MailSender mailSender = new MailSender();
                mailSender.AddTo("ikramul@celimited.com");
                mailSender.Subject = "This is PMS Email";
                mailSender.Body = "<p>" + message + "</p>";
                mailSender.SendMail(emailSettings);
                System.Threading.Thread.Sleep(500);*/
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpPost]
        [Route("sendEmailForPmsMultiple")]
        public ActionResult SendEmailForPmsMultiple(dynamic data)
        {
            EmailSettings emailSettings = _emailSettings.Value;
            var employees = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data.list));
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            string subject = (string)item["emailSubject"].ToObject<string>();
            string body = (string)item["emailBody"].ToObject<string>();
            try
            {
                foreach (var employee in employees)
                {
                    MailSender mailSender = new MailSender();
                    mailSender.AddTo(employee.emailAddress.ToString());
                    mailSender.Subject = subject;
                    mailSender.Body = "<p>" + body + "</p>";
                    mailSender.SendMail(emailSettings);
                    System.Threading.Thread.Sleep(500);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpPost]
        [Route("sendEmailNotification")]
        public ActionResult SendEmailNotification(dynamic data)
        {
            List<Employee> employees = new List<Employee>();
            EmailSettings emailSettings = _emailSettings.Value;
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            string empIds = (string)item["empIds"].ToObject<string>();
            string subject = (string)item["emailSubject"].ToObject<string>();
            string body = (string)item["emailBody"].ToObject<string>();
            try
            {
                employees = _employeeService.GetByEmpIDs(empIds);
                foreach (var employee in employees)
                {
                    MailSender mailSender = new MailSender();
                    mailSender.AddTo(employee.EmailAddress);
                    mailSender.Subject = subject;
                    mailSender.Body = "<p>" + body + "</p>";
                    mailSender.SendMail(emailSettings);
                    System.Threading.Thread.Sleep(500);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getPmsLmGoalReport/{pmpYearId}")]
        public ActionResult GetPmsLmGoalReport(int pmpYearId)
        {
            DataSet ds = new DataSet();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();
            try
            {
                ds = _objectiveService.GetPmsLmGoalReport(pmpYearId, employeeId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ds);
        }

        [HttpGet]
        [Route("getPmsIndividualGoalData/{pmpYearId}")]
        public ActionResult GetPmsIndividualGoalData(int pmpYearId)
        {
            DataSet ds = new DataSet();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();
            try
            {
                ds = _objectiveService.GetPmsIndividualGoalData(pmpYearId, employeeId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ds);
        }

        [HttpPost]
        [Route("getPmsDataDepartmentWise")]
        public ActionResult GetPmsDataDepartmentWise(dynamic data)
        {
            DataSet ds = new DataSet();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            var item = Newtonsoft.Json.JsonConvert.DeserializeObject(Convert.ToString(data));
            string empIds = (string)item["empIds"].ToObject<string>();
            int pmpYearId = item["pmsYear"].ToObject<int>();
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();
            try
            {
                if (empIds.Length > 0)
                {
                    ds = _objectiveService.GetPmsDataEmployeeWise(pmpYearId, empIds);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ds);
        }

        #region Competency

        [HttpGet]
        [Route("getCompetencys")]
        public ActionResult getCompetencys()
        {
            List<Competency> oCompetency = new List<Competency>();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int payrollTypeId = currentUser.PayrollTypeID.GetValueOrDefault();
            try
            {
                oCompetency = _competencyService.Get(EnumStatus.Regardless, payrollTypeId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(oCompetency);
        }

        #endregion Competency

        #region Questionnaire

        [HttpGet]
        [Route("getQuestionnaires")]
        public ActionResult getQuestionnaires()
        {
            List<Questionnaire> oQuestionnaire = new List<Questionnaire>();
            try
            {
                oQuestionnaire = _questionnaireService.Get();
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(oQuestionnaire);
        }
        [HttpPost]
        [Route("saveQuestionnaires")]
        public ActionResult saveQuestionnaires(Questionnaire oQuestionnaire)
        {
            Questionnaire item = new Questionnaire();
            oQuestionnaire.GradeIDsInString = string.Join(",", oQuestionnaire.GradeIDs.Select(x => x.ToString()).ToList());
            try
            {
                item.ID = _questionnaireService.Save(oQuestionnaire);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item.ID);
        }
        [HttpPost]
        [Route("deleteQuestionnaireById")]
        public ActionResult deleteQuestionnaireById(Questionnaire oQuestionnaire)
        {
            try
            {
                _questionnaireService.Delete(oQuestionnaire.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        #endregion Questionnaire

        #region Calibration

        [HttpGet]
        [Route("getCalibrationByPmpYearId/{pmpYearId}")]
        public ActionResult GetCalibrationByPmpYearId(int pmpYearId)
        {
            List<Calibration> items = new List<Calibration>();
            try
            {
                items = new CalibrationService().GetByPmpYearId(pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getCalibrationByEmpIdAndPmpYearId/{empId}/{pmpYearId}")]
        public ActionResult GetCalibrationByEmpIdAndPmpYearId(int empId, int pmpYearId)
        {
            Calibration item = new Calibration();
            try
            {
                item = new CalibrationService().GetByEmpIdAndPmpYearId(empId, pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(item);
        }

        [HttpGet]
        [Route("getSubordinatesCalibration/{pmpYearId}")]
        public ActionResult GetSubordinatesCalibration(int pmpYearId)
        {
            List<Calibration> items = new List<Calibration>();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int empId = currentUser.EmployeeID.GetValueOrDefault();
            try
            {
                items = new CalibrationService().GetSubordinatesCalibration(pmpYearId, empId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }


        [HttpPost]
        [Route("saveCalibration")]
        public ActionResult SaveCalibration(Calibration item)
        {
            try
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

                if (item.IsNew == true)
                {
                    item.CreatedBy = currentUser.UserID;
                    item.CreatedDate = DateTime.Today;
                }
                else
                {
                    item.ModifiedBy = currentUser.UserID;
                    item.ModifiedDate = DateTime.Today;
                }
                if (item.CalibrationAudiances.Count > 0)
                {
                    foreach(CalibrationAudiance calibrationAudiance in item.CalibrationAudiances)
                    if (calibrationAudiance.IsNew == true)
                    {
                        calibrationAudiance.CreatedBy = currentUser.UserID;
                        calibrationAudiance.CreatedDate = DateTime.Today;
                    }
                    else
                    {
                        calibrationAudiance.ModifiedBy = currentUser.UserID;
                        calibrationAudiance.ModifiedDate = DateTime.Today;
                    }
                }
                new CalibrationService().Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpPost]
        [Route("saveCalibrationEss")]
        public ActionResult SaveCalibrationEss(Calibration item)
        {
            try
            {
                CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

                if (item.IsNew == true)
                {
                    item.CreatedBy = currentUser.UserID;
                    item.CreatedDate = DateTime.Today;
                }
                else
                {
                    item.ModifiedBy = currentUser.UserID;
                    item.ModifiedDate = DateTime.Today;
                }
                new CalibrationService().SaveCalibrationEss(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpPost]
        [Route("deleteCalibration")]
        public ActionResult DeleteCalibration(Calibration item)
        {
            try
            {
                new CalibrationService().Delete(item.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getEmployeeWithRatings/{pmpYearId}/{ratingStr}")]
        public ActionResult GetEmployeeWithRatings(int pmpYearId, string ratingStr)
        {
            DataSet ds = new DataSet();
            try
            {
                ds = new CalibrationService().GetEmployeeWithRatings(pmpYearId, ratingStr);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ds.Tables[0]);
        }


        #endregion Calibration

        #region CalibrationAudiance
        [HttpGet]
        [Route("getCalibrationAudianceByCalibrationId/{calibrationId}")]
        public ActionResult getCalibrationAudianceByCalibrationId(int calibrationId)
        {
            List<CalibrationAudiance> items = new List<CalibrationAudiance>();
            try
            {
                //items = new CalibrationAudianceService().Get(calibrationId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }
        #endregion

        #region PMPValueBehavior


        [HttpGet]
        [Route("getPMPValueBehaviors")]
        public ActionResult getPMPValueBehaviors()
        {
            List<PMPValueBehavior> oPMPValueBehavior = new List<PMPValueBehavior>();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int payrollTypeId = currentUser.PayrollTypeID.GetValueOrDefault();
            try
            {
                oPMPValueBehavior = _pmpValueBehaviorService.Get(EnumStatus.Regardless);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(oPMPValueBehavior);
        }

        [HttpGet]
        [Route("getPMPValueBehaviors/{pmpYearId}/{employeeId}")]
        public ActionResult getPMPValueBehaviors(int pmpYearId, int employeeId)
        {
            List<PMPValueBehavior> oPMPValueBehaviors = new List<PMPValueBehavior>();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int payrollTypeId = currentUser.PayrollTypeID.GetValueOrDefault();

            List<PMPValueBehaviorSetting> oPMPValueBehaviorSettings = null;

            DataRow oDR = null;
            DataTable oPMPValueBehaviorsDT = new DataTable();
            oPMPValueBehaviorsDT.Columns.Add("Id", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("PMPValueBehaviorSettingID", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("Code", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("Name", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("Description", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("Question", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("ParentID", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("Tier", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("PayrollTypeID", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("TargetRating", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("EmpComments", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("EmpCommentsDate", typeof(DateTime));

            oPMPValueBehaviorsDT.Columns.Add("MyEmpRating", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("MyEmpComments", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("MyEmpCommentsDate", typeof(DateTime));
            oPMPValueBehaviorsDT.Columns.Add("MyLMRating", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("MyLMComments", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("MyLMCommentDate", typeof(DateTime));

            oPMPValueBehaviorsDT.Columns.Add("YeEmpRating", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("YeEmpComments", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("YeEmpCommentsDate", typeof(DateTime));

            oPMPValueBehaviorsDT.Columns.Add("YeLMRating", typeof(int));
            oPMPValueBehaviorsDT.Columns.Add("YeLMComments", typeof(string));
            oPMPValueBehaviorsDT.Columns.Add("YeLMCommentDate", typeof(DateTime));

            int count = 0;

            try
            {
                int maxTire = Convert.ToInt32(new SystemConfigarationService().GetconfigValue(EnumConfigurationType.Logic, "pmpvaluebehavior", "tier"));

                oPMPValueBehaviors = _pmpValueBehaviorService.Get(EnumStatus.Regardless);
                ObjectiveSet oObjectiveSet = _objectiveSetService.GetByEmployeeID(employeeId, pmpYearId);

                if (oObjectiveSet != null)
                {
                    oPMPValueBehaviorSettings = _pmpValueBehaviorSettingService.GetByObjectiveSetID(oObjectiveSet.ID);
                }

                foreach (PMPValueBehavior item in oPMPValueBehaviors)
                {
                    oDR = oPMPValueBehaviorsDT.NewRow();
                    oDR["Id"] = item.ID;
                    oDR["Code"] = item.Code;
                    oDR["Name"] = item.Name;
                    oDR["Description"] = item.Description;
                    oDR["Question"] = item.Question;
                    if(item.ParentID != null)
                        oDR["ParentID"] = item.ParentID;
                    oDR["Tier"] = item.Tier;
                    oDR["PayrollTypeID"] = item.PayrollTypeID;
                    if (maxTire == item.Tier)
                    {
                        if (oPMPValueBehaviorSettings != null && oPMPValueBehaviorSettings.Count > 0)
                        {
                            foreach (PMPValueBehaviorSetting oPMPValueBehaviorSettingItem in oPMPValueBehaviorSettings)
                            {
                                if (item.ID == oPMPValueBehaviorSettingItem.PMPValueBehaviorID)
                                {
                                    oDR["PMPValueBehaviorSettingID"] = oPMPValueBehaviorSettingItem.ID;
                                    oDR["TargetRating"] = oPMPValueBehaviorSettingItem.TargetRating;
                                    oDR["EmpComments"] = oPMPValueBehaviorSettingItem.EmpComments;
                                    if (oPMPValueBehaviorSettingItem.EmpCommentsDate != null)
                                        oDR["EmpCommentsDate"] = oPMPValueBehaviorSettingItem.EmpCommentsDate;

                                    //if(oPMPValueBehaviorSettingItem.MyEmpRating != null)
                                    //    oDR["MyEmpRating"] = oPMPValueBehaviorSettingItem.MyEmpRating;
                                    if (oPMPValueBehaviorSettingItem.MyEmpComments != null) 
                                        oDR["MyEmpComments"] = oPMPValueBehaviorSettingItem.MyEmpComments;
                                    if (oPMPValueBehaviorSettingItem.MyEmpCommentsDate != null) 
                                        oDR["MyEmpCommentsDate"] = oPMPValueBehaviorSettingItem.MyEmpCommentsDate;

                                    //if(oPMPValueBehaviorSettingItem.MyLMRating != null)
                                    //    oDR["MyLMRating"] = oPMPValueBehaviorSettingItem.MyLMRating;
                                    if (oPMPValueBehaviorSettingItem.MyLMComments != null) 
                                        oDR["MyLMComments"] = oPMPValueBehaviorSettingItem.MyLMComments;
                                    if (oPMPValueBehaviorSettingItem.MyLMCommentDate != null) 
                                        oDR["MyLMCommentDate"] = oPMPValueBehaviorSettingItem.MyLMCommentDate;

                                    if(oPMPValueBehaviorSettingItem.YeEmpRating != null)
                                        oDR["YeEmpRating"] = oPMPValueBehaviorSettingItem.YeEmpRating;
                                    if (oPMPValueBehaviorSettingItem.YeEmpComments != null) 
                                        oDR["YeEmpComments"] = oPMPValueBehaviorSettingItem.YeEmpComments;
                                    if (oPMPValueBehaviorSettingItem.YeEmpCommentsDate != null) 
                                        oDR["YeEmpCommentsDate"] = oPMPValueBehaviorSettingItem.YeEmpCommentsDate;

                                    if (oPMPValueBehaviorSettingItem.YeLMRating != null) 
                                        oDR["YeLMRating"] = oPMPValueBehaviorSettingItem.YeLMRating;
                                    if (oPMPValueBehaviorSettingItem.YeLMComments != null) 
                                        oDR["YeLMComments"] = oPMPValueBehaviorSettingItem.YeLMComments;
                                    if (oPMPValueBehaviorSettingItem.YeLMCommentDate != null) 
                                        oDR["YeLMCommentDate"] = oPMPValueBehaviorSettingItem.YeLMCommentDate;
                                }
                            }
                        }
                    }
                    oPMPValueBehaviorsDT.Rows.Add(oDR);

                    count++;
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(oPMPValueBehaviorsDT);
        }

        #endregion PMPValueBehavior


        #region DevelopmentPlan

        [HttpPost]
        [Route("saveDevelopmentPlan")]
        public ActionResult SaveDevelopmentPlan(DevelopmentPlan item)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            item.EmployeeID = currentUser.EmployeeID.GetValueOrDefault();

            int ans;
            try
            {
                ObjectiveSet objectiveSet = _objectiveSetService.GetByEmployeeID(item.EmployeeID, item.PMPYearID);
                item.ObjectiveSetID = objectiveSet.ID;

                ans = _developmentPlanService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpGet]
        [Route("getDevelopmentPlansEmployee/{pmpYearId}/{currentYear}")]
        public ActionResult GetDevelopmentPlan(int pmpYearId, bool currentYear)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();

            List<DevelopmentPlan> items = null;
            try
            {
                if (currentYear)
                {
                    ObjectiveSet objectiveSet = _objectiveSetService.GetByEmployeeID(employeeId, pmpYearId);
                    if (objectiveSet != null)
                        items = _developmentPlanService.GetByObjectiveSetId(objectiveSet.ID);
                }
                else
                {
                    //items = _developmentPlanService.GetPreviousYears(employeeId, pmpYearId);
                    items = _developmentPlanService.GetPreviousYears(employeeId, _pmpProcessService.GetByPMPProcessID(pmpYearId).PmpYear);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getDevelopmentPlansEmployee/{employeeId}/{pmpYearId}/{currentYear}")]
        public ActionResult GetDevelopmentPlan(int employeeId, int pmpYearId, bool currentYear)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

            List<DevelopmentPlan> items = null;
            try
            {
                if (currentYear)
                {
                    ObjectiveSet objectiveSet = _objectiveSetService.GetByEmployeeID(employeeId, pmpYearId);
                    if (objectiveSet != null)
                        items = _developmentPlanService.GetByObjectiveSetId(objectiveSet.ID);
                }
                else
                {
                    items = _developmentPlanService.GetPreviousYears(employeeId, pmpYearId);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        #endregion DevelopmentPlan

        #region PMPValueBehaviorSetting

        [HttpPost]
        [Route("savePMPValueBehaviorSetting")]
        public ActionResult SavePMPValueBehaviorSetting(List<PMPValueBehaviorSetting> items)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            //item.EmployeeID = currentUser.EmployeeID.GetValueOrDefault();

            int ans;
            try
            {
                //ObjectiveSet objectiveSet = _objectiveSetService.GetByEmployeeID(item.EmployeeID, item.PMPYearID);
                //item.ObjectiveSetID = objectiveSet.ID;

                //ans = _developmentPlanService.Save(item);
                _pmpValueBehaviorSettingService.Save(items);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }
        #endregion PMPValueBehaviorSetting



        [HttpGet]
        [Route("getTrainingNeedAnalysis/{pmpYearId}")]
        public ActionResult GetTrainingNeedAnalysis(int pmpYearId)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            List<DevelopmentPlan> items = null;
            List<Employee> employees = new List<Employee>();
            try
            {
                items = _developmentPlanService.GetByPmpYearId(pmpYearId);
                employees = _EmployeeService.GetAllEmps();
                int? payrolltypeid = null;
                if (currentUser.PayrollTypeID != null)
                    payrolltypeid = (int)currentUser.PayrollTypeID;

                if (payrolltypeid != null)
                {
                    List<Grade> grades = new GradeService().Get(EnumStatus.Regardless, (int)payrolltypeid);
                    List<Designation> designations =
                        new DesignationService().Get(EnumStatus.Regardless, (int)payrolltypeid);
                    List<Department> departments =
                        new DepartmentService().Get(EnumStatus.Regardless, (int)payrolltypeid);

                    items.ForEach(x =>
                    {
                        var employee = employees.FirstOrDefault(d => d.ID == x.EmployeeID);
                        x.EmployeeName = employee.Name;
                        x.EmployeeNo = employee.EmployeeNo;
                        var designation = designations.FirstOrDefault(d => d.ID == employee.DesignationID);
                        if (designation != null)
                            x.DesignationName = designation.Name;
                        var department = departments.FirstOrDefault(d => d.ID == employee.DepartmentID);
                        if (department != null)
                            x.DepartmentName = department.Name;
                    });
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpGet]
        [Route("getTrainingNeedAnalysisCount/{pmpYearId}")]
        public ActionResult GetTrainingNeedAnalysisCount(int pmpYearId)
        {
            DataSet ds = new DataSet();
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            int employeeId = currentUser.EmployeeID.GetValueOrDefault();
            try
            {
                ds = _developmentPlanService.GetTrainingNeedAnalysisCount(pmpYearId);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ds.Tables[0]);
        }

        [HttpGet]
        [Route("getsuccessionroles")]
        public ActionResult GetSuccessionRoles()
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            List<SuccessionRole> roles = new List<SuccessionRole>();
            try
            {
                roles = _successionRoleService.Get(EnumStatus.Active, (int)currentUser.PayrollTypeID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(roles);
        }

        [HttpPost]
        [Route("saveSuccessionPlanning")]
        public ActionResult saveSuccessionPlanning(SuccessionPlanning item)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            // item.EmployeeID = currentUser.EmployeeID.GetValueOrDefault();

            int ans;
            try
            {
                item.PlanningYear = DateTime.Now;
                item.CreatedBy = currentUser.UserID;
                item.CreatedDate = DateTime.Now;
                ans = _successionPlanningService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpGet]
        [Route("getsuccessionplanning")]
        public ActionResult Getsuccessionplanning()
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            //List<SuccessionRole> roles = new List<SuccessionRole>();
            List<SuccessionPlanning> plannings = new List<SuccessionPlanning>();
            List<Employee> employees = new List<Employee>();
            try
            {
                List<Designation> designations = new DesignationService().Get(EnumStatus.Regardless, (int)currentUser.PayrollTypeID);
                employees = _employeeService.GetAllEmps();
                plannings = _successionPlanningService.Get();
                if (plannings != null && plannings.Count > 0)
                {
                    foreach (SuccessionPlanning plan in plannings)
                    {
                        var employee = new Employee();
                        employee = employees.Find(x => x.ID == plan.EmployeeID);
                        plan.EmployeeName = employee.Name;
                        if (employee.Status == EnumEmployeeStatus.Discontinued)
                            plan.IsDiscontinueEmployee = true;
                        else
                            plan.IsDiscontinueEmployee = false;
                        plan.DesignationName= designations?.Find(y=>y.ID == employee.ID)?.Name;


                        var successionOne = new Employee();
                        successionOne = employees.Find(x => x.ID == plan.SuccessorOneID);
                        plan.SuccessionOneName = successionOne.Name;
                        if (successionOne.Status == EnumEmployeeStatus.Discontinued)
                            plan.IsDiscontinueOne = true;
                        else
                            plan.IsDiscontinueOne = false;
                        plan.SuccessionOneDesignation = designations?.Find(y => y.ID == successionOne.ID)?.Name;

                        var successionTwo = new Employee();
                        successionTwo = employees.Find(x => x.ID == plan.SuccessorTwoID);
                        plan.SuccessionTwoName = successionTwo.Name;
                        if (successionOne.Status == EnumEmployeeStatus.Discontinued)
                            plan.IsDiscontinueTwo = true;
                        else
                            plan.IsDiscontinueTwo = false;
                        plan.SuccessionTwoDesignation = designations?.Find(y => y.ID == successionTwo.ID)?.Name;

                    }
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(plannings);
        }

        [HttpPost]
        [Route("deleteSuccessionPlanning")]
        public ActionResult DeleteSuccessionPlanning(SuccessionPlanning item)
        {
            try
            {
                _successionPlanningService.Delete(item.ID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok();
        }

        [HttpGet]
        [Route("getSecondLineManagerData")]
        public ActionResult getSecondLineManagerData()
        {
            DataTable dt = new DataTable();
            dt.Columns.Add("EmployeeId", typeof(int));
            dt.Columns.Add("EmployeeNo", typeof(string));
            dt.Columns.Add("EmployeeName", typeof(string));
            dt.Columns.Add("LineManagerID", typeof(int));
            dt.Columns.Add("LineManager", typeof(string));
            dt.Columns.Add("EmpRating", typeof(double));
            dt.Columns.Add("LmRating", typeof(double));
            dt.Columns.Add("YEEmpComplete", typeof(string));
            dt.Columns.Add("YELMComplete", typeof(string));
            dt.Columns.Add("YeTotalObjectiveEmpMark", typeof(double));
            dt.Columns.Add("YeTotalObjectiveLmMark", typeof(double));

            //List<SearchEmployee> oEmployees = null;
            List<Employee> myTeam = null;
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            try
            {
                List<Employee> allEmployees = new EmployeeService().GetAllEmps();
                //oEmployees = new SearchEmployeeService().GetTeam((int)currentUser.EmployeeID, EnumStatus.Active);
                List<Employee> oEmployees = new EmployeeService().GetSubordinatesByLineManager((int)currentUser.EmployeeID).FindAll(x => x.Status == EnumEmployeeStatus.Live);
                myTeam = oEmployees.ToList();

                foreach (Employee emp in oEmployees)
                {
                    foreach (Employee item in allEmployees.FindAll(x => x.LineManagerID == emp.ID).FindAll(x => x.Status == EnumEmployeeStatus.Live))
                    {
                        myTeam.Add(item);
                    }
                }
                //PMPProcess oPMPProcess = _pmpProcessService.GetCurrentPMPYear(false);

                List<ObjectiveSet> oObjectiveSets = _objectiveSetService.GetByPMPYear(_pmpProcessService.GetCurrentPMPYear(false).ID, null);


                DataRow dr = null;
                int count = 0;

                foreach(Employee item in myTeam)
                {
                    dr = dt.NewRow();
                    dr["EmployeeId"] = item.ID;
                    dr["EmployeeNo"] = item.EmployeeNo;
                    dr["EmployeeName"] = item.Name;
                    if(item.LineManagerID != null)
                    {
                        dr["LineManagerID"] = item.LineManagerID;
                        dr["LineManager"] = allEmployees.Find(x => x.ID == item.LineManagerID).Name;
                    }

                    ObjectiveSet objectiveSet = oObjectiveSets.Find(x => x.EmployeeID == item.ID);
                    if(objectiveSet != null)
                    {
                        dr["EmpRating"] = objectiveSet.EMPOverallRating;
                        dr["LmRating"] = objectiveSet.LMOverallRating;
                        if(objectiveSet.YeTotalObjectiveEmpMark != null)
                            dr["YeTotalObjectiveEmpMark"] = objectiveSet.YeTotalObjectiveEmpMark;
                        if (objectiveSet.YeTotalObjectiveLmMark != null)
                            dr["YeTotalObjectiveLmMark"] = objectiveSet.YeTotalObjectiveLmMark;

                        dr["YEEmpComplete"] = objectiveSet.YEEmpComplete.ToString().Replace('_', ' ');
                        dr["YELMComplete"] = objectiveSet.YELMComplete.ToString().Replace('_', ' ');
                    }

                    dt.Rows.Add(dr);
                    count++;
                }

            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(dt);
        }

        [HttpGet]
        [Route("getPMSObjectiveProgressHistory/{objectiveID}/{employeeID}")]
        public ActionResult GetPMSObjectiveProgressHistory(int objectiveID, int employeeID)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);
            List<PMSObjectiveProgress> items = new List<PMSObjectiveProgress>();
            try
            {
                items = _pmsObjectiveProgressService.GetByObjectiveID(objectiveID, employeeID);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(items);
        }

        [HttpPost]
        [Route("savePMSObjectiveProgressHistory")]
        public ActionResult savePMSObjectiveProgressHistory(PMSObjectiveProgress item)
        {
            CurrentUser currentUser = CurrentUser.GetCurrentUser(HttpContext.User);

            int ans;
            try
            {
                item.UpdateTime = DateTime.Now;
                item.CreatedBy = currentUser.UserID;
                item.CreatedDate = DateTime.Now;
                ans = _pmsObjectiveProgressService.Save(item);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }

            return Ok(ans);
        }

        [HttpPost("uploadPMSObjectiveProgressHistoryWithAttachment")]
        [AllowAnonymous]
        public ActionResult uploadPMSObjectiveProgressHistoryWithAttachment()
        {
            PMSObjectiveProgressAttachment item = new PMSObjectiveProgressAttachment();
            string base64String = "";

            try
            {
                var fdata = Request.Form.Files["fileData"];
                //Upload Image
                item.PMSObjectiveProgressID= Convert.ToInt32(Request.Form["pmsObjectiveProgressID"]);
                item.FileName = Convert.ToString(Request.Form["fileName"]);
                item.FileType = Convert.ToInt32(Request.Form["filetype"]);
                string employeeNo = Convert.ToString(Request.Form["employeeNo"]);

                using (var ms = new MemoryStream())
                {
                    fdata.CopyTo(ms);
                    item.FileData = ms.ToArray();
                    item.FileName = employeeNo.ToString() + "-" + fdata.FileName.ToString();//$" {Path.GetExtension(fdata.FileName)}";
                    item.UploadTime = DateTime.Now;
                    byte[] textAsBytes = ms.ToArray();
                    this._pmsObjectiveProgressAttachmentService.Save(item);
                    base64String = Convert.ToBase64String(textAsBytes);
                }
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
            }


            return Ok(base64String);
        }

        [HttpGet("GetPMSObjectiveProgressHistoryWithAttachment/{pmsObjectiveProgressID}")]
        public ActionResult GetPMSObjectiveProgressHistoryWithAttachment(int pmsObjectiveProgressID)
        {
            PMSObjectiveProgressAttachment item = new PMSObjectiveProgressAttachment();


            item = this._pmsObjectiveProgressAttachmentService.GetbyPMSObjectiveProgressID(pmsObjectiveProgressID);
            if (item != null)
            {
                byte[] textAsBytes = (byte[])item.FileData;
                string base64String = "";
                if (item != null)
                {
                    base64String = Convert.ToBase64String(textAsBytes);
                }

                return Ok(base64String);
            }
            else return Ok("");
        }
    }
}