public bool ResetTable(int Mode_Id)
        {
            int  iResult = 0;
            bool bReturn = false;

            try
            {
                SqlParameter[] Param = new SqlParameter[2];
                Param[0] = DataBaseServiceHandler.AddParameter <int>("@Mode_ID", DbType.Int32, Mode_Id);
                Param[1] = DataBaseServiceHandler.AddParameter <int>("@Status", DbType.Int32, iResult, ParameterDirection.Output);

                SqlHelper.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, "usp_ResetTable", Param);

                if (Param[1].SqlValue != null)
                {
                    iResult = Convert.ToInt32(Param[1].SqlValue.ToString());
                }

                bReturn = (iResult == 0) ? true : false;
                LogManager.WriteLog("records affected in ResetTable: " + iResult.ToString(), LogManager.enumLogLevel.Info);
            }

            catch (Exception Ex)
            {
                bReturn = false;
                ExceptionManager.Publish(Ex);
            }
            return(bReturn);
        }
        public string GetSetting(string strSettingName)
        {
            SqlParameter ParamValue = new SqlParameter();

            ParamValue.ParameterName = DBConstants.CONST_SP_PARAM_SETTINGVALUE;
            ParamValue.Direction     = ParameterDirection.Output;
            ParamValue.Value         = string.Empty;
            ParamValue.SqlDbType     = SqlDbType.VarChar;
            ParamValue.Size          = 200;

            try
            {
                if (strSettingName != null)
                {
                    //DataBaseServiceHandler.ConnectionString = ExchangeConnectionString;
                    DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONST_SP_GETSETTING,
                                                           DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_SP_PARAM_SETTINGID, DbType.Int32, 0, ParameterDirection.Input),
                                                           DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_SP_PARAM_SETTINGNAME, DbType.String, strSettingName.Trim()),
                                                           DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_SP_PARAM_SETTINGDEFAULT, DbType.String, string.Empty),
                                                           ParamValue);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
            }

            return(ParamValue.Value.ToString());
        }
        public bool FactoryResetHistory(bool isCompleted, int ResetModeID, string UserName, ref int FRHistoryID)
        {
            bool bReturn = false;

            try
            {
                SqlParameter[] Param = new SqlParameter[4];
                Param[0] = DataBaseServiceHandler.AddParameter <bool>("@IsCompleted", DbType.Boolean, isCompleted);
                Param[1] = DataBaseServiceHandler.AddParameter <int>("@Mode_ID", DbType.Int32, ResetModeID);
                Param[2] = DataBaseServiceHandler.AddParameter <string>("@User_Name", DbType.String, UserName);
                Param[3] = DataBaseServiceHandler.AddParameter <int>("@Status", DbType.Int32, FRHistoryID, ParameterDirection.InputOutput);

                SqlHelper.ExecuteScalar(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, "usp_UpdateFactoryResetHistory", Param);

                if (Param[3].SqlValue != null)
                {
                    FRHistoryID = Convert.ToInt32(Param[3].SqlValue.ToString());
                }

                bReturn = (FRHistoryID != -1) ? true : false;
                LogManager.WriteLog("records affected in FactoryResetHistory: " + FRHistoryID.ToString(), LogManager.enumLogLevel.Info);
            }

            catch (Exception Ex)
            {
                bReturn = false;
                ExceptionManager.Publish(Ex);
            }
            return(bReturn);
        }
        public bool CreateShortPayForApproval(Treasury objTreasury, ref int iShortPayID)
        {
            System.Data.SqlClient.SqlParameter ShortPayID = DataBaseServiceHandler.AddParameter <int>("@ShortPayID",
                                                                                                      DbType.Int32, 0, ParameterDirection.InputOutput);

            try
            {
                DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONST_SP_CREATE_SHORTPAY_FOR_APPROVAL,
                                                       DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, objTreasury.InstallationNumber),
                                                       DataBaseServiceHandler.AddParameter <int>("@User_No", DbType.Int32, objTreasury.UserID),
                                                       DataBaseServiceHandler.AddParameter <string>("@Treasury_Type", DbType.String, objTreasury.TreasuryType),
                                                       DataBaseServiceHandler.AddParameter <string>("@Treasury_Reason", DbType.String, objTreasury.TreasuryReason),
                                                       DataBaseServiceHandler.AddParameter <double>("@Treasury_Amount", DbType.Double, objTreasury.TreasuryAmount),
                                                       DataBaseServiceHandler.AddParameter <int>("@Treasury_Reason_Code", DbType.Int32, objTreasury.TreasuryReasonCode),
                                                       DataBaseServiceHandler.AddParameter <int>("@Treasury_Issuer_User_No", DbType.Int32, objTreasury.TreasuryIssuerUserNo),
                                                       ShortPayID
                                                       );

                iShortPayID = int.Parse(ShortPayID.Value.ToString());

                return(true);
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
                return(false);
            }
        }
        public bool DeleteAddConstraint(bool DropConstraint)
        {
            int  iResult = 0;
            bool bReturn = false;

            try
            {
                SqlParameter[] Param = new SqlParameter[2];
                Param[0] = DataBaseServiceHandler.AddParameter <bool>("@DropConstraint", DbType.Boolean, DropConstraint);
                Param[1] = DataBaseServiceHandler.AddParameter <int>("@Status", DbType.Int32, iResult, ParameterDirection.Output);

                SqlHelper.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, "usp_AddRemoveForiegnConstraint", Param);

                if (Param[1].SqlValue != null)
                {
                    iResult = Convert.ToInt32(Param[1].SqlValue.ToString());
                }

                bReturn = (iResult == 0) ? true : false;
                LogManager.WriteLog("records affected in DeleteAddConstraint: " + iResult.ToString(), LogManager.enumLogLevel.Info);
            }

            catch (Exception Ex)
            {
                bReturn = false;
                ExceptionManager.Publish(Ex);
            }
            return(bReturn);
        }
        public bool SetMachinePreviousState(int installationNo)
        {
            int    errorCode    = 0;
            string errorMessage = string.Empty;

            try
            {
                LogManager.WriteLog("Inside Method", LogManager.enumLogLevel.Info);

                DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString,
                                                       CommandType.StoredProcedure, DBConstants.CONST_SP_USP_UPDATEMACHINEMAINTENANCEDETAILS,
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_INSTALATION_NO, DbType.Int32, installationNo, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_ERROR_CODE, DbType.Int32, errorCode, ParameterDirection.Output),
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_ERROR_MESSAGE, DbType.String, errorMessage, ParameterDirection.Output));

                LogManager.WriteLog(string.Format("{0} - {1}", "Error Code", errorCode.ToString()), LogManager.enumLogLevel.Info);
                LogManager.WriteLog(string.Format("{0} - {1}", "Error Message", errorMessage), LogManager.enumLogLevel.Info);

                return(errorCode == 0 ? true : false);
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
                return(false);
            }
        }
        public int ExecuteHourlyVTP(int InstallationNumber, DateTime dtTheDate, int iTheHour, bool isRead)
        {
            int iResult = -1;
            int iValue  = 0;

            try
            {
                var ReturnValue = DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_RETURNVALUE, DbType.Int32, 0, ParameterDirection.ReturnValue);
                iValue = SqlHelper.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, System.Data.CommandType.StoredProcedure, DBConstants.CONST_SP_USP_HOURLY_VTP,
                                                   DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_THEINSTALLATION, DbType.Int32, InstallationNumber),
                                                   DataBaseServiceHandler.AddParameter <DateTime>(DBConstants.CONST_PARAM_THEDATETIME, DbType.DateTime, dtTheDate),
                                                   DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_THEHOUR, DbType.Int16, iTheHour),
                                                   DataBaseServiceHandler.AddParameter <bool>(DBConstants.CONST_PARAM_ISREAD, DbType.Boolean, isRead),
                                                   ReturnValue);
                if (iValue > 0)
                {
                    if (ReturnValue != null)
                    {
                        if (ReturnValue.Value != DBNull.Value || ReturnValue.Value.ToString() != string.Empty)
                        {
                            iResult = int.Parse(ReturnValue.Value.ToString());
                        }
                    }
                }

                LogManager.WriteLog("SP Excecution for HourlyVTP: " + iValue, LogManager.enumLogLevel.Info);
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
                iResult = -1;
            }
            return(iResult);
        }
