Modules/EDMIAPI/DatabaseWithFallback.vb

Imports System.Data.SqlClient
Imports DigitalData.Modules.Database
Imports DigitalData.Modules.EDMI.API
Imports DigitalData.Modules.EDMI.API.Constants
Imports DigitalData.Modules.EDMI.API.EDMIServiceReference
Imports DigitalData.Modules.Logging

Public Class DatabaseWithFallback
    Private ReadOnly _Logger As Logger
    Private ReadOnly _Client As Client
    Private ReadOnly _ClientConfig As GlobalStateClientConfiguration
    Private ReadOnly _DatabaseECM As MSSQLServer
    Private _DatabaseIDB As MSSQLServer

    ''' <summary>
    ''' Options for GetDatatable
    ''' </summary>
    Public Class GetDatatableOptions
        Public ReadOnly FallbackSQL
        Public ReadOnly FallbackType

        ''' <summary>
        ''' Filter expression for the cached Datatable
        ''' </summary>
        Public Property FilterExpression As String = ""
        ''' <summary>
        ''' Columns to sort the cached Datatable by
        ''' </summary>
        Public Property SortByColumn As String = ""
        ''' <summary>
        ''' Force the fallback, skipping the service completely
        ''' </summary>
        Public Property ForceFallback As Boolean = False
        ''' <summary>
        ''' Connection Id to use, references TBDD_CONNECTION
        ''' </summary>
        Public Property ConnectionId As Integer = 0

        ''' <summary>
        ''' Creates a new options object for GetDatatable options
        ''' </summary>
        ''' <param name="pFallbackSQL">SQL Command to execute as fallback</param>
        ''' <param name="pFallbackType">Named Database to use for the fallback SQL Command</param>
        Public Sub New(pFallbackSQL As String, pFallbackType As Constants.DatabaseType)
            FallbackSQL = pFallbackSQL
            FallbackType = pFallbackType
        End Sub
    End Class

    Public Sub New(LogConfig As LogConfig, Client As Client, DatabaseECM As MSSQLServer, DatabaseIDB As MSSQLServer)
        _Logger = LogConfig.GetLogger()
        _Client = Client
        _DatabaseECM = DatabaseECM
        _DatabaseIDB = DatabaseIDB

        _Logger.Debug("Client exists: [{0}]", Not IsNothing(Client))
        _Logger.Debug("DatabaseECM exists: [{0}]", Not IsNothing(DatabaseECM))
        _Logger.Debug("DatabaseIDB exists: [{0}]", Not IsNothing(DatabaseIDB))

        ' Load client config, will throw if client is not yet connected to service
        _ClientConfig = Client?.ClientConfig
    End Sub

    ''' <summary>
    ''' Set the IDB Database class after initializing the class. 
    ''' It is now your responsibility to make sure to not use any IDB calls before calling this method.
    ''' </summary>
    Public Sub InitializeIDB(pDatabaseIDB As MSSQLServer)
        _DatabaseIDB = pDatabaseIDB
    End Sub

    Public Function GetConnectionString(pConnectionId As Integer) As String
        Return _DatabaseECM.GetConnectionStringForId(pConnectionId)
    End Function

#Region "GetDatatable"
    Public Function GetDatatableECM(pSQL As String) As DataTable
        Return GetDatatable(New GetDatatableOptions(pSQL, Constants.DatabaseType.ECM))
    End Function

    Public Async Function GetDatatableECMAsync(pSQL As String) As Task(Of DataTable)
        Return Await GetDatatableFromServiceAsync(pSQL, Constants.DatabaseType.ECM, 0)
    End Function

    Public Function GetDatatableIDB(pSQL As String) As DataTable
        Return GetDatatable(New GetDatatableOptions(pSQL, Constants.DatabaseType.IDB))
    End Function

    Public Async Function GetDatatableIDBAsync(pSQL As String) As Task(Of DataTable)
        Return Await GetDatatableFromServiceAsync(pSQL, Constants.DatabaseType.IDB, 0)
    End Function

    Public Function GetDatatableWithConnection(pSQL As String, pConnectionId As Integer) As DataTable
        Return GetDatatable(New GetDatatableOptions(pSQL, Constants.DatabaseType.None) With {.ConnectionId = pConnectionId})
    End Function

    Public Async Function GetDatatableWithConnectionAsync(pSQL As String, pConnectionId As Integer) As Task(Of DataTable)
        Return Await GetDatatableFromServiceAsync(pSQL, Constants.DatabaseType.None, pConnectionId)
    End Function
