C# TransactionResponse.setSuccess方法代码示例

    /**
     * Return list of vacancy which have this status.
     */
    public static TransactionResponse getAllActiveVacancy(string status)
    {
        TransactionResponse response = new TransactionResponse();
        IDictionary<string, object> statusParams = new Dictionary<string, object>();
        statusParams.Add("@status", status);
        statusParams.Add("@districtId", PageAccessManager.getDistrictID());

        //Pass Stored Procedure Name and parameter list.
        DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spAllActiveVacancy, statusParams);
        try
        {
            DataTable dataTable = dpOperation.getRecord();

            response.Data = dataTable;
            response.setSuccess(true);
        }
        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setSuccess(false);
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.M_UNKNOWN_EVIL_ERROR);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            LoggerManager.LogError(ex.ToString(), logger);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

 public static void upDateWithGenericErrorMessage(TransactionResponse response)
 {
     //Display generic message.
     response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
     response.setMessage(DBOperationErrorConstants.M_SYSTEM_ENCOUNTERED_UNKNOWN_ERROR);
     response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_EVIL_ERROR);
     response.setSuccess(false);
 }

    public static TransactionResponse getDistrictSettingValue(string paramTag)
    {
        TransactionResponse response = new TransactionResponse();

        IDictionary<string, object> argumentsMap = new Dictionary<string, object>();
        argumentsMap.Add("@paramter_tag", paramTag);
        argumentsMap.Add("@districtID", PageAccessManager.getDistrictID());

        //Pass Stored Procedure Name and parameter list.
        DBOperationsUtil dbOperation = new DBOperationsUtil(DbAccessConstants.spGetDistrictSetting, argumentsMap);
        try
        {
            DataTable dataTable = dbOperation.getRecord();
            if (dataTable != null)
            {
                foreach (DataRow row in dataTable.Rows)
                {
                    //put the data on Transaction reponse
                    response.Data = row["parameter_value"].ToString();
                    response.setSuccess(true);
                    return response;
                }
            }
            response.Data = PARAMETER_NOT_DEFINED + DBOperationErrorConstants.CONTACT_ADMIN;
            response.setSuccess(false);
            return response;
        }
        catch (SqlException ex)
        {
            response.Data = PARAMETER_NOT_DEFINED + DBOperationErrorConstants.CONTACT_ADMIN;
            response.setSuccess(false);
            return response;
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            LoggerManager.LogError(ex.ToString(), logger);
            response.Data = PARAMETER_NOT_DEFINED + DBOperationErrorConstants.CONTACT_ADMIN;
            response.setSuccess(false);
            return response;
        }
    }

    public static TransactionResponse getAllNotificationsForCurrentEmployee(MembershipUser currentUser)
    {
        //get detail of the logged on user.
        Employee employee = EmployeeManager.getLoggedOnUser((Guid)currentUser.ProviderUserKey);

        if (employee == null)
        {
            return EmployeeManager.handleLoggedInUserCanNotBeIdentfied();
        }

        TransactionResponse response = new TransactionResponse();
        try
        {
            IDictionary<string, object> employeeIdMap = new Dictionary<string, object>();
            employeeIdMap.Add("@EMP_ID", employee.EmpID);
            employeeIdMap.Add("@destrictID", PageAccessManager.getDistrictID());

            //Pass Stored Procedure Name and parameter list.
            DBOperationsUtil dbOperation = new DBOperationsUtil(DbAccessConstants.spGetAllNotificationForTheCurrentEmployee, employeeIdMap);
            DataTable dataTable = dbOperation.getRecord();
            //put the data on Transaction response
            response.Data = dataTable;
            response.setSuccess(true);
            response.setMessageType(TransactionResponse.SeverityLevel.INFO);
            response.setMessage(DBOperationErrorConstants.M_NOTIFICATION_INFO);
            //get Notifications inside the TransactionResponse.
            return response;
        }
        catch (SqlException ex)
        {
            response.setErrorCode(DBOperationErrorConstants.E_ERROR_WHILE_READING_NOTIFICATION);
            response.setMessage(DBOperationErrorConstants.M_ERROR_WHILE_READING_NOTIF);
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setSuccess(false);
            return response;
        }

           //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            LoggerManager.LogError(ex.ToString(), logger);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_EVIL_ERROR);
            response.setMessage(DBOperationErrorConstants.M_UNKNOWN_EVIL_ERROR);
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setSuccess(false);
            return response;
        }
    }

    private TransactionResponse sendInsertPromotionToDb(string spName, IDictionary<string, object> parameters)
    {
        //Pass Stored Procedure Name and parameter list. 
        DBOperationsUtil storeToDb = new DBOperationsUtil(spName, parameters);

        TransactionResponse response = new TransactionResponse();
        try
        {
            //call store to DB mathod and get reponse. 
            storeToDb.instertNewRecord();
            response.setSuccess(true);
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
            response.setMessage(DBOperationErrorConstants.M_PROMOTION_REGISTER_OK);
        }

        catch (SqlException ex) 
        {
            //Determine if the cause was duplicate KEY.
            if (ex.ToString().Contains(DBOperationErrorConstants.PK_DUPLICATE_INDICATOR))
            {
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_DUPLICATE_PROMOTION_KEY_ERROR);
                response.setErrorCode(DBOperationErrorConstants.E_DUPLICATE_KEY_ERROR);
            }
            else
            {
                //Other SqlException is catched
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_UNKNOWN_ERROR_APP_RATING_REGISTER);
                response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            }
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {            
            //Write this exception to file for investigation of the issue later. 
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }

        return response;
    }

    public TransactionResponse addNewPromotionAssignment()
    {
        //Add List of Arguments for new promotion Assigment
        IDictionary<string, object> promotionAssigmentParameters = new Dictionary<string, object>();

        promotionAssigmentParameters.Add("@minNo", promotionAssigment.MinuteNo);
        promotionAssigmentParameters.Add("@hROfficerID", promotionAssigment.HROfficerID);
        promotionAssigmentParameters.Add("@deadLine", promotionAssigment.DeadLine);
        promotionAssigmentParameters.Add("@remark", promotionAssigment.Remark);

        //Pass Stored Procedure Name and parameter list.
        DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spAddPromotionAssignmentToHROfficer, promotionAssigmentParameters);
        TransactionResponse response = new TransactionResponse();
        try
        {
            //call update to DB mathod and get reponse.
            dpOperation.updateRecord();
            response.setSuccess(true);
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
            response.setMessage(DBOperationErrorConstants.M_VACANCY_ASSIGNED_SUCCESS);
        }

        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.PK_DUPLICATE_INDICATOR + ". "+ DBOperationErrorConstants.M_DUPLICATE_PROMOTION_ASSIGNEMENT);
            response.setErrorCode(DBOperationErrorConstants.E_PROMOTION_ASSIGNEMETN_FAILED);
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

    /**
     * Get applicant result after checking done, or while interview or exam result is entering
     */
    public TransactionResponse getApplicantPassedToSecPhase(Vacancy vacancy)
    {
        TransactionResponse response = new TransactionResponse();
        try
        {
            //Add List of Arguments for new employee
            IDictionary<string, object> parameters = new Dictionary<string, object>();
            parameters.Add("@vacancyNo", vacancy.VacancyNo);
            parameters.Add("@vacancyDate", vacancy.PostedDate);

            DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spGetApplicantPassedToSecPhase, parameters);

            DataTable appResult = dpOperation.getRecord();

            response.Data = appResult;
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
            response.setMessage(DBOperationErrorConstants.M_REPORT_GENERATED_SUCCESS);
            response.setSuccess(true);
            return response;
        }
        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.M_UNABLE_TO_APPLICANT_RESULT);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            response.setSuccess(false);
        }
        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

    public TransactionResponse DeleteApplicat(Vacancy vacancy, string eid)
    {
        TransactionResponse response = new TransactionResponse();

        try
        {
            //Add List of Arguments for new employee @EID
            IDictionary<string, object> parameters = new Dictionary<string, object>();

            parameters.Add("@vacancy_No", vacancy.VacancyNo);
            parameters.Add("@vancacy_Date", vacancy.PostedDate);
            parameters.Add("@EID", eid);

            //get report for the Processor
            DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spDeleteApplicant, parameters);
            DataTable dataTable = dpOperation.getRecord();

            response.Data = dataTable;
            response.setSuccess(true);
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
        }
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

    /**
        * Ranks applicants according to their total evaluation result.
        * If 2 applicants have the same evaluation result the same rank will be given to them
        * and the next rank will be skipped
        * example: Applicants in their evaluation result order: A, B|C, D
        * -------> if Applicant B and C have the same evaluation result
        * -------> The Rank will be:
        * -------> A = 1
        * -------> B = 2
        * -------> C = 2
        * -------> D = 4  <- (rank 3 is skipped)
        */
    private TransactionResponse rankApplicants(DataTable updateApplRegComplete, TransactionResponse response)
    {
        int rankCount = 1;
        int count = 1;
        float subTot = 0;
        float tempSubTot = 0;
        bool firstTimeIteration = true;
        bool isAllApplicantDataValid = true;
        string applicantWithInValidEvaluationData = "";

        foreach (DataRow row in updateApplRegComplete.Rows)
        {
            //case of the 1st rank
            if (firstTimeIteration)
            {
                row["rank"] = rankCount;

                //get the subTotal of the current applicant
                if (row["Total"] != null && !row["Total"].ToString().Equals(""))
                {
                    subTot = float.Parse(row["Total"].ToString(), CultureInfo.InvariantCulture.NumberFormat);
                }

                //not first time interaction any more
                firstTimeIteration = false;

                //Evaluation result can not be less than 1. why?
                if (subTot < 1 || row["Total"] == null || row["Total"].ToString().Equals(""))
                {
                    isAllApplicantDataValid = false;
                    //applicantWithInValidEvaluationData = "Applicant: " + row["Full Name"]
                    //                                     + " doesn't have valid evaluation result = " + row["Total"]
                    //                                     + " Please correct this evaluation and generate the report again ";
                    applicantWithInValidEvaluationData = "Applicant: " + row["First Name"] + " " + row["Middle Name"] + " " + row["Last Name"] + " [" + row["Employee ID"] + "]"
                                                            + " doesn't have valid evaluation result = " + row["Total"]
                                                            + " Please correct this evaluation and generate the report again ";
                    break;
                }
            }

            else
            {
                tempSubTot = 0;
                if (row["Total"] != null && !row["Total"].ToString().Equals(""))
                {
                    tempSubTot = float.Parse(row["Total"].ToString(), CultureInfo.InvariantCulture.NumberFormat);
                }

                //Different result, use the next available rank	and update the subTot to the new result.
                if (tempSubTot > 0 && subTot > 0 && subTot != tempSubTot)
                {
                    rankCount = count;
                    subTot = tempSubTot;
                }

                //Otherwise it is same result, so keep the rank
                row["rank"] = rankCount;

                //Evaluation result can not be less than 1.
                if (tempSubTot < 1 || row["Total"] == null || row["Total"].ToString().Equals(""))
                {
                    isAllApplicantDataValid = false;
                    //applicantWithInValidEvaluationData = "Applicant: " + row["Full Name"]
                    applicantWithInValidEvaluationData = "Applicant: " + row["First Name"] + " " + row["Middle Name"] + " " + row["Last Name"] + " [" + row["Employee ID"] + "]"
                                                         + " doesn't have valid evaluation result = " + row["Total"]
                                                         + " Please correct this evaluation and generate the report again ";
                    break;
                }
            }
            ++count;
        }

        if (!isAllApplicantDataValid)
        {
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(applicantWithInValidEvaluationData);
            response.setSuccess(false);
            return response;
        }

        //rank given to each applicants and the data is ready.
        //set it inside the transaction response
        response.Data = updateApplRegComplete;

        response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
        response.setMessage(DBOperationErrorConstants.M_VACANCY_EVALUTION_RESULT_GENERATED_SUCCESS);
        response.setSuccess(true);
        return response;
//.........这里部分代码省略.........

    /**
     * Get Inactive employee by date interval
     */
    public TransactionResponse getInactiveEmployeeResult(string startedDate, string endDate)
    {
        TransactionResponse response = new TransactionResponse();
        try
        {
            //Add List of Arguments for new employee
            IDictionary<string, object> parameters = new Dictionary<string, object>();
            parameters.Add("@startDate", startedDate);
            parameters.Add("@endDate", endDate);

            DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spGetInactiveEmployeeDetail, parameters);

            DataTable getResult = dpOperation.getRecord();
            if (getResult != null && getResult.Rows.Count > 0)
            {
                response.Data = getResult;
                response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
                response.setMessage(DBOperationErrorConstants.M_REPORT_GENERATED_SUCCESS);
                response.setSuccess(true);
                return response;
            }
            else
            {
                response.setMessageType(TransactionResponse.SeverityLevel.INFO);
                response.setMessage(DBOperationErrorConstants.M_GENERATE_INACTIVE_EMPLOYEE_REPORT_EMPTY);
                response.setSuccess(false);
                return response;
            }
        }
        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.M_UNABLE_TO_GENERATE_INACTIVE_EMPLOYEE);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            response.setSuccess(false);
        }
        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

    /**
     * calls Store to DB utility for the current employee.
     */
    public TransactionResponse AddHROfficerOrClerk(string SPName, string EmpID)
    {
        //Add List of Arguments for new employee
        IDictionary<string, object> paramater = new Dictionary<string, object>();

        paramater.Add("@Emp_ID", EmpID);

        //Pass Stored Procedure Name and parameter list.
        DBOperationsUtil storeToDb = new DBOperationsUtil(SPName, paramater);

        TransactionResponse response = new TransactionResponse();

        //call store to DB mathod and get reponse.
        try
        {
            storeToDb.instertNewRecord();
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
            response.setSuccess(true);
            response.setMessage(DBOperationErrorConstants.M_HR_OFFICER_REGISTER_OK);
        }

        catch (SqlException ex)
        {
            //Determine if the cause was duplicate KEY.
            if (ex.ToString().Contains(DBOperationErrorConstants.PK_DUPLICATE_INDICATOR))
            {
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_DUPLICATE_EID_KEY_ERROR);
                response.setErrorCode(DBOperationErrorConstants.E_DUPLICATE_KEY_ERROR);
            }
            else
            {
                //Other SqlException is catched
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_UNKNOWN_ERROR_EMP_REGISTER);
                response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            }
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }

        return response;
    }

    /**
     * Add employee remark
    */
    public TransactionResponse storeEmployeeremark(MembershipUser currentUser)
    {
        //get detail of the logged on user.
        Employee employee = EmployeeManager.getLoggedOnUser((Guid)currentUser.ProviderUserKey);
        if (employee == null)
        {
            return EmployeeManager.handleLoggedInUserCanNotBeIdentfied();
        }

        //Add List of Arguments for new employee
        IDictionary<string, object> employeeRemarkMap = new Dictionary<string, object>();

        employeeRemarkMap.Add("@EmpID", employeeRemark.EmployeeID);
        employeeRemarkMap.Add("@remarkRefNo", employeeRemark.RemarkReferanceNo);
        employeeRemarkMap.Add("@dateOfRemark", employeeRemark.DateOfRemark);
        employeeRemarkMap.Add("@remarkType", employeeRemark.RemarkType);
        employeeRemarkMap.Add("@penalityPerc", employeeRemark.PenaltyPerc);
        employeeRemarkMap.Add("@managerID", employeeRemark.ManagerID);
        employeeRemarkMap.Add("@managerPosition", employeeRemark.ManagerPosition);
        employeeRemarkMap.Add("@remarkReason", employeeRemark.RemarkReason);
        employeeRemarkMap.Add("@responsiblehrOfficerID", employee.EmpID);
        employeeRemarkMap.Add("@Branch", employeeRemark.Branch);

        //Pass Stored Procedure Name and parameter list.
        DBOperationsUtil storeToDb = new DBOperationsUtil(DbAccessConstants.spAddEmployeeRemark, employeeRemarkMap);

        TransactionResponse response = new TransactionResponse();

        //call store to DB mathod and get reponse.
        try
        {
            storeToDb.instertNewRecord();
            response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
            response.setSuccess(true);
            response.setMessage(DBOperationErrorConstants.M_EMPLOYEE_REMARK_REGISTER_OK);
        }

        catch (SqlException ex)
        {
            //Determine if the cause was duplicate KEY.
            if (ex.ToString().Contains(DBOperationErrorConstants.PK_DUPLICATE_INDICATOR))
            {
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_DUPLICATE_REF_NO_KEY_ERROR);
                response.setErrorCode(DBOperationErrorConstants.E_DUPLICATE_KEY_ERROR);
            }
            else
            {
                //Other SqlException is catched
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_UNKNOWN_ERROR_EMP_REGISTER);
                response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            }
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            logException(ex);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }

        return response;
    }

    //this methode is used to update vacancy status from profile arrived to readvertise
    //and also set profile arrived & applicant registeration to NULL
    public TransactionResponse updateVacancyStatusToReadvertiseFromProfileArrived()
    {
        TransactionResponse response = new TransactionResponse();
        bool isUpdated = false;
        try
        {
            try
            {
                //Add List of Arguments for new employee
                IDictionary<string, object> parameters = new Dictionary<string, object>();
                parameters.Add("@vacancy_No", vacancy.VacancyNo.Trim());
                parameters.Add("@posted_date ", vacancy.PostedDate.Trim());
                parameters.Add("@status", vacancy.Status);
                parameters.Add("@vancy_deadline", vacancy.VancyDeadline);

                DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spReadvertiseVacFromProfileArr, parameters);
                isUpdated = dpOperation.updateRecord();
            }
            //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
            catch (Exception ex)
            {
                //Write this exception to file for investigation of the issue later.
                logException(ex);
                LoggerManager.upDateWithGenericErrorMessage(response);
            }

            if (isUpdated)
            {
                response.setMessageType(TransactionResponse.SeverityLevel.SUCESS);
                response.setMessage(DBOperationErrorConstants.M_VACANCY_READVERTISED_SUCCESS);
                response.setSuccess(true);
            }
            else
            {
                response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
                response.setMessage(DBOperationErrorConstants.M_VACANCY_READVERTISED_FAIL);
                response.setErrorCode(DBOperationErrorConstants.E_VACANCY_READVERTISE_FAILED);
                response.setSuccess(true);
            }
        }
        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.M_VACANCY_READVERTISED_FAIL);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
            response.setSuccess(false);
        }
        return response;
    }

    /**
     * Return list of vacancy which have this status.
     */
    public static TransactionResponse getNotAnnouncedPromotion()
    {
        // Get a reference to the currently logged on user
        MembershipUser currentUser = Membership.GetUser();

        //get employee detail of the current user.
        Employee employee = EmployeeManager.getLoggedOnUser((Guid)currentUser.ProviderUserKey);

        TransactionResponse response = new TransactionResponse();

        //Pass Stored Procedure Name and parameter list.
        IDictionary<string, object> parameter = new Dictionary<string, object>();
        parameter.Add("@hROfficerID", employee.EmpID);
        DBOperationsUtil dpOperation = new DBOperationsUtil(DbAccessConstants.spGetNotAnnouncedPromotion, parameter);
        try
        {
            DataTable dataTable = dpOperation.getRecord();

            response.Data = dataTable;
            response.setSuccess(true);
        }
        catch (SqlException ex)
        {
            //Other SqlException is catched
            response.setSuccess(false);
            response.setMessageType(TransactionResponse.SeverityLevel.ERROR);
            response.setMessage(DBOperationErrorConstants.M_UNKNOWN_EVIL_ERROR);
            response.setErrorCode(DBOperationErrorConstants.E_UNKNOWN_ERROR_AT_DB_OOPERATION);
        }

        //CATCH ANY OTHER EXCEPTION, dont let user see any kind of unexpected error
        catch (Exception ex)
        {
            //Write this exception to file for investigation of the issue later.
            LoggerManager.LogError(ex.ToString(), logger);
            LoggerManager.upDateWithGenericErrorMessage(response);
        }
        return response;
    }

    /**
     * Return list of HR Officer processor rating report
     */
    public static TransactionResponse getHROfficerProcessorRatingReport(string EID, string startDate, string endDate)
    {
        TransactionResponse response = new TransactionResponse();

        IDictionary<string, object> parameters = new Dictionary<string, object>();
        parameters.Add("@EID", EID);
        parameters.Add("@startDate", startDate);
        parameters.Add("@endDate", endDate);

        DBOperationsUtil gvOperation = new DBOperationsUtil(DbAccessConstants.spGetHROfficerProcessorRatingReport, parameters);
        DataTable dataTable = gvOperation.getRecord();
        response.Data = dataTable;
        response.setSuccess(true);

        return response;
    }