Beispiel #8
0
        public bool UpdateEventDetails(string clearType, string eventType, int eventNo, int installationNo)
        {
            int    errorCode    = 0;
            string errorMessage = string.Empty;

            try
            {
                LogManager.WriteLog("Inside Method", LogManager.enumLogLevel.Info);

                DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString,
                                                       CommandType.StoredProcedure, DBConstants.CONST_SP_USP_CLEAREVENTDETAILS,
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_USER_ID, DbType.Int32, BMC.Security.SecurityHelper.CurrentUser.SecurityUserID, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_CLEAR_TYPE, DbType.String, clearType, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_EVENTTYPE, DbType.String, eventType, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_EVENT_NO, DbType.Int32, eventNo, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_INSTALATION_NO, DbType.Int32, installationNo, ParameterDirection.Input),
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_ERROR_CODE, DbType.Int32, errorCode, ParameterDirection.Output),
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_ERROR_MESSAGE, DbType.String, errorMessage, ParameterDirection.Output));

                LogManager.WriteLog(string.Format("{0} - {1}", "Error Code", errorCode.ToString()), LogManager.enumLogLevel.Info);
                LogManager.WriteLog(string.Format("{0} - {1}", "Error Message", errorMessage), LogManager.enumLogLevel.Info);

                return(errorCode == 0 ? true : false);
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
                return(false);
            }
        }
 public int LogTitoTicketPrint(string BarCode, int Amount)
 {
     return(DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, "usp_LogTITOTicketPrint",
                                                   DataBaseServiceHandler.AddParameter <string>("@TicketNumber", DbType.String, BarCode),
                                                   DataBaseServiceHandler.AddParameter <string>("@Workstation", DbType.String, Environment.MachineName),
                                                   DataBaseServiceHandler.AddParameter <int>("@Value", DbType.Int32, Amount),
                                                   DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, 0)));
 }
 public static void UpdateAFTPolling(int Installation_ID)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateAFTPolling",
                                                DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, Installation_ID));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
 }