#End Region

#Region "GetScalarValue"
    Public Function GetScalarValueECM(pSQL As String) As Object
        Return GetScalarValue(pSQL, Constants.DatabaseType.ECM)
    End Function

    Public Async Function GetScalarValueECMAsync(pSQL As String) As Task(Of Object)
        Return Await GetScalarValueFromServiceAsync(pSQL, Constants.DatabaseType.ECM, 0)
    End Function

    Public Function GetScalarValueIDB(pSQL As String) As Object
        Return GetScalarValue(pSQL, Constants.DatabaseType.IDB)
    End Function

    Public Async Function GetScalarValueIDBAsync(pSQL As String) As Task(Of Object)
        Return Await GetScalarValueFromServiceAsync(pSQL, Constants.DatabaseType.IDB, 0)
    End Function

    Public Function GetScalarValueWithConnection(pSQL As String, pConnectionId As Integer) As Object
        Return GetScalarValue(pSQL, Constants.DatabaseType.None, pConnectionId:=pConnectionId)
    End Function

    Public Async Function GetScalarValueWithConnectionAsync(pSQL As String, pConnectionId As Integer) As Task(Of Object)
        Return Await GetScalarValueFromServiceAsync(pSQL, Constants.DatabaseType.None, pConnectionId)
    End Function
#End Region

#Region "ExecuteNonQuery"
    Public Function ExecuteNonQueryECM(pSQL As String) As Boolean
        Return ExecuteNonQuery(pSQL, Constants.DatabaseType.ECM)
    End Function

    Public Async Function ExecuteNonQueryECMAsync(pSQL As String) As Task(Of Boolean)
        Return Await ExecuteNonQueryFromServiceAsync(pSQL, Constants.DatabaseType.ECM, 0)
    End Function

    Public Function ExecuteNonQueryIDB(pSQL As String) As Boolean
        Return ExecuteNonQuery(pSQL, Constants.DatabaseType.IDB)
    End Function

    Public Async Function ExecuteNonQueryIDBAsync(pSQL As String) As Task(Of Boolean)
        Return Await ExecuteNonQueryFromServiceAsync(pSQL, Constants.DatabaseType.IDB, 0)
    End Function

    Public Function ExecuteNonQueryWithConnection(pSQL As String, pConnectionId As Integer) As Boolean
        Return ExecuteNonQuery(pSQL, Constants.DatabaseType.None, pConnectionId:=pConnectionId)
    End Function

    Public Async Function ExecuteNonQueryWithConnectionAsync(pSQL As String, pConnectionId As Integer) As Task(Of Boolean)
        Return Await ExecuteNonQueryFromServiceAsync(pSQL, Constants.DatabaseType.None, pConnectionId)
    End Function
