Imports System.IO
Imports System.Net
Imports System.Net.Http
Imports System.Threading
Imports System.Threading.Tasks
Imports System.Web.Http
Imports System.Web.Http.Description
Imports Microsoft.Web.Http
Imports Org.BouncyCastle.Asn1
Imports VERAG_PROG_ALLGEMEIN
Imports VERAG_PROG_ALLGEMEIN.TESTJSON

Namespace ApiController.Controllers


    Public Class AVISOController
        Inherits System.Web.Http.ApiController

        ''' <summary>
        ''' Upload Files in Base64-Format and attach it to an existring LKW (with avisoId) or an specific consignment (with sendungsId)
        ''' </summary>
        ''' 
        ''' <returns>OK, if file is uploaded or ERROR-Code if something went wrong</returns>

        ''' <response code="200">Returns 200  file is uploaded sucessfully</response>
        ''' <response code="400">Returns 400 upload failed</response>

        <ApiVersion("1")>
        <System.Web.Http.Route("api/v{version:apiVersion}/uploadAvisoAttachment")>
        <BasicAuthentication>
        Public Async Function uploadAvisoAttachment(anhangsart As String, arrayOfFiles() As String, Optional avisoId As Integer = -1, Optional sendungsId As Integer = -1, Optional saveOnServer As Boolean = False) As Task(Of HttpResponseMessage)
            ' Globale Fehlerbehandlung einstellen
            VERAG_PROG_ALLGEMEIN.cAllgemein.TESTSYSTEM = False
            VERAG_PROG_ALLGEMEIN.cAllgemein.ERR_OP_GLOBAL = VERAG_PROG_ALLGEMEIN.ERROR_OP.LOG

            Dim response As HttpResponseMessage

            Try
                ' Eingabevalidierung
                If String.IsNullOrWhiteSpace(anhangsart) Then
                    Return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Der Parameter 'anhangsart' darf nicht leer sein.")
                End If

                If arrayOfFiles Is Nothing OrElse arrayOfFiles.Length = 0 Then
                    VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR("Leeres 'arrayOfFiles' empfangen.", "Anhangsart: " & anhangsart, "uploadAvisoAttachment")
                    Return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Das 'arrayOfFiles' darf nicht leer sein.")
                End If

                If avisoId <= 0 AndAlso sendungsId <= 0 Then
                    Return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Es muss entweder eine gültige 'avisoId' oder 'sendungsId' angegeben werden.")
                End If


                Dim ip = Request.Properties("MS_HttpContext").Request.UserHostAddress()


                Dim DS_name As String = ""
                Dim DS_Domain As String = ""
                Dim DS_pw As String = ""

                If Not saveOnServer Then
                    Dim prog As String = "Datenarchiv"
                    Dim SQL As New VERAG_PROG_ALLGEMEIN.SQL
                    Dim isProductive As String = If(VERAG_PROG_ALLGEMEIN.cAllgemein.TESTSYSTEM, "0", "1")
                    Dim query As String = "SELECT TOP 1 * FROM tblAPIEinstellungen WHERE api_program='" & prog & "' and api_productive ='" & isProductive & "'"
                    Dim DSZugang As DataTable = SQL.loadDgvBySql(query, "ADMIN")
                    If DSZugang.Rows.Count = 0 Then
                        Return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Fehler beim Abrufen der Datenserver-Zugangsdaten.")
                    End If

                    ' Zugang für Datenarchiv
                    DS_Domain = DSZugang.Rows(0).Item("api_url")
                    DS_name = DSZugang.Rows(0).Item("api_user")
                    DS_pw = DSZugang.Rows(0).Item("api_password")
                End If

                ' Dateien verarbeiten
                Dim result As String = ""

                If sendungsId > 0 Then
                    result = Await ProcessFilesAsync(anhangsart, arrayOfFiles, sendungsId, True, saveOnServer, DS_name, DS_Domain, DS_pw)
                ElseIf avisoId > 0 Then
                    result = Await ProcessFilesAsync(anhangsart, arrayOfFiles, avisoId, False, saveOnServer, DS_name, DS_Domain, DS_pw)
                Else
                    Return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Fehlerhafte Eingabeparameter.")
                End If

                If result = "OK" Then
                    response = Request.CreateResponse(HttpStatusCode.OK, "Die Dokumente wurden erfolgreich hochgeladen.")

                    Dim avisoObjekt As cAviso
                    avisoObjekt = cAviso.getAvisoById(avisoId)
                    ' Benachrichtigung senden
                    Dim code As Integer = cAvisoBenachrichtigungenCodes.Verwahrung_Foto
                    Dim TXT_Titel As String = "Verwahrung Foto hinzugefügt"
                    Dim TXT_Mitteilung As String = "Ein neues Verwahrung Foto wurde zu AvisoID " & avisoId & " oder SendungsID " & sendungsId & " hinzugefügt."

                    Dim benachrichtigungErfolg As Boolean = cAvisoBenachrichtigungen.send_BENACHRICHTIGUNG_AKTIV_AVISOUSER(
                        avisoId,
                        sendungsId,
                        TXT_Titel,
                        TXT_Mitteilung,
                        code,
                        avisoObjekt.FIRMA
                    )

                    If benachrichtigungErfolg <> False Then
                        response = Request.CreateResponse(HttpStatusCode.OK, "Die Benachrichtigung wurde gesendet.")
                    Else
                        response = Request.CreateResponse(HttpStatusCode.OK, "Die Dokumente wurden erfolgreich hochgeladen, aber die Benachrichtigung konnte nicht gesendet werden.")
                    End If

                Else
                    response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, result)
                End If

            Catch ex As Exception
                VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace & vbNewLine, System.Reflection.MethodInfo.GetCurrentMethod.Name)
                response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Ein unerwarteter Fehler ist aufgetreten.")
            End Try

            Return response
        End Function


        Private Async Function ProcessFilesAsync(anhangsart As String, arrayOfFiles() As String, id As Integer, isSendung As Boolean, saveOnServer As Boolean, DS_name As String, DS_Domain As String, DS_pw As String) As Task(Of String)
            Try
                ' Sendung oder Aviso laden
                Dim entity As Object = Nothing
                If isSendung Then
                    entity = New VERAG_PROG_ALLGEMEIN.cSendungen(id)
                    If entity Is Nothing Then
                        Dim errMsg As String = "Die angegebene Sendung wurde nicht gefunden. ID: " & id
                        Debug.WriteLine(errMsg)
                        Return errMsg
                    End If
                Else
                    entity = VERAG_PROG_ALLGEMEIN.cAviso.getAvisoById(id)
                    If entity Is Nothing Then
                        Dim errMsg As String = "Das angegebene Aviso wurde nicht gefunden. ID: " & id
                        Debug.WriteLine(errMsg)
                        Return errMsg
                    End If
                End If

                ' Netzwerkverbindung herstellen, falls erforderlich
                If Not saveOnServer Then
                    Dim retries As Integer = 0
                    While NetzwerkVerbindungOffen(DS_name, DS_Domain) AndAlso retries < 20
                        If retries = 10 Then
                            Dim errMsg As String = "Die Verbindung zum Datenserver konnte nicht hergestellt werden. Versuche: " & retries
                            Debug.WriteLine(errMsg)
                            Return errMsg
                        End If
                        Await Task.Delay(1000)
                        retries += 1
                    End While

                    NetzwerkVerbindungHerstellen(DS_Domain, DS_name, DS_pw)
                End If

                For Each image In arrayOfFiles
                    Dim filetemp As String = RemoveBase64Prefix(image)

                    ' Validierung des Base64-Formats
                    If Not IsValidBase64String(filetemp) Then
                        Dim errMsg As String = "Das Base64-Format der Datei ist ungültig. Datei: " & image
                        Debug.WriteLine(errMsg)
                        Return errMsg
                    End If

                    ' Dateierweiterung ermitteln
                    Dim fileextension As String = VERAG_PROG_ALLGEMEIN.DATENVERVER_OPTIONS.getFileExtensionFromBase64String(filetemp)
                    If String.IsNullOrEmpty(fileextension) OrElse fileextension.ToLower() = "unknown" Then
                        fileextension = "jpg"
                    End If

                    If Not saveOnServer Then
                        ' Datei auf Datenserver hochladen
                        Dim uploadResult As String = Await UploadFileToDataServerAsync(entity, id, isSendung, filetemp, fileextension, anhangsart)
                        If uploadResult <> "OK" Then
                            Dim errMsg As String = "Fehler beim Hochladen der Datei auf den Datenserver. Upload-Ergebnis: " & uploadResult
                            Debug.WriteLine(errMsg)
                            Return errMsg
                        End If
                    Else
                        ' Datei direkt auf dem Server speichern
                        Dim saveResult As String = Await SaveFileOnServerAsync(id, isSendung, filetemp, fileextension, anhangsart)
                        If saveResult <> "OK" Then
                            Dim errMsg As String = "Fehler beim Speichern der Datei auf dem Server. Save-Ergebnis: " & saveResult
                            Debug.WriteLine(errMsg)
                            Return errMsg
                        End If
                    End If
                Next

                If Not saveOnServer Then
                    NetzwerkVerbindungTrennen(DS_Domain)
                End If

                Return "OK"

            Catch ex As Exception
                Dim methodName As String = System.Reflection.MethodBase.GetCurrentMethod().Name
                Dim lineNumber As Integer = GetExceptionLineNumber(ex)
                Dim errMsg As String = $"Ein Fehler ist beim Verarbeiten der Dateien aufgetreten in {methodName}, Zeile {lineNumber}: {ex.Message}"
                Debug.WriteLine(errMsg)
                VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(errMsg, ex.StackTrace & vbNewLine, methodName)
                Return errMsg
            End Try
        End Function


        Private Function GetExceptionLineNumber(ByVal ex As Exception) As Integer
            Dim st As New StackTrace(ex, True)
            Dim frame As StackFrame = st.GetFrame(0)
            If frame IsNot Nothing Then
                Dim line As Integer = frame.GetFileLineNumber()
                If line = 0 Then
                    ' Falls GetFileLineNumber 0 zurückgibt, könnte es daran liegen, dass keine Debug-Informationen verfügbar sind.
                    Return -1
                Else
                    Return line
                End If
            End If
            Return -1
        End Function


        Private Function RemoveBase64Prefix(base64String As String) As String
            If base64String.Contains("base64,") Then
                Return base64String.Substring(base64String.IndexOf("base64,") + 7)
            End If
            Return base64String
        End Function

        Private Function IsValidBase64String(base64String As String) As Boolean
            Try
                Convert.FromBase64String(base64String)
                Return True
            Catch ex As Exception
                Return False
            End Try

        End Function

        Private Async Function UploadFileToDataServerAsync(entity As Object, entityId As Integer, isSendung As Boolean, fileContent As String, fileExtension As String, anhangsart As String) As Task(Of String)
            Try
                ' Create a new data server entry
                Dim dsCategory As String = "DOKUMENTE"
                Dim dsSubCategory As String = "AVISO_ANHAENGE"
                Dim dsName As String = $"{anhangsart}_{DateTime.Now:ddMMyy_HHmmss}"
                Dim dsFileName As String = $"{DateTime.Now:ddMMyy_HHmmss.ffff}"

                Dim DS As New VERAG_PROG_ALLGEMEIN.cDATENSERVER(dsCategory, dsSubCategory, entityId, dsFileName, "", dsName, False)
                DS.uploadDataToDATENSERVER_fromBase64String(fileContent, DS.da_name, $".{fileExtension}", False, False)

                If DS Is Nothing OrElse DS.da_id <= 0 Then
                    Return "Fehler beim Hochladen der Datei zum Datenserver."
                End If

                ' Anhangseintrag erstellen
                Dim fileName As String = VERAG_PROG_ALLGEMEIN.cDATENSERVER.replaceInvalidCahr(DS.da_name)
                Dim destPath As String = DS.GET_TOP1_PATH
                Dim fileSize As Long = 0

                If Not String.IsNullOrEmpty(destPath) AndAlso File.Exists(destPath) Then
                    Dim fi As New FileInfo(destPath)
                    fileSize = fi.Length
                Else
                    fileSize = 100 ' Standardgröße, falls Datei nicht gefunden
                End If

                Dim ANH As VERAG_PROG_ALLGEMEIN.cAvisoAnhaenge

                If isSendung Then
                    ANH = New VERAG_PROG_ALLGEMEIN.cAvisoAnhaenge(entity.tblSnd_AvisoID, fileName, DS.da_id, anhangsart, $".{fileExtension}", entityId, , fileSize)
                Else
                    ANH = New VERAG_PROG_ALLGEMEIN.cAvisoAnhaenge(entityId, fileName, DS.da_id, anhangsart, $".{fileExtension}", , , fileSize)
                End If

                If Not ANH.SAVE Then
                    Return "Fehler beim Speichern des Anhangs in der Datenbank."
                End If

                Return "OK"
            Catch ex As Exception
                VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace & vbNewLine, System.Reflection.MethodInfo.GetCurrentMethod.Name)
                Return "Ein Fehler ist beim Hochladen der Datei zum Datenserver aufgetreten."
            End Try
        End Function

        Private Async Function SaveFileOnServerAsync(entityId As Integer, isSendung As Boolean, fileContent As String, fileExtension As String, anhangsart As String) As Task(Of String)
            Try
                Dim TMP_PATH As String = ""
                If Environment.GetFolderPath(Environment.SpecialFolder.Personal) = "" Then ' Webserver
                    TMP_PATH = If(isSendung, "G:\temp\Verag\DatenTMP\SENDUNGSID\", "G:\temp\Verag\DatenTMP\AVISOID\")
                Else
                    TMP_PATH = Path.GetTempPath() & "\VERAG\DatenTMP\"
                End If

                TMP_PATH = TMP_PATH.Replace("\\", "\")
                If Not My.Computer.FileSystem.DirectoryExists(TMP_PATH) Then
                    My.Computer.FileSystem.CreateDirectory(TMP_PATH)
                End If

                Dim name As String = VERAG_PROG_ALLGEMEIN.cDATENSERVER.replaceInvalidCahr($"{entityId}_{anhangsart}_{Now:ddMMyy_HHmmss}").Replace("?", "")
                Dim extension As String = $".{fileExtension}"
                Dim destPath As String = TMP_PATH & name

                ' Sicherstellen, dass der Dateiname eindeutig ist
                Dim fileLock As New Object()
                SyncLock fileLock
                    While File.Exists(destPath & extension)
                        destPath = TMP_PATH & name & "_" & Now.ToString("yyyyMMddHHmmssfff")
                    End While
                End SyncLock

                Dim bytes As Byte() = Convert.FromBase64String(fileContent)
                Await Task.Run(Sub() File.WriteAllBytes(destPath & extension, bytes))

                Return "OK"
            Catch ex As Exception
                VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace & vbNewLine, System.Reflection.MethodInfo.GetCurrentMethod.Name)
                Return "Fehler beim Speichern der Datei auf dem Server."
            End Try
        End Function


        Private Shared fileLock As New Object()



        <ApiVersion("1")>
        <System.Web.Http.Route("api/v{version:apiVersion}/uploadAvisoAttString")>
        <BasicAuthentication>
        Public Function uploadAvisoAttString(anhangsart As String, arrayOfFiles As String, Optional avisoId As Integer = -1, Optional sendungsId As Integer = -1) As String
            VERAG_PROG_ALLGEMEIN.cAllgemein.TESTSYSTEM = False
            VERAG_PROG_ALLGEMEIN.cAllgemein.ERR_OP_GLOBAL = VERAG_PROG_ALLGEMEIN.ERROR_OP.MAIL

            Dim SQL As New VERAG_PROG_ALLGEMEIN.SQL

            Try
                Dim ip = Request.Properties("MS_HttpContext").Request.UserHostAddress()

                'Dim bodyText
                'Dim json

                'If HttpContext.Current.Request.GetBufferedInputStream IsNot Nothing Then
                '    Dim bodyStream As Stream = HttpContext.Current.Request.GetBufferedInputStream
                '    Dim reader = New StreamReader(bodyStream)
                '    If bodyStream.CanRead Then
                '        bodyText = reader.ReadToEnd

                '        json = JsonConvert.DeserializeObject(bodyText)

                '    Else
                '        uploadAvisoAttachment = "STREAMREADER_ERR"
                '        Return uploadAvisoAttachment
                '    End If
                'Else


                '    uploadAvisoAttachment = "UPLOAD_ERR"
                '    Return uploadAvisoAttachment
                'End If

                Dim listOfFiles As List(Of String) = arrayOfFiles.Split(",").ToList

                If Not (listOfFiles IsNot Nothing AndAlso listOfFiles.Count > 0) Then
                    uploadAvisoAttString = "FILESARRAY_EMPTY_ERR"
                    Return uploadAvisoAttString
                End If



                If anhangsart <> "" Then ' AndAlso listOfImages IsNot Nothing AndAlso listOfImages.Count > 0


                    If sendungsId > 0 Then

                        Dim SENDUNG = New VERAG_PROG_ALLGEMEIN.cSendungen(sendungsId)
                        If SENDUNG Is Nothing Then
                            uploadAvisoAttString = "NO_SENDUNG_ERR"
                            Return uploadAvisoAttString

                        Else

                            For Each image In listOfFiles
                                Dim filetemp = image.Replace("data:application/pdf;base64,", "")


                                Try
                                    Convert.FromBase64String(filetemp)
                                Catch ex As Exception
                                    uploadAvisoAttString = "BASE64_FORMAT_ERR"
                                    Return uploadAvisoAttString
                                End Try

                                Dim fileextension = VERAG_PROG_ALLGEMEIN.DATENVERVER_OPTIONS.getFileExtensionFromBase64String(filetemp)


                                Dim DS As New VERAG_PROG_ALLGEMEIN.cDATENSERVER("DOKUMENTE", "AVISO_ANHAENGE", SENDUNG.tblSnd_AvisoID, Now.ToString("ddMMyy_HHmmss.ffff"), "", anhangsart & "_" & Now.ToString("ddMMyy_HHmmss"), False)
                                DS.uploadDataToDATENSERVER_fromBase64String(filetemp, DS.da_name, IIf(fileextension.ToLower <> "unknown", "." & fileextension, ""), False, False)

                                If DS.da_id <= 0 Then
                                    uploadAvisoAttString = "UPLOAD_DS_ERR"
                                    Return uploadAvisoAttString
                                End If
                                Dim fileName = DS.da_name
                                Dim destPath = DS.GET_TOP1_PATH
                                fileName = VERAG_PROG_ALLGEMEIN.cDATENSERVER.replaceInvalidCahr(fileName)
                                Dim fi As New FileInfo(destPath)
                                Dim ANH As New VERAG_PROG_ALLGEMEIN.cAvisoAnhaenge(SENDUNG.tblSnd_AvisoID, fileName, DS.da_id, anhangsart, fi.Extension, sendungsId,, fi.Length,)
                                If Not ANH.SAVE Then
                                    uploadAvisoAttString = "SAVE_ANH_ERR"
                                    Return uploadAvisoAttString
                                End If



                            Next


                        End If

                    ElseIf avisoId > 0 Then
                        Dim AVISO = VERAG_PROG_ALLGEMEIN.cAviso.getAvisoById(avisoId)
                        If AVISO Is Nothing Then
                            uploadAvisoAttString = "NO_AVISO_ERR"
                            Return uploadAvisoAttString
                        Else
                            For Each image In listOfFiles
                                Dim filetemp = image.Replace("data:application/pdf;base64,", "")
                                Try
                                    Convert.FromBase64String(filetemp)
                                Catch ex As Exception
                                    uploadAvisoAttString = "BASE64_FORMAT_ERR"
                                    Return uploadAvisoAttString
                                End Try



                                Dim fileextension = VERAG_PROG_ALLGEMEIN.DATENVERVER_OPTIONS.getFileExtensionFromBase64String(filetemp)
                                Dim DS As New VERAG_PROG_ALLGEMEIN.cDATENSERVER("DOKUMENTE", "AVISO_ANHAENGE", avisoId, Now.ToString("ddMMyy_HHmmss.ffff"), "", anhangsart & "_" & Now.ToString("ddMMyy_HHmmss"), False)
                                DS.uploadDataToDATENSERVER_fromBase64String(filetemp, DS.da_name, IIf(fileextension.ToLower <> "unknown", "." & fileextension, ""), False, False)

                                If DS.da_id <= 0 Then
                                    uploadAvisoAttString = "UPLOAD_DS_ERR"
                                    Return uploadAvisoAttString
                                End If
                                Dim fileName = DS.da_name
                                Dim destPath = DS.GET_TOP1_PATH
                                fileName = VERAG_PROG_ALLGEMEIN.cDATENSERVER.replaceInvalidCahr(fileName)
                                Dim fi As New FileInfo(destPath)
                                Dim ANH As New VERAG_PROG_ALLGEMEIN.cAvisoAnhaenge(avisoId, fileName, DS.da_id, anhangsart, fi.Extension, sendungsId,, fi.Length,)
                                If Not ANH.SAVE Then
                                    uploadAvisoAttString = "SAVE_ANH_ERR"
                                    Return uploadAvisoAttString
                                End If
                            Next

                        End If


                    Else

                        Return uploadAvisoAttString

                    End If


                    Return "OK"
                End If


            Catch ex As Exception
                Return uploadAvisoAttString
            End Try



            Return uploadAvisoAttString
        End Function




        '------------------------------------------------------------------------
        '----------------------------------TEST----------------------------------   
        '------------------------------------------------------------------------


        <ApiVersion("1")>
        <System.Web.Http.Route("api/v{version:apiVersion}/TESTEN_POST")>
        <BasicAuthentication>
        Public Function TESTEN_POST(ByVal API_AVISO As VERAG_PROG_ALLGEMEIN.cVERAG_in_TRAviso) As String
            VERAG_PROG_ALLGEMEIN.cAllgemein.TESTSYSTEM = True
            VERAG_PROG_ALLGEMEIN.cAllgemein.ERR_OP_GLOBAL = VERAG_PROG_ALLGEMEIN.ERROR_OP.MAIL
            Dim SQL As New VERAG_PROG_ALLGEMEIN.SQL

            Dim ip = Request.Properties("MS_HttpContext").Request.UserHostAddress()

            Try
                SQL.doSQL("insert into tbltest (test,ipaddress) Values('IN_AVISO_START " & Now.ToShortDateString & "-" & Now.ToShortTimeString & "','" & ip & "')", "FMZOLL")
            Catch ex As Exception

            End Try

            Return "OK"

            '   SQL.doSQL("insert into tbltest (test) Values('" & PostValue & "')", "FMZOLL")

            Return TESTEN_POST
        End Function

        Public Shared Sub NetzwerkVerbindungHerstellen(remotePath As String, username As String, password As String)
            ' Netzwerkverbindung mit "net use" aufbauen
            Dim startInfo As New ProcessStartInfo("net", $"use {remotePath} /user:{username} {password}")
            startInfo.WindowStyle = ProcessWindowStyle.Hidden
            startInfo.CreateNoWindow = True
            Process.Start(startInfo).WaitForExit()
        End Sub

        ' Methode zum Trennen der Verbindung
        Public Shared Sub NetzwerkVerbindungTrennen(remotePath As String)
            Dim startInfo As New ProcessStartInfo("net", $"use {remotePath} /delete")
            startInfo.WindowStyle = ProcessWindowStyle.Hidden
            startInfo.CreateNoWindow = True
            Process.Start(startInfo).WaitForExit()
        End Sub

        Function NetzwerkVerbindungOffen(ByVal username As String, ByVal remotePath As String) As Boolean
            Try
                ' Führe den Befehl "net use" aus und hole die Ausgabe
                Dim process As New Process()
                process.StartInfo.FileName = "cmd.exe"
                process.StartInfo.Arguments = "/c net use"
                process.StartInfo.RedirectStandardOutput = True
                process.StartInfo.UseShellExecute = False
                process.StartInfo.CreateNoWindow = True
                process.Start()

                ' Lies die Ausgabe des Befehls
                Dim output As String = process.StandardOutput.ReadToEnd()
                process.WaitForExit()

                ' Überprüfe, ob die Ausgabe die gewünschte Freigabe und den Benutzernamen enthält
                Return output.Contains(remotePath) AndAlso output.Contains(username)

            Catch ex As Exception
                Console.WriteLine("Fehler: " & ex.Message)
                Return False
            End Try
        End Function


    End Class



    <ApiExplorerSettings(IgnoreApi:=True)> 'hide controller
    <ApiVersion("1")>
    <System.Web.Http.Route("api/v{version:apiVersion}/TEST/AVISO")>
    Public Class AVISO1TESTController
        Inherits System.Web.Http.ApiController

        ''' <summary>
        ''' Gets the Hello World Response
        ''' </summary>
        Public Function GetValue() As String
            Return "Hello world!"
        End Function

        Public Function PostValue(ByVal API_AVISO As VERAG_PROG_ALLGEMEIN.cVERAG_in_TRAviso) As String
            VERAG_PROG_ALLGEMEIN.cAllgemein.TESTSYSTEM = True
            VERAG_PROG_ALLGEMEIN.cAllgemein.ERR_OP_GLOBAL = VERAG_PROG_ALLGEMEIN.ERROR_OP.MAIL
            Dim SQL As New VERAG_PROG_ALLGEMEIN.SQL

            Dim ip = Request.Properties("MS_HttpContext").Request.UserHostAddress()

            SQL.doSQL("insert into tbltest (test,ipaddress) Values('IN_AVISO_START " & Now.ToShortDateString & "-" & Now.ToShortTimeString & "','" & ip & "')", "FMZOLL")

            Try
                Dim resultJson2 = jsonString.FromClass(API_AVISO)
                SQL.doSQL("insert into tbltest (test) Values('IN_AVISO_" & resultJson2 & "')", "FMZOLL")
            Catch ex As Exception

            End Try


            PostValue = "IN_AVISO_ERR"
            Try
                If API_AVISO Is Nothing Then Return VERAG_IN_AVISO_Exceptions.ERR_01_Wrong_Format
                If API_AVISO.Company Is Nothing OrElse API_AVISO.Company = "" Then Return VERAG_IN_AVISO_Exceptions.ERR_02_Missing_Company
                If API_AVISO.Department Is Nothing OrElse API_AVISO.Department = "" Then Return VERAG_IN_AVISO_Exceptions.ERR_03_Missing_Department
                If API_AVISO.PartnerTID Is Nothing OrElse API_AVISO.PartnerTID = "" Then Return VERAG_IN_AVISO_Exceptions.ERR_04_Missing_PartnerID
                If API_AVISO.TransportLicensePlate Is Nothing OrElse API_AVISO.TransportLicensePlate = "" Then Return VERAG_IN_AVISO_Exceptions.ERR_09_Missing_PlateNr

                Dim TR_AVISO As New VERAG_PROG_ALLGEMEIN.cVERAG_in_TRAvisoFULL


                TR_AVISO.trAv_PartnerSystem = API_AVISO.PartnerTID
                TR_AVISO.trAv_gewicht = API_AVISO.TotGrossWeight
                TR_AVISO.trAv_colli = API_AVISO.TotPackage
                TR_AVISO.trAv_Transportmittel = API_AVISO.TransportBorderType
                TR_AVISO.trAv_Grenzueberschreitung = API_AVISO.TransportModeBorder
                'TR_AVISO.trAv_FraechterKdNr = API_AVISO.PaXXXXXXXrtnerTID
                'TR_AVISO.trAv_Fraechter = API_AVISO.PaXXXXXXXrtnerTID
                'TR_AVISO.trAv_AvisiererKdNr = API_AVISO.PaXXXXXXXrtnerTID
                'TR_AVISO.trAv_Avisierer = API_AVISO.PaXXXXXXXrtnerTID
                TR_AVISO.trAv_Nationalitaet = API_AVISO.TransportCountryCode
                TR_AVISO.trAv_Kennzeichen = API_AVISO.TransportLicensePlate
                TR_AVISO.trAv_Reference = API_AVISO.Reference
                TR_AVISO.trAv_Fraechter = API_AVISO.FreightCompany
                TR_AVISO.trAv_FraechterKdNr = API_AVISO.FreightCompanyID
                TR_AVISO.trAv_Niederlassung = API_AVISO.Department
                TR_AVISO.trAv_Firma = API_AVISO.Company
                TR_AVISO.trAv_datetime = Now
                TR_AVISO.trAv_Info = API_AVISO.Info

                If Not TR_AVISO.SAVE(False) Then Return VERAG_IN_AVISO_Exceptions.ERR_05_InternalVerarb

                If API_AVISO.DOCUMENTS IsNot Nothing Then
                    For Each ANH In API_AVISO.DOCUMENTS
                        Dim TR_DOC As New VERAG_PROG_ALLGEMEIN.cVERAG_in_TRAvisoAnhaenge
                        TR_DOC.DocumentType = ANH.DocumentType
                        TR_DOC.DocumentNr = ANH.DocumentNr
                        TR_DOC.DocumentDate = ANH.DocumentDate

                        If ANH.base64BinaryStream IsNot Nothing AndAlso ANH.base64BinaryStream <> "" Then
                            TR_DOC.trAvAh_docID = VERAG_IN_AVISO_Functions.base64toDS(ANH.base64BinaryStream, TR_AVISO.trAv_Id, ANH.FileName)
                        End If
                        TR_AVISO.ANHAENGE.Add(TR_DOC)
                    Next
                End If

                If Not TR_AVISO.SAVE_Anhaenge Then Return VERAG_IN_AVISO_Exceptions.ERR_05_InternalVerarb


                If API_AVISO.POSITIONS IsNot Nothing Then
                    For Each SH In API_AVISO.POSITIONS
                        Dim EZA As New VERAG_PROG_ALLGEMEIN.cVERAG_in_eza
                        Dim SHIPMENT As New VERAG_PROG_ALLGEMEIN.cVERAG_in_eza_FULL(EZA)
                        ' Dim SHIPMENT As New VERAG_PROG_ALLGEMEIN.cVERAG_in_shippment()
                        SHIPMENT.shTr_TRAvisoId = TR_AVISO.trAv_Id 'Zur Verknüfung

                        EZA.Company = API_AVISO.Company
                        EZA.Department = API_AVISO.Department
                        EZA.Reference = SH.Reference


                        EZA.DeclarationCountry = SH.DeclarationCountry
                        EZA.DeclarationType = SH.DeclarationType

                        EZA.TotPackage = SH.NumberOfPackages
                        EZA.TotGrossWeight = SH.GrossWeight
                        'EZA.TotGrossWeight = SH.GrossWeight

                        EZA.CustomsCodeDeparture = SH.CustomsCodeDeparture
                        EZA.CustomsCodeDestination = SH.CustomsCodeDestination
                        'EZA.CustomsCodeEntry = API_AVISO.CustomsCodeEntry
                        EZA.TransportModeBorder = API_AVISO.TransportModeBorder

                        EZA.CountryCodeDeparture = SH.CountryCodeDeparture
                        EZA.CountryCodeDestination = SH.CountryCodeDestination
                        EZA.DEStateCodeDestination = SH.DEStateCodeDestination

                        EZA.TransportArrivalLicensePlate = API_AVISO.TransportLicensePlate
                        EZA.TransportArrivalCountryCode = API_AVISO.TransportCountryCode
                        EZA.TransportBorderType = API_AVISO.TransportBorderType
                        EZA.TransportBorderLicensePlate = API_AVISO.TransportLicensePlate
                        EZA.Incoterm = SH.Incoterm

                        EZA.PrePaperCode = SH.PrePaperCode
                        EZA.PrePaperNr = SH.PrePaperNr
                        ' EZA.KindOfBusiness = SH.ReferenceXXXXXXXXXXXX
                        EZA.InvoiceAmount = SH.InvoiceAmount
                        EZA.InvoiceCurrency = SH.InvoiceCurrency


                        EZA.ContainerNr1 = SH.ContainerNr1
                        EZA.ContainerNr2 = SH.ContainerNr2
                        EZA.ContainerNr3 = SH.ContainerNr3
                        EZA.ContainerNr4 = SH.ContainerNr4



                        If SH.ADDRESS IsNot Nothing Then
                            For Each ADD In SH.ADDRESS
                                Dim TR_ADD As New VERAG_PROG_ALLGEMEIN.cVERAG_in_eza_Adressen
                                TR_ADD.AddressCode = ADD.AddressCode
                                TR_ADD.CustomerID = ADD.CustomerID
                                TR_ADD.EORI = ADD.EORI
                                TR_ADD.NLNR = ADD.NLNR
                                TR_ADD.Name1 = ADD.Name1
                                TR_ADD.Name2 = ADD.Name2
                                TR_ADD.Name3 = ADD.Name3
                                TR_ADD.Street1 = ADD.Street1
                                TR_ADD.Street2 = ADD.Street2
                                TR_ADD.City = ADD.City
                                TR_ADD.CountryCode = ADD.CountryCode
                                TR_ADD.PostalCode = ADD.PostalCode
                                TR_ADD.UStID = ADD.UStID

                                EZA.ADDRESS.Add(TR_ADD)
                            Next
                        End If

                        If SH.DOCUMENTS IsNot Nothing Then
                            For Each DOC In SH.DOCUMENTS
                                Dim TR_DOC As New VERAG_PROG_ALLGEMEIN.cVERAG_in_shipment_Document
                                TR_DOC.DocumentType = DOC.DocumentType
                                TR_DOC.DocumentNr = DOC.DocumentNr
                                TR_DOC.DocumentDate = DOC.DocumentDate

                                If DOC.base64BinaryStream IsNot Nothing AndAlso DOC.base64BinaryStream <> "" Then
                                    TR_DOC.shTrPosDoc_docID = VERAG_IN_AVISO_Functions.base64toDS(DOC.base64BinaryStream, TR_AVISO.trAv_Id, DOC.FileName, "SND_ATTACHMENT")
                                End If

                                EZA.DOCUMENTS.Add(TR_DOC)
                            Next
                        End If

                        If Not SHIPMENT.SAVE() Then
                            Return VERAG_IN_AVISO_Exceptions.ERR_06_InternalSave
                        End If
                    Next
                End If

                Return "OK"

            Catch ex As Exception
                VERAG_PROG_ALLGEMEIN.cErrorHandler.ERR(ex.Message, ex.StackTrace & vbNewLine & "Datei: " & NCTS_Exceptions.ERR_03_InternalVerarb, System.Reflection.MethodInfo.GetCurrentMethod.Name)
                SQL.doSQL("insert into tbltest (test) Values('" & NCTS_Exceptions.ERR_03_InternalVerarb & ex.Message & "')", "FMZOLL")
                Return NCTS_Exceptions.ERR_03_InternalVerarb
            End Try

            '   SQL.doSQL("insert into tbltest (test) Values('" & PostValue & "')", "FMZOLL")

            Return PostValue
        End Function
    End Class


    Class VERAG_IN_AVISO_Exceptions
        Public Const ERR_01_Wrong_Format As String = "ERR_01"
        Public Const ERR_02_Missing_Company As String = "ERR_02"
        Public Const ERR_03_Missing_Department As String = "ERR_03"
        Public Const ERR_04_Missing_PartnerID As String = "ERR_04"
        Public Const ERR_05_InternalVerarb As String = "ERR_05"
        Public Const ERR_06_InternalSave As String = "ERR_06"
        Public Const ERR_07_Missing_Colli As String = "ERR_07"
        Public Const ERR_08_Missing_Gewicht As String = "ERR_08"
        Public Const ERR_09_Missing_PlateNr As String = "ERR_09"

    End Class

    Class VERAG_IN_AVISO_Functions

        Public Shared Function base64toDS(base64 As String, AvisoTRID As Integer, FileName As String, Optional uOrdner3 As String = "AVISO_ATTACHMENT") As Integer
            Dim DS As New VERAG_PROG_ALLGEMEIN.cDATENSERVER("INTERFACE", "IN", "TR_AVISO", uOrdner3, AvisoTRID, FileName)
            DS.uploadDataToDATENSERVER_fromBase64String(base64, FileName,, False)
            Return DS.da_id
        End Function

    End Class
End Namespace