Beispiel #11
0
 public static void UpdateAAMSVerification(int ReferenceID, int IH_Status)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateAAMSIHVerification",
                                                DataBaseServiceHandler.AddParameter <int>("@Reference_ID", DbType.Int32, ReferenceID),
                                                DataBaseServiceHandler.AddParameter <int>("@IH_Status", DbType.Int32, IH_Status));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
 }
 public static void UpdateTicketExpireInstallations(int nInstallationNo)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateInstallationsForTicketExpire",
                                                DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, nInstallationNo));
     }
     catch (Exception Ex)
     {
         LogManager.WriteLog("usp_UpdateInstallationsForTicketExpire Database Hit Failed.", LogManager.enumLogLevel.Info);
         ExceptionManager.Publish(Ex);
     }
 }
 public static void UpdateEmployeeCardPolling(string EmployeecardNo, int InstallationNo)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(ExchangeConnectionString, CommandType.StoredProcedure, "usp_UpdateEmployeecardPolling",
                                                DataBaseServiceHandler.AddParameter <int>("@InstallationNo", DbType.Int32, InstallationNo),
                                                DataBaseServiceHandler.AddParameter <string>("@EmpCardNo ", DbType.String, EmployeecardNo));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
 }
        public int DeleteReasonDetails(ReasonCode objReason)
        {
            try
            {
                DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONST_SP_DELETE_REASON_PROC,
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_REASONDESCRIPTION, DbType.String, objReason.ReasonDescription));
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
            }

            return(1);
        }
Beispiel #15
0
 public static void UpdateLP21Status(int ReferenceID, string Command, string UpdateType)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateLP21Status",
                                                DataBaseServiceHandler.AddParameter <int>("@Reference_ID", DbType.Int32, ReferenceID),
                                                DataBaseServiceHandler.AddParameter <string>("@EntityCommand", DbType.String, Command),
                                                DataBaseServiceHandler.AddParameter <string>("@UpdateType", DbType.String, UpdateType));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
 }