#End Region


    ''' <summary>
    ''' Returns a Datatable by trying to fetch a cached version from the service, then querying the database through the service and querying the database directly as fallback. 
    ''' </summary>
    ''' <param name="pDataTableName">Name of the Cached Datatable</param>
    ''' <param name="pOptions">Options object</param>
    Public Function GetDatatable(pDataTableName As String, pOptions As GetDatatableOptions) As DataTable
        Return GetDatatable(pDataTableName, pOptions.FallbackSQL, pOptions.FallbackType, pOptions.FilterExpression, pOptions.SortByColumn, pOptions.ForceFallback, pOptions.ConnectionId)
    End Function

    Public Function GetDatatable(pSQL As String, pConnectionId As Integer) As DataTable
        Return GetDatatable("FORCE_FALLBACK", pSQL, Constants.DatabaseType.ECM, pSortByColumn:=Nothing, pForceFallback:=False, pConnectionId:=pConnectionId)
    End Function

    ''' <summary>
    ''' Returns a datatable directly from the database.
    ''' </summary>
    ''' <param name="pOptions">Options object</param>
    Public Function GetDatatable(pOptions As GetDatatableOptions) As DataTable
        Dim oForceFallback = True
        Return GetDatatable("FORCE_FALLBACK", pOptions.FallbackSQL, pOptions.FallbackType, pOptions.FilterExpression, pOptions.SortByColumn, oForceFallback, pOptions.ConnectionId)
    End Function

    ''' <summary>
    ''' Returns a Datatable by trying to fetch a cached version from the service, then querying the database through the service and querying the database directly as fallback.
    ''' </summary>
    ''' <param name="pDataTableName">Name of the Cached Datatable</param>
    ''' <param name="pFallbackSQL">SQL Command to execute as fallback</param>
    ''' <param name="pFallbackType">Named Database to use for the fallback SQL Command</param>
    ''' <param name="pFilterExpression">Filter expression for the cached Datatable</param>
    ''' <param name="pSortByColumn">Columns to sort the cached Datatable by</param>
    ''' <param name="pForceFallback">Force the fallback, skipping the service completely</param>
    ''' <param name="pConnectionId">Connection Id to use, references TBDD_CONNECTION</param>
    Public Function GetDatatable(pDataTableName As String, pFallbackSQL As String, pFallbackType As Constants.DatabaseType, Optional pFilterExpression As String = "", Optional pSortByColumn As String = "", Optional pForceFallback As Boolean = False, Optional pConnectionId As Integer = 0) As DataTable
        Try
            Dim oResult As DataTable = Nothing
            Dim oTableResult As TableResult = Nothing
            _Logger.Debug("GetDatatable: Fetching datatable [{0}] , Filter Expression [{1}], Sort By Column [{2}], Force Fallback [{3}]",
                          pDataTableName, pFilterExpression, pSortByColumn, pForceFallback)
            ' If there is no client, we assume there is no service (configured)
            If _Client Is Nothing Then
                _Logger.Debug("GetDatatable: Client is empty, falling back to direct database access.")
                Return GetDatatableFromDatabase(pFallbackSQL, pFallbackType, pConnectionId)
            End If

            ' If ForceFallback flag is set, we go to database immediately
            If pForceFallback Or _ClientConfig.ForceDirectDatabaseAccess Then
                _Logger.Debug("GetDatatable: ForceFallback is True, falling back to direct database access.")
                Return GetDatatableFromDatabase(pFallbackSQL, pFallbackType, pConnectionId)
            End If

            ' If the table is not cached, we try going through the service
            If Not IsTableCached(pDataTableName) Then
                _Logger.Debug("GetDatatable: Datatable [{0}] is not chached, fetching data from service.", pDataTableName)
                Return GetDatatableFromService(pFallbackSQL, pFallbackType, pConnectionId)
            End If

            ' If there is a proper ConnectionId, we try going through the service
            If pConnectionId > 0 Then
                _Logger.Debug("GetDatatable: ConnectionId is set, fetching data from service.")
                Return GetDatatableFromService(pFallbackSQL, pFallbackType, pConnectionId)
            End If

            Try
                _Logger.Debug("GetDatatable: Datatable is chached, fetching data from cache.")
                oTableResult = _Client.GetDatatableByName(pDataTableName, pFilterExpression, pSortByColumn)
            Catch ex As Exception
                _Logger.Error(ex)
                oTableResult = Nothing
            End Try

            If oTableResult Is Nothing OrElse oTableResult.OK = False Then
                _Logger.Warn("⚠ GetDatatable: Datatable [{0}] could not be fetched from AppServer Cache. Falling back to direct Database Access.", pDataTableName)
                Return GetDatatableFromDatabase(pFallbackSQL, pFallbackType, pConnectionId)
            Else
                _Logger.Debug("✔ GetDatatable: Datatable [{0}] fetched from AppServer Cache.", pDataTableName)
                Return oTableResult.Table
            End If

        Catch ex As Exception
            _Logger.Error(ex)
            Return Nothing

        End Try
    End Function

    ''' <summary>
    ''' Returns a Scalar Value by querying the database through the service and querying the database directly as fallback.
    ''' </summary>
    ''' <param name="pSQL">SQL Command to execute as fallback</param>
    ''' <param name="pDatabaseType">Named Database to use for the fallback SQL Command</param>
    ''' <param name="pForceFallback">Force the fallback, skipping the service completely</param>
    ''' <param name="pConnectionId">Connection Id to use, references TBDD_CONNECTION</param>
    Public Function GetScalarValue(pSQL As String, pDatabaseType As Constants.DatabaseType, Optional pForceFallback As Boolean = False, Optional pConnectionId As Integer = 0) As Object
        Try
            ' If there is no client, we assume there is no service (configured)
            If _Client Is Nothing Then
                Return GetScalarValueFromDatabase(pSQL, pDatabaseType, pConnectionId)
            End If

            ' If ForceFallback flag is set, we go to database immediately
            If pForceFallback Or _ClientConfig.ForceDirectDatabaseAccess Then
                Return GetScalarValueFromDatabase(pSQL, pDatabaseType, pConnectionId)
            End If

            Return GetScalarValueFromService(pSQL, pDatabaseType, pConnectionId)

        Catch ex As Exception
            _Logger.Error(ex)
            Return Nothing

        End Try
    End Function

    ''' <summary>
    ''' Returns a Scalar Value by querying the database through the service and querying the database directly as fallback.
    ''' </summary>
    ''' <param name="pSQL">SQL Command to execute as fallback</param>
    ''' <param name="pDatabaseType">Named Database to use for the fallback SQL Command</param>
    ''' <param name="pForceFallback">Force the fallback, skipping the service completely</param>
    ''' <param name="pConnectionId">Connection Id to use, references TBDD_CONNECTION</param>
    Public Function ExecuteNonQuery(pSQL As String, pDatabaseType As Constants.DatabaseType, Optional pForceFallback As Boolean = False, Optional pConnectionId As Integer = 0) As Boolean
        Try
            Dim oResult As DataTable = Nothing
            Dim oTableResult As TableResult = Nothing

            ' If there is no client, we assume there is no service (configured)
            If _Client Is Nothing Then
                _Logger.Debug("ExecuteNonQuery - Client is empty, falling back to direct database access.")
                Return ExecuteNonQueryFromDatabase(pSQL, pDatabaseType, pConnectionId)
            End If

            ' If ForceFallback flag is set, we go to database immediately
            If pForceFallback Or _ClientConfig.ForceDirectDatabaseAccess Then
                _Logger.Debug("ExecuteNonQuery - ForceFallback is set, falling back to direct database access.")
                Return ExecuteNonQueryFromDatabase(pSQL, pDatabaseType, pConnectionId)
            End If

            Return ExecuteNonQueryFromService(pSQL, pDatabaseType, pConnectionId)

        Catch ex As Exception
            _Logger.Error(ex)
            Return Nothing

        End Try
    End Function

    Private Function IsTableCached(pName As String) As Boolean
        _Logger.Debug("IsTableCached: Checking if table [{0}] is cached.", pName)
        If _Client Is Nothing Then
            _Logger.Warn("⚠ IsTableCached: Client is nothing, cannot check if table is cached.")
            Return False
        End If

        Return _Client.CachedTables.Contains(pName.ToUpper)
    End Function

    Private Function GetDatatableFromService(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As DataTable
        Try
            _Logger.Debug("GetDatatableFromService: Fetching data from service [{0}] with Connection Id [{1}] and Command [{2}]", DatabaseType.ToString, pConnectionId, pSQLCommand)
            Dim oResult As GetDatatableResponse = Nothing

            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = _Client.GetDatatableFromECM(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = _Client.GetDatatableFromIDB(pSQLCommand)
                Case Else
                    Return GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ GetDatatableFromService: Service returned invalid response [{0}]. Falling back to direct database access.", If(oResult Is Nothing, "null", oResult.ErrorMessage))
                Return GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End If

            Return oResult.Table

        Catch ex As InvalidOperationException
            _Logger.Warn("⚠ GetDatatableFromService skipped: [{0}] Falling back to direct database access.", ex.Message)
            Return GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        Catch ex As Exception
            _Logger.Warn("⚠ GetDatatableFromService failed. Falling back to direct database access.")
            _Logger.Error(ex)
            Return GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        End Try
    End Function

    Private Async Function GetDatatableFromServiceAsync(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Task(Of DataTable)
        Dim oFallback As Boolean = False
        _Logger.Debug("GetDatatableFromServiceAsync: GetDatatableFromServiceAsync called with SQL [{0}], DatabaseType [{1}], ConnectionId [{2}]", pSQLCommand, DatabaseType.ToString, pConnectionId)
        If _Client Is Nothing OrElse _ClientConfig?.ForceDirectDatabaseAccess Then
            Return Await Task.Run(Function() GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Dim oResult As GetDatatableResponse = Nothing
        Try
            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = Await _Client.GetDatatableFromECMAsync(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = Await _Client.GetDatatableFromIDBAsync(pSQLCommand)
                Case Else
                    oResult = Await _Client.GetDatatableFromConnectionAsync(pSQLCommand, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ GetDatatableFromServiceAsync failed. Falling back to direct database access.")
                oFallback = True
            End If
        Catch ex As Exception
            _Logger.Warn("⚠ GetDatatableFromServiceAsync failed. Falling back to direct database access.")
            _Logger.Error(ex)
            oFallback = True
        End Try

        If oFallback Then
            Return Await Task.Run(Function() GetDatatableFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Return oResult.Table
    End Function
    Private Function GetDatatableFromDatabase(pSQLCommand As String, pDatabaseType As Constants.DatabaseType, pConnectionId As Integer) As DataTable
        Try
            _Logger.Debug("GetDatatableFromDatabase: Fetching data from database [{0}] with Connection Id [{1}] and Command [{2}]", pDatabaseType.ToString, pConnectionId, pSQLCommand)

            Select Case pDatabaseType
                Case Constants.DatabaseType.IDB
                    Return _DatabaseIDB.GetDatatable(pSQLCommand)

                Case Else
                    If pConnectionId > 0 Then
                        _Logger.Debug("Retrieving Connection String from Connection Id [{0}]", pConnectionId)
                        Dim oConnectionString = _DatabaseECM.Get_ConnectionStringforID(pConnectionId)
                        Return _DatabaseECM.GetDatatableWithConnection(pSQLCommand, oConnectionString)
                    Else
                        Return _DatabaseECM.GetDatatable(pSQLCommand)
                    End If

            End Select

        Catch ex As Exception
            _Logger.Error(ex)
            Return Nothing

        End Try
    End Function
    Private Async Function GetScalarValueFromServiceAsync(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Task(Of Object)
        Dim oFallback As Boolean = False

        _Logger.Debug("GetScalarValueFromServiceAsync called with SQL [{0}], DatabaseType [{1}], ConnectionId [{2}]", pSQLCommand, DatabaseType.ToString, pConnectionId)

        If _Client Is Nothing OrElse _ClientConfig?.ForceDirectDatabaseAccess Then
            Return Await Task.Run(Function() GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Dim oResult As GetScalarValueResponse = Nothing
        Try
            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = Await _Client.GetScalarValueFromECMAsync(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = Await _Client.GetScalarValueFromIDBAsync(pSQLCommand)
                Case Else
                    oResult = Await _Client.GetScalarValueFromConnectionAsync(pSQLCommand, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ GetScalarValueFromServiceAsync failed. Falling back to direct database access.")
                oFallback = True
            End If
        Catch ex As Exception
            _Logger.Warn("⚠ GetScalarValueFromServiceAsync failed. Falling back to direct database access.")
            _Logger.Error(ex)
            oFallback = True
        End Try

        If oFallback Then
            Return Await Task.Run(Function() GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Return oResult.Scalar
    End Function
    Private Function GetScalarValueFromService(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Object
        Try
            Dim oResult As GetScalarValueResponse = Nothing
            _Logger.Debug("GetScalarValueFromService [{0}] with Connection Id [{1}] and Command [{2}]", DatabaseType.ToString, pConnectionId, pSQLCommand)
            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = _Client.GetScalarValueFromECM(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = _Client.GetScalarValueFromIDB(pSQLCommand)
                Case Else
                    Return GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ GetScalarValueFromService: Service returned invalid response [{0}]. Falling back to direct database access.", If(oResult Is Nothing, "null", oResult.ErrorMessage))
                Return GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End If

            Return oResult.Scalar

        Catch ex As InvalidOperationException
            _Logger.Warn("⚠ GetScalarValueFromService skipped: [{0}] Falling back to direct database access.", ex.Message)
            Return GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        Catch ex As Exception
            _Logger.Warn("⚠ GetScalarValueFromService failed. Falling back to direct database access.")
            _Logger.Error(ex)
            Return GetScalarValueFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        End Try
    End Function


    Private Function GetScalarValueFromDatabase(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Object
        Try
            _Logger.Debug("DBwFF GetScalarValueFromDatabase [{0}] with Connection Id [{1}] and Command [{2}]", DatabaseType.ToString, pConnectionId, pSQLCommand)
            Select Case DatabaseType
                Case Constants.DatabaseType.IDB
                    Return _DatabaseIDB.GetScalarValue(pSQLCommand)

                Case Else
                    If pConnectionId > 0 Then
                        Dim oConnectionString = _DatabaseECM.Get_ConnectionStringforID(pConnectionId)
                        Return _DatabaseECM.GetScalarValueWithConnection(pSQLCommand, oConnectionString)
                    Else
                        Return _DatabaseECM.GetScalarValue(pSQLCommand)
                    End If

            End Select

        Catch ex As Exception
            _Logger.Error(ex)
            Return Nothing

        End Try
    End Function
    Private Async Function ExecuteNonQueryFromServiceAsync(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Task(Of Boolean)
        Dim oFallback As Boolean = False

        _Logger.Debug("ExecuteNonQueryFromServiceAsync called with SQL [{0}], DatabaseType [{1}], ConnectionId [{2}]", pSQLCommand, DatabaseType.ToString, pConnectionId)

        If _Client Is Nothing OrElse _ClientConfig?.ForceDirectDatabaseAccess Then
            Return Await Task.Run(Function() ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Dim oResult As ExecuteNonQueryResponse = Nothing
        Try
            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = Await _Client.ExecuteNonQueryFromECMAsync(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = Await _Client.ExecuteNonQueryFromIDBAsync(pSQLCommand)
                Case Else
                    oResult = Await _Client.ExecuteNonQueryFromConnectionAsync(pSQLCommand, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ ExecuteNonQueryFromServiceAsync failed. Falling back to direct database access.")
                oFallback = True
            End If
        Catch ex As Exception
            _Logger.Warn("⚠ ExecuteNonQueryFromServiceAsync failed. Falling back to direct database access.")
            _Logger.Error(ex)
            oFallback = True
        End Try

        If oFallback Then
            Return Await Task.Run(Function() ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId))
        End If

        Return oResult.Result
    End Function
    Private Function ExecuteNonQueryFromService(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Boolean
        Try
            Dim oResult As ExecuteNonQueryResponse = Nothing
            _Logger.Debug("ExecuteNonQueryFromService [{0}] with Connection Id [{1}] and Command [{2}]", DatabaseType.ToString, pConnectionId, pSQLCommand)
            Select Case DatabaseType
                Case Constants.DatabaseType.ECM
                    oResult = _Client.ExecuteNonQueryFromECM(pSQLCommand)
                Case Constants.DatabaseType.IDB
                    oResult = _Client.ExecuteNonQueryFromIDB(pSQLCommand)
                Case Else
                    Return ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End Select

            If oResult Is Nothing OrElse oResult.OK = False Then
                _Logger.Warn("⚠ ExecuteNonQueryFromService: Service returned invalid response [{0}]. Falling back to direct database access.", If(oResult Is Nothing, "null", oResult.ErrorMessage))
                Return ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId)
            End If

            Return oResult.Result

        Catch ex As InvalidOperationException
            _Logger.Warn("⚠ ExecuteNonQueryFromService skipped: [{0}] Falling back to direct database access.", ex.Message)
            Return ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        Catch ex As Exception
            _Logger.Warn("⚠ ExecuteNonQueryFromService failed. Falling back to direct database access.")
            _Logger.Error(ex)
            Return ExecuteNonQueryFromDatabase(pSQLCommand, DatabaseType, pConnectionId)

        End Try
    End Function

    Private Function ExecuteNonQueryFromDatabase(pSQLCommand As String, DatabaseType As Constants.DatabaseType, pConnectionId As Integer) As Boolean
        Try
            _Logger.Debug("ExecuteNonQueryFromDatabase [{0}] with Connection Id [{1}] and Command [{2}]", DatabaseType.ToString, pConnectionId, pSQLCommand)

            Select Case DatabaseType
                Case Constants.DatabaseType.IDB
                    Return _DatabaseIDB.ExecuteNonQuery(pSQLCommand)

                Case Else
                    If pConnectionId > 0 Then
                        Dim oConnectionString = _DatabaseECM.Get_ConnectionStringforID(pConnectionId)
                        Return _DatabaseECM.ExecuteNonQueryWithConnection(pSQLCommand, oConnectionString)
                    Else
                        Return _DatabaseECM.ExecuteNonQuery(pSQLCommand)
                    End If

            End Select

        Catch ex As Exception
            _Logger.Error(ex)
            Return False

        End Try
    End Function
End Class