Beispiel #16
0
        public string GetEPIDetails(int installation_No)
        {
            string  EPIDetails      = string.Empty;
            DataSet dtInstallations = SqlHelper.ExecuteDataset(CommonDataAccess.ExchangeConnectionString,
                                                               CommandType.StoredProcedure, "usp_GetEPIDetails", new SqlParameter[1] {
                DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, installation_No)
            });

            if (dtInstallations != null && dtInstallations.Tables.Count > 0)
            {
                EPIDetails = dtInstallations.Tables[0].Rows[0]["EPIDetails"].ToString();
            }
            return(EPIDetails);
        }
Beispiel #17
0
        public static bool SyncInstallationStatus(int Installation_No, char syncStatus)
        {
            try
            {
                DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_SyncInstallationStatus",
                                                       DataBaseServiceHandler.AddParameter <int>("@Installation_No", DbType.Int32, Installation_No), DataBaseServiceHandler.AddParameter <char>("@SyncStatus", DbType.String, syncStatus));

                return(true);
            }
            catch (Exception Ex)
            {
                ExceptionManager.Publish(Ex);
                return(false);
            }
        }
Beispiel #18
0
        public static bool UpdatePortDisabledStatusForPortBlocking(int installationNo)
        {
            try
            {
                DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_UpdatePortDisabledStatus",
                                                       DataBaseServiceHandler.AddParameter <int>("@InstallationNo", DbType.Int32, installationNo));

                return(true);
            }
            catch (Exception Ex)
            {
                ExceptionManager.Publish(Ex);
                return(false);
            }
        }
 public static void UpdateTicketExpire(int value)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(
             TicketingConnectionString,
             CommandType.StoredProcedure,
             DBConstants.CONSTANT_USP_SETTICKETEXPIRE,
             DataBaseServiceHandler.AddParameter <int>("Value", DbType.String, value));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
 }
Beispiel #20
0
 public string PrepareCashDeskEvent(int InstallationNumber, int FaultType)
 {
     //DataBaseServiceHandler.ConnectionString = CommonDataAccess.ExchangeConnectionString;
     try
     {
         return(DataBaseServiceHandler.ExecuteScalar <string>(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONST_SP_RSP_CASHDESKEVENT,
                                                              DataBaseServiceHandler.AddParameter <int>("@InstallationNo", DbType.Int32, InstallationNumber),
                                                              DataBaseServiceHandler.AddParameter <int>("@FaultType", DbType.Int32, FaultType)));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
     return(string.Empty);
 }
 //
 public static void UpdateTicketExpire(int value)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(
             GetTicketingConnectionString(),
             CommandType.StoredProcedure,
             "usp_SetTicketExpire",
             DataBaseServiceHandler.AddParameter <int>("Value", DbType.String, value));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
 }
Beispiel #22
0
        public static bool UpdateB5ReqStatus(int RefID)
        {
            try
            {
                DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateB5ReqStatus",
                                                       DataBaseServiceHandler.AddParameter <int>("@BAD_ID", DbType.Int32, RefID));

                return(true);
            }
            catch (Exception Ex)
            {
                ExceptionManager.Publish(Ex);
                return(false);
            }
        }
Beispiel #23
0
 public static void InsertExportHistory(string Type, string Reference)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(DBBuilder.GetConnectionString(), CommandType.StoredProcedure, "usp_Export_History",
                                                DataBaseServiceHandler.AddParameter <string>("@Reference1", DbType.String, Reference),
                                                DataBaseServiceHandler.AddParameter <string>("@Reference2", DbType.String, ""),
                                                DataBaseServiceHandler.AddParameter <string>("@Type", DbType.String, Type),
                                                DataBaseServiceHandler.AddParameter <string>("@Status", DbType.String, ""));
     }
     catch (Exception Ex)
     {
         ExceptionManager.Publish(Ex);
     }
 }
 public static void UpdateBarPosition(int iInstallationNo, bool status)
 {
     try
     {
         LogManager.WriteLog("UpdateBarPosition  - started update for machine status", LogManager.enumLogLevel.Info);
         SqlHelper.ExecuteNonQuery(GetConnectionString(), CommandType.StoredProcedure, "usp_UpdateBarPositionMachineStatus",
                                   DataBaseServiceHandler.AddParameter <int>("InstallationNo", DbType.Int32, iInstallationNo),
                                   DataBaseServiceHandler.AddParameter <bool>("Status", DbType.Boolean, status),
                                   DataBaseServiceHandler.AddParameter <int>("ExportHistory", DbType.Int32, 0));
     }
     catch (Exception ex)
     {
         LogManager.WriteLog("Update Bar Position machine status failed", LogManager.enumLogLevel.Info);
         ExceptionManager.Publish(ex);
     }
 }
 public static void UpdateAppSettings_SortOrder(string AppSettingKey, string AppSettingValue)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(
             ExchangeConnectionString,
             CommandType.StoredProcedure,
             DBConstants.CONSTANT_USP_APPSETTINGS_SORTORDER,
             DataBaseServiceHandler.AddParameter <string>("AppSettingName", DbType.String, AppSettingKey),
             DataBaseServiceHandler.AddParameter <string>("Value", DbType.String, AppSettingValue));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
 }
 public int UpdateTicketException(int ID, string TicketNumber, string Value)
 {
     try
     {
         //DataBaseServiceHandler.ConnectionString = CommonDataAccess.ExchangeConnectionString;
         return(DataBaseServiceHandler.ExecuteNonQuery(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONST_SP_UPDATE_TICKET_EXCEPTION_PROC,
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_TE_TICKET_NUMBER, DbType.String, TicketNumber),
                                                       DataBaseServiceHandler.AddParameter <int>(DBConstants.CONST_PARAM_TE_ID, DbType.Int32, ID),
                                                       DataBaseServiceHandler.AddParameter <string>(DBConstants.CONST_PARAM_TE_STATUS, DbType.Int32, Value)));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
     return(-1);
 }
 public static void UpdateSettings(string SettingNamem, string SettingValue)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(
             ExchangeConnectionString,
             CommandType.StoredProcedure,
             DBConstants.CONSTANT_USP_SETSETTINGSVALUE,
             DataBaseServiceHandler.AddParameter <string>("SettingName", DbType.String, SettingNamem),
             DataBaseServiceHandler.AddParameter <string>("SettingValue", DbType.String, SettingValue));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
 }
        public DataSet GetMachineDetailsTreasury(string TreasuryNumber)
        {
            DataSet MachineDetailTreasury = new DataSet();

            try
            {
                //DataBaseServiceHandler.ConnectionString = ExchangeConnectionString;
                MachineDetailTreasury = DataBaseServiceHandler.Fill(ExchangeConnectionString, CommandType.StoredProcedure, DBConstants.CONSTANT_RSP_GETMCDETAILSVIATREASURY, MachineDetailTreasury,
                                                                    DataBaseServiceHandler.AddParameter <string>("Treasury_ID", DbType.String, TreasuryNumber));
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
            }
            return(MachineDetailTreasury);
        }
        public DataTable GetPlayerDetails(Int32 InstallationNo)
        {
            DataTable PlayerDetail = new DataTable();

            try
            {
                PlayerDetail = DataBaseServiceHandler.Fill(CommonDataAccess.ExchangeConnectionString, CommandType.StoredProcedure, "rsp_PlayerClub_GetPlayerDetails", PlayerDetail,
                                                           DataBaseServiceHandler.AddParameter <Int32>("@Installation_No", DbType.Int32, InstallationNo));
            }
            catch (Exception Ex)
            {
                ExceptionManager.Publish(Ex);
            }

            return(PlayerDetail);
        }
 public static void UpdateGMUSiteCodeStatus(int Installation_No, int Status)
 {
     try
     {
         DataBaseServiceHandler.ExecuteNonQuery(
             ExchangeConnectionString,
             CommandType.StoredProcedure,
             DBConstants.CONSTANT_USP_SETGMUSITECODESTATUS,
             DataBaseServiceHandler.AddParameter <int>("@InstallationNo", DbType.Int32, Installation_No),
             DataBaseServiceHandler.AddParameter <int>("@Status", DbType.Int32, Status));
     }
     catch (Exception ex)
     {
         ExceptionManager.Publish(ex);
     }
 }