3176 lines
179 KiB
VB.net
3176 lines
179 KiB
VB.net
Imports System.ComponentModel
|
|
Imports System.Data.Entity.Core.Common.CommandTrees.ExpressionBuilder
|
|
Imports System.IO
|
|
Imports System.Text.RegularExpressions
|
|
Imports DigitalData.Modules.Logging
|
|
Imports WINDREAMLib
|
|
|
|
|
|
|
|
Public Class frmNIHauptseite
|
|
Private Shared _Logger As DigitalData.Modules.Logging.Logger
|
|
Private Shared _MyLogger As LogConfig
|
|
'####Variablen für Nachindexierung
|
|
Private _windreamNI As ClassNIWindream
|
|
Private _clsWorkfile As clsNI_WorkFile
|
|
|
|
Private bwProfil As New BackgroundWorker
|
|
Private bwDatei As New BackgroundWorker
|
|
Private bwsearch As New BackgroundWorker
|
|
|
|
Private database As ClassNIDatenbankzugriff
|
|
Private xml As New ClassxmlZugriff
|
|
|
|
Private _windreamRechte As ClassWD_Rechte
|
|
Private _sqlite As ClassSQLITE
|
|
Private _fulltext As clsNIFulltext
|
|
|
|
Private manuallyRun As Boolean = False
|
|
Private manually_cancel As Boolean = True
|
|
'#### Variablen für das Profil
|
|
Private myNIDatatable As DataTable
|
|
Private myNIArrayIndexe() As String = Nothing ' zum Speichern der Indexe
|
|
Private myNIArrayValues() As String = Nothing ' zum Speichern der Werte
|
|
Public _MRDokumentart, _MRKundenKennzeichen, _MRDeskrIndex As String
|
|
Public Shared _MRKONVERT_FEHLER As Integer = 0
|
|
|
|
Private windreamSucheErgebnisse As WMObjects
|
|
'_MRKONVERT_FEHLER 1 = Konvertierungsfehler-Falsch ausgelesener/eingetragener Wert
|
|
'Private _Grundeinstellung As ClassMoReKonfiguration
|
|
'##### Generelle Variablen
|
|
Public debug As Boolean = True
|
|
Private Shared _Instance As frmNIHauptseite = Nothing
|
|
Private _validModules()
|
|
Private licenseManager As ClassLicenseManager = Nothing
|
|
Public Shared _windream As ClassWindream_allgemein
|
|
Private Const ConstWMEntityDocument = 1 ''WINDREAMLib.WMEntity.WMEntityDocument
|
|
Public Shared Function Instance() As frmNIHauptseite
|
|
If _Instance Is Nothing OrElse _Instance.IsDisposed = True Then
|
|
_Instance = New frmNIHauptseite
|
|
End If
|
|
_Instance.BringToFront()
|
|
Return _Instance
|
|
End Function
|
|
|
|
Sub New()
|
|
|
|
' Dieser Aufruf ist für den Windows Form-Designer erforderlich.
|
|
InitializeComponent()
|
|
|
|
_MyLogger = New LogConfig(LogConfig.PathType.CustomPath, Path.Combine(My.Application.Info.DirectoryPath, "Log"))
|
|
_Logger = _MyLogger.GetLogger()
|
|
_windream = New ClassWindream_allgemein(_MyLogger)
|
|
' 3a. Windream instanziieren
|
|
_windreamNI = New ClassNIWindream(_MyLogger)
|
|
database = New ClassNIDatenbankzugriff(_MyLogger)
|
|
|
|
|
|
' 3b. Windream initialisieren (Connection, Session, ... aufbauen)
|
|
If _windreamNI.Init() = False Then
|
|
_Logger.Warn("Die Windream-Klasse konnte nicht initialisiert werden. Windream-Client unvollständig gestartert.")
|
|
Exit Sub
|
|
|
|
End If
|
|
'ClassMoveRenameLogger.Init("", "MoveRename_", True)
|
|
|
|
|
|
|
|
AddHandler bwProfil.DoWork, AddressOf bwProfil_DoWork
|
|
AddHandler bwProfil.RunWorkerCompleted, AddressOf bwProfil_RunWorkerCompleted
|
|
AddHandler bwProfil.ProgressChanged, AddressOf bwProfil_ProgressChanged
|
|
|
|
AddHandler bwsearch.DoWork, AddressOf bwsearch_Documents
|
|
AddHandler bwsearch.RunWorkerCompleted, AddressOf bwsearch_RunWorkerCompleted
|
|
|
|
bwsearch.WorkerSupportsCancellation = True
|
|
|
|
bwProfil.WorkerReportsProgress = True
|
|
bwProfil.WorkerSupportsCancellation = True
|
|
|
|
AddHandler bwDatei.DoWork, AddressOf bwDatei_DoWork
|
|
AddHandler bwDatei.RunWorkerCompleted, AddressOf bwDatei_RunWorkerCompleted
|
|
AddHandler bwDatei.ProgressChanged, AddressOf bwDatei_ProgressChanged
|
|
|
|
bwDatei.WorkerReportsProgress = True
|
|
bwDatei.WorkerSupportsCancellation = True
|
|
End Sub
|
|
|
|
Private Sub frmNIHauptseite_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing
|
|
My.Settings.Save()
|
|
NI_OPENED = False
|
|
'If e.CloseReason = CloseReason.UserClosing Then
|
|
' _Logger.Info("Nachindexierung Hauptformular wird durch User geschlossen.")
|
|
'Else
|
|
' _Logger.Info("Nachindexierung Hauptformular wird automatisch geschlossen.")
|
|
'End If
|
|
End Sub
|
|
|
|
Private Sub frmNIHauptseite_Shown(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Shown
|
|
NI_OPENED = True
|
|
If My.Settings.vLogErrorsonly = False Then
|
|
_MyLogger.Debug = True
|
|
Else
|
|
_MyLogger.Debug = False
|
|
End If
|
|
|
|
If My.Settings.NI_RUNNING = True Or AUTOSTART_FIH = True Then
|
|
Start_NachindexierungThreads()
|
|
_Logger.Info("Nachindexierungslauf wird gestartet.")
|
|
If My.Settings.NI_RUNNING Then
|
|
_Logger.Info("My.Settings.NI_RUNNING = True")
|
|
End If
|
|
If AUTOSTART_FIH Then
|
|
_Logger.Info("AUTOSTART_FIH = True")
|
|
End If
|
|
Else
|
|
_Logger.Info("Nachindexierung Hauptformular wurde geladen - Nachindexierungslauf wird NICHT gestartet.")
|
|
End If
|
|
End Sub
|
|
Private Sub frmNIHauptseite_Load(sender As Object, e As System.EventArgs) Handles Me.Load
|
|
'Try
|
|
' 'LoadAllModules()
|
|
' TBTC_MOVE_RENAMETableAdapter.Connection.ConnectionString = My.Settings.DDECMConString
|
|
'Catch ex As Exception
|
|
' MsgBox(ex.Message, MsgBoxStyle.Critical, "Fehler bei frmNIHauptseite_Load")
|
|
' _Logger.Warn("Fehler bei frmNIHauptseite_Load: " & ex.Message)
|
|
'End Try
|
|
End Sub
|
|
'Private Function return_conn(ByVal dbart As String)
|
|
' Select Case dbart
|
|
' Case "MS-SQL"
|
|
' Dim csb As New SqlClient.SqlConnectionStringBuilder
|
|
' csb.DataSource = Me._Grundeinstellung.DataSource
|
|
' csb.InitialCatalog = Me._Grundeinstellung.InitialCatalog
|
|
' csb.IntegratedSecurity = False
|
|
' csb.UserID = Me._Grundeinstellung.UserId
|
|
' csb.Password = Me._Grundeinstellung.Password
|
|
|
|
' Dim connection As New SqlClient.SqlConnection(csb.ConnectionString)
|
|
|
|
' Return csb.ConnectionString
|
|
' Case "Postgre"
|
|
' Dim conn As String
|
|
' My.Settings.Save()
|
|
' conn = "Data Source=" & Me._Grundeinstellung.DataSource & ";Persist Security Info=True;User ID=" & Me._Grundeinstellung.UserId & ";Password=" & Me._Grundeinstellung.Password '& ";Unicode=True"
|
|
' Dim connection As New Oracle.DataAccess.Client.OracleConnection(conn)
|
|
' Return conn
|
|
' Case Else
|
|
' MsgBox("Test zur Zeit nicht möglich", MsgBoxStyle.Information, "Achtung:")
|
|
' Return Nothing
|
|
' End Select
|
|
'End Function
|
|
'Public Sub LoadAllModules()
|
|
' Me._validModules = Nothing
|
|
|
|
' If Not My.Settings.licensekey = "" Then
|
|
' 'Me.licenseManager = New ClassLicenseManager = Nothing
|
|
' Me.licenseManager = New ClassLicenseManager("#DigitalData9731258!#", My.Settings.licensekey)
|
|
|
|
' Me.licenseManager.licenseString = Me.licenseManager.DecodeLicenseKey(My.Settings.licensekey)
|
|
' Me.licenseManager.licenseStringArray = Me.licenseManager.SplitLicenseString(Me.licenseManager.licenseString)
|
|
' Me.licenseManager.LoadLicenses()
|
|
|
|
' Dim i As Integer = 0
|
|
|
|
' If Me.licenseManager.Licenses.Licenses IsNot Nothing Then
|
|
' For Each license As ClassLicense In Me.licenseManager.Licenses.Licenses()
|
|
' Dim expires As String = license.Expires.Date
|
|
' If IsExpired(license.Expires.Date) = False Then
|
|
' ' MsgBox(license.Modulename & vbNewLine & expires)
|
|
|
|
' Select Case license.Modulename.ToUpper
|
|
' Case "MOVEANDRENAME"
|
|
' LICENSE_MoveRename = True
|
|
' _Logger.Info("LICENSE MoveandRename aktiv")
|
|
' End Select
|
|
' i += 1
|
|
' Else
|
|
' Select Case license.Modulename
|
|
' Case "MOVEANDRENAME"
|
|
' LICENSE_MoveRename = False
|
|
' End Select
|
|
' i += 1
|
|
' End If
|
|
' 'Date.TryParse(expires, license.Expires)
|
|
|
|
' Next
|
|
' End If
|
|
' End If
|
|
'End Sub
|
|
Private Function IsExpired(ByVal _Date As Date)
|
|
If Date.Today > _Date Then
|
|
Return True
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
Private dokument As WMObject
|
|
|
|
'Private Sub btnStartStop_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
|
|
' If Me._running = False Then
|
|
' If Not Me.bwProfil.IsBusy And Not Me.bwDatei.IsBusy Then
|
|
' Me._running = True
|
|
' Me.btnStartStop.Text = "Nachindexierung stoppen"
|
|
' Me.numIntervall.Enabled = False
|
|
' Me.pnlInfos.Visible = True
|
|
|
|
' Me.timRun.Interval = Me.numIntervall.Value * 60 * 1000
|
|
' Me.timRun.Start()
|
|
|
|
' If Me.debug Then
|
|
' ClassLoggerNI.Init("", My.Settings.vLogNI & "_", True)
|
|
' ClassLoggerNI.Add(" ")
|
|
' ClassLoggerNI.Add(" ")
|
|
' ClassLoggerNI.Add(" ")
|
|
' ClassLoggerNI.Add("======================================================================")
|
|
' ClassLoggerNI.Add(" Nachindexierungsvorgang gestartet ")
|
|
' ClassLoggerNI.Add("______________________________________________________________________")
|
|
' ClassLoggerNI.Add(" ")
|
|
' ClassLoggerNI.Add(" Datum: " & Now.Date & " " & Now.Date.ToShortTimeString)
|
|
' ClassLoggerNI.Add(" Intervall: " & Me.numIntervall.Value)
|
|
' ClassLoggerNI.Add("======================================================================")
|
|
' End If
|
|
|
|
' ' den Indexierungsvorgang direkt (zum ersten Mal) durchführen
|
|
' Me.Suche_ausfuehren()
|
|
' Else
|
|
' MsgBox("Die Prozesse laufen noch")
|
|
' End If
|
|
|
|
' Else
|
|
' Me._running = False
|
|
' Me.btnStartStop.Text = "Nachindexierung starten"
|
|
' Me.numIntervall.Enabled = True
|
|
' Me.pnlInfos.Visible = False
|
|
|
|
' If Me.bwProfil.IsBusy Then
|
|
' Me.bwProfil.CancelAsync()
|
|
' End If
|
|
|
|
' 'If Me.bwDatei.IsBusy Then
|
|
' ' Me.bwDatei.CancelAsync()
|
|
' 'End If
|
|
|
|
' Me.timRun.Stop()
|
|
' End If
|
|
'End Sub
|
|
Private Sub startDateiDurchlauf()
|
|
bwDatei.RunWorkerAsync()
|
|
End Sub
|
|
Private Sub bwDatei_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs)
|
|
If bwDatei.CancellationPending Then
|
|
_Logger.Info("bwDatei.CancellationPending - e.Cancel")
|
|
e.Cancel = True
|
|
ElseIf manually_cancel = True Then
|
|
_Logger.Info("bwDatei.manually_cancel - e.Cancel")
|
|
e.Cancel = True
|
|
Else
|
|
IndexiereVerarbeiteDokument(Me.aktivesDokument)
|
|
End If
|
|
|
|
End Sub
|
|
|
|
Private Sub bwDatei_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs)
|
|
If e.Cancelled Then
|
|
' MsgBox("Die Nachindexierung wurde abgebrochen.", MsgBoxStyle.Information, "Vorgang abgebrochen (Datei)")
|
|
Else
|
|
If Me.bwDatei.IsBusy Then
|
|
_Logger.Warn("Achtung: bwDatei-RunWorkerCompleted aber bwDatei.Busy - CancelAsync")
|
|
Me.bwDatei.CancelAsync()
|
|
End If
|
|
' MsgBox("Fertig")
|
|
End If
|
|
End Sub
|
|
|
|
Private Sub bwDatei_ProgressChanged(ByVal sender As Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs)
|
|
End Sub
|
|
Private Sub startProfileDurchlauf()
|
|
bwProfil.RunWorkerAsync()
|
|
End Sub
|
|
Private Sub bwsearch_Documents(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs)
|
|
Try
|
|
windreamSucheErgebnisse = Me._windreamNI.GetSearchDocuments(Me.aktivesProfil.WindreamSuche)
|
|
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
End Sub
|
|
Private Sub bwsearch_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs)
|
|
|
|
If e.Cancelled Then
|
|
_Logger.Warn("Achtung: Ausführung der Suche wurde abgebrochen(" & Now & ")")
|
|
ElseIf e.Error IsNot Nothing Then
|
|
' MsgBox("Fehler")
|
|
Else
|
|
' MsgBox("Fertig")
|
|
|
|
Dim minutes = CLng(System.DateTime.Now.Subtract(CURRENT_START_DATETIME).Minutes)
|
|
If minutes >= 1 Then
|
|
_Logger.Warn("Suchdauer >= 1 Minute aber letzendlich ausgeführt (" & Now & ")")
|
|
End If
|
|
|
|
End If
|
|
|
|
End Sub
|
|
Private Sub bwProfil_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs)
|
|
Try
|
|
'If bwProfil.CancellationPending Then
|
|
' e.Cancel = True
|
|
'End If
|
|
Dim _Fehler As Boolean = False
|
|
For Each profil As ClassNIProfil In ClassNIProfile.Profile
|
|
_Fehler = False
|
|
' aktuelles Profil der Klasse mitteilen
|
|
Me.aktivesProfil = profil
|
|
_clsWorkfile = New clsNI_WorkFile(_MyLogger)
|
|
_clsWorkfile.aktivesProfil = profil
|
|
'_clsMoRe = New ClassMO_RE(_MyLogger)
|
|
' Profilname aktualisieren (in lblProfilname)
|
|
bwProfil.ReportProgress(-3)
|
|
|
|
' Ausgabe an Logdatei über nächstes Profil
|
|
_Logger.Info("########################################################")
|
|
_Logger.Info("Starte Durchlauf für Profil: " & profil.Profilname & " - " & Now)
|
|
|
|
' Überprüfen ob Profil aktiv oder inaktiv
|
|
If CBool(Me.aktivesProfil.Aktiv) = False Then
|
|
_Logger.Info("Profil: " & profil.Profilname & " ist inaktiv geschaltet")
|
|
|
|
Else
|
|
' den Durchlaufszeitpunkt speichern
|
|
aktivesProfil.LastRun = Now
|
|
'AUSKOMMENTIERT um Fehler beim Speichern der Dateien zu verhindern!! 17.08.2015
|
|
'aktivesProfil.Save(False)
|
|
|
|
If clsHelper.file_exists(Me.aktivesProfil.WindreamSuche, "NI") = False AndAlso Me.aktivesProfil.WindreamSuche.ToLower.Contains("select") = False Then
|
|
_Logger.Warn("Windream Suche für Profil: " & profil.Profilname & " konnte nicht ausgeführt werden! Die Datei " & Me.aktivesProfil.WindreamSuche & " existiert nicht!")
|
|
' wenn die gesuchte File eine Suche ist: per MAil informierne und Indexierung abbrechen
|
|
|
|
Abbruch_NI("Windream-Suche konnte nicht gefunden werden!", True, False)
|
|
clsHelper.Add_Application_log("Nachindexierung wurde abgebrochen, da eine Windream-Suche (" & Me.aktivesProfil.WindreamSuche & ") nicht gefunden werden konnte")
|
|
|
|
Else
|
|
' wenn im aktuellen Suchergebnis Verknüpfungen vorhanden sind
|
|
If Me.aktivesProfil.Verknüpfungen IsNot Nothing Then
|
|
' windream-Suche für Profil starten
|
|
bwsearch.RunWorkerAsync()
|
|
Dim d1 As Date = Now
|
|
CURRENT_START_DATETIME = Now
|
|
Dim oldminute As Integer = 0
|
|
Do While bwsearch.IsBusy
|
|
Dim minutes = CLng(System.DateTime.Now.Subtract(d1).Minutes)
|
|
If minutes >= 1 And minutes <> oldminute Then
|
|
oldminute = minutes
|
|
_Logger.Warn("bwsearch IsBusy " & Now & " - MinutesSinceRunWD-Search: " & minutes.ToString)
|
|
If minutes >= 2 Then
|
|
Select Case minutes
|
|
Case 3
|
|
_Logger.Warn($"Die Ausführung der Suche [{Me.aktivesProfil.WindreamSuche}] dauerte zu lange - MinutesSinceRunWD-Search: " & minutes.ToString)
|
|
_Logger.Warn("Die Nachindexierung wird abgebrochen und läuft wieder im Intervall an!")
|
|
'ClassNIEmail.Send_Urgent("Achtung - die Ausführung der Suche: " & Me.aktivesProfil.WindreamSuche & " dauerte viel zu lange! <p> Prüfen Sie schnellst möglich die Client-Konfiguration")
|
|
Abbruch_NI("Abbruch nach Timeout Suche", False, True)
|
|
CURRENT_STATE = "Abbruch Timeout"
|
|
Exit Sub
|
|
End Select
|
|
End If
|
|
End If
|
|
Loop
|
|
If bwProfil.CancellationPending Or bwsearch.CancellationPending Then
|
|
_Logger.Warn(" CancellationPending2 - Abbruch durchgeführt - Nun Exit Sub")
|
|
Exit Sub
|
|
End If
|
|
|
|
|
|
If _Fehler = False Then
|
|
If Not IsNothing(windreamSucheErgebnisse) Or WMSearchIsSQL = True Then
|
|
|
|
|
|
|
|
If (Not IsNothing(windreamSucheErgebnisse) AndAlso windreamSucheErgebnisse.Count > 0) Or WMSearchIsSQL = True Then
|
|
If (Not IsNothing(windreamSucheErgebnisse) AndAlso windreamSucheErgebnisse.Count > 0) Then
|
|
_Logger.Debug($"windreamSucheErgebnisse.Count: [{windreamSucheErgebnisse.Count}]")
|
|
ElseIf WMSearchIsSQL = True Then
|
|
_Logger.Debug($"windreamSucheErgebnisse will be collected with SQL!")
|
|
End If
|
|
|
|
'Wenn Nachbearbeitung AD aktiv ist dann, Klassen initialisieren
|
|
If aktivesProfil.NachbearbeitungAD = True Then
|
|
_Logger.Debug($"aktivesProfil.NachbearbeitungAD = True")
|
|
'Erst DB
|
|
_sqlite = New ClassSQLITE(_MyLogger)
|
|
_windreamRechte = New ClassWD_Rechte(_MyLogger, _sqlite)
|
|
If _sqlite.DBInit(False) = True Then
|
|
_Logger.Debug($"ClassSQLITE initialized...")
|
|
'Dann Rechte-Klasse
|
|
If _windreamRechte.Init() = False Then
|
|
_Logger.Warn("## Die AD-Rechteklasse konnte nicht initialisert werden - Profil Abbruch")
|
|
_Fehler = True
|
|
Else
|
|
_Logger.Debug($"The AD-RightClass has been initialized...")
|
|
End If
|
|
Else
|
|
_Logger.Warn("## Die SQLite-DB konnte nicht initialisert werden - Profil Abbruch")
|
|
_Fehler = True
|
|
End If
|
|
Else
|
|
_Logger.Debug("NachbearbeitungAD inaktiv")
|
|
End If
|
|
|
|
If _Fehler = False Then
|
|
'profil()
|
|
' nun Profilabhängige Parameter laden
|
|
If aktivesProfil.IndexValidation <> "" Then
|
|
_Logger.Debug("Dokumente sollen für Validierung markiert werden - Index: " & aktivesProfil.IndexValidation)
|
|
_clsWorkfile._SetFileValidation = True
|
|
Else
|
|
_clsWorkfile._SetFileValidation = False
|
|
End If
|
|
_Logger.Debug($"clsWorkfile._filevalidation Checked...")
|
|
If My.Settings.ERROR_INDEX <> "" Then
|
|
_Logger.Debug("Error-msg shall be logged in index: " & My.Settings.ERROR_INDEX)
|
|
|
|
End If
|
|
_Logger.Debug($"clsWorkfile._fileerror Checked...")
|
|
_Logger.Debug("Ni-Art: " & aktivesProfil.Ni_Art.ToLower)
|
|
' neue Anzahl von Dateien an ProgressBar2
|
|
If WMSearchIsSQL = False Then
|
|
bwProfil.ReportProgress(windreamSucheErgebnisse.Count)
|
|
End If
|
|
|
|
Dim oWorkCount As Integer = 1
|
|
If WMSearchIsSQL = False Then
|
|
For Each dok As WMObject In windreamSucheErgebnisse
|
|
Dim StopwatchTimer As New ClassStopwatch("Stopwatch FileRun")
|
|
_Logger.Info($"Working on Doc: [{dok.aName}] # ({oWorkCount} of {windreamSucheErgebnisse.Count})")
|
|
' aktuelles Dokument der Klasse mitteilen
|
|
Me.aktivesDokument = dok
|
|
|
|
'####### Go für das Dokument ##########
|
|
' Thread für diese Datei starten
|
|
Me.startDateiDurchlauf()
|
|
'######################################
|
|
' solange der Datei-Thread noch nicht abgeschlossen wurde
|
|
|
|
While Me.bwDatei.IsBusy
|
|
|
|
End While
|
|
' nächste Datei an ProgressBar2
|
|
bwProfil.ReportProgress(-1)
|
|
oWorkCount += 1
|
|
' Vorgang abbrechen
|
|
If bwProfil.CancellationPending Then
|
|
_Logger.Info($"bwProfil.CancellationPending...Exit bwProfil_DoWork")
|
|
StopwatchTimer.Done()
|
|
Exit Sub
|
|
ElseIf manually_cancel = True Then
|
|
_Logger.Info($"manually_cancel...Exit bwProfil_DoWork")
|
|
StopwatchTimer.Done()
|
|
Exit Sub
|
|
End If
|
|
|
|
Dim swMessage = StopwatchTimer.Done()
|
|
If swMessage <> "" Then
|
|
_Logger.Info(swMessage)
|
|
End If
|
|
Next
|
|
Else
|
|
Try
|
|
Dim oDTResults As DataTable
|
|
oDTResults = DB_ECM.GetDatatable(aktivesProfil.WindreamSuche)
|
|
|
|
If Not IsNothing(oDTResults) Then
|
|
If oDTResults.Rows.Count > 0 Then
|
|
bwProfil.ReportProgress(oDTResults.Rows.Count)
|
|
_Logger.Debug($">> Working on [{oDTResults.Rows.Count}] documents via SQL...")
|
|
If Not IsNothing(_windreamNI) Then
|
|
Dim oColumnIndex As Integer
|
|
Try
|
|
Dim oCheckInt As Integer
|
|
Dim oCheckStr As String
|
|
If Integer.TryParse(oDTResults.Rows(0).Item(1).ToString, oCheckInt) Then
|
|
|
|
oColumnIndex = 0
|
|
Else
|
|
oColumnIndex = 1
|
|
End If
|
|
_Logger.Debug($">> WM fullFilePath is obviously located in ColumnIndex: {oColumnIndex}")
|
|
Catch ex As Exception
|
|
|
|
End Try
|
|
Dim i As Integer = 0
|
|
For Each oROW As DataRow In oDTResults.Rows
|
|
Dim oFilenameWM = oROW.Item(oColumnIndex).ToString
|
|
oFilenameWM = oFilenameWM.Replace("W:", "")
|
|
oFilenameWM = oFilenameWM.Replace("\\windream\objects", "")
|
|
_Logger.Debug($">> Trying to create WMObject by path [{oFilenameWM}] ...")
|
|
'Dim _dok As WMObject
|
|
'_dok = Nothing
|
|
Try
|
|
aktivesDokument = _windreamNI.oWMSession.GetWMObjectByPath(ConstWMEntityDocument, oFilenameWM)
|
|
Catch ex As Exception
|
|
_Logger.Warn($"ATTENTION: error while creating a windream-object via objectpath - ERROR [{ex.InnerException.Message}]")
|
|
_Logger.Warn($"Filename [{oFilenameWM}]")
|
|
_Logger.Error(ex)
|
|
bwProfil.ReportProgress(-4)
|
|
Exit Sub
|
|
End Try
|
|
|
|
If Not IsNothing(aktivesDokument) Then
|
|
_Logger.Debug($"..Got a windream-document-object for {aktivesDokument.aName}...")
|
|
i += 1
|
|
'####### Go für das Dokument ##########
|
|
' Thread für diese Datei starten
|
|
Me.startDateiDurchlauf()
|
|
'######################################
|
|
' solange der Datei-Thread noch nicht abgeschlossen wurde
|
|
|
|
While Me.bwDatei.IsBusy
|
|
|
|
End While
|
|
' nächste Datei an ProgressBar2
|
|
bwProfil.ReportProgress(-1)
|
|
oWorkCount += 1
|
|
' Vorgang abbrechen
|
|
If bwProfil.CancellationPending Then
|
|
_Logger.Info($"bwProfil.CancellationPending...Exit bwProfil_DoWork")
|
|
Exit Sub
|
|
ElseIf manually_cancel = True Then
|
|
_Logger.Info($"manually_cancel...Exit bwProfil_DoWork")
|
|
|
|
Exit Sub
|
|
End If
|
|
Else
|
|
_Logger.Error("Could not create a WMDocument via path!")
|
|
End If
|
|
Next
|
|
Else
|
|
_Logger.Error("ATTENTION: _windreamNI not intitialized properly...")
|
|
_Logger.Warn("ATTENTION: _windreamNI not intitialized properly...")
|
|
End If
|
|
End If
|
|
Else
|
|
_Logger.Warn($"ATTENTION: The datatable for WMResults is nothing")
|
|
_Logger.Warn($"SQL WMResults: {aktivesProfil.WindreamSuche}")
|
|
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn($"UNEXPECTED ERROR IN GetSearchDocuments via SQL: {ex.Message}")
|
|
_Logger.Warn($"Dokument: {aktivesDokument.aName}")
|
|
_Logger.Error(ex)
|
|
Dim oLIneNumber = GetLineNumber(ex)
|
|
If oLIneNumber > 0 Then
|
|
_Logger.Warn($"#### oLIneNumber: {oLIneNumber} ####")
|
|
End If
|
|
End Try
|
|
|
|
End If
|
|
|
|
|
|
Else
|
|
_Logger.Debug("Fehler = True - Check Log")
|
|
_Logger.Warn("Fehler = True - Check Log")
|
|
bwProfil.ReportProgress(-4)
|
|
End If
|
|
|
|
Else
|
|
_Logger.Debug("Keine windream-Dokumente für Profil: " & profil.Profilname & " gefunden!")
|
|
' keine Dateien zum Indexieren
|
|
bwProfil.ReportProgress(-4)
|
|
End If
|
|
Else
|
|
_Logger.Warn($"windreamSucheErgebnisse Is Nothing!! - Please check Search of {profil.Profilname}")
|
|
End If
|
|
Else
|
|
_Logger.Warn("_Fehler = True - Check the config of Nachindexierung")
|
|
bwProfil.ReportProgress(-4)
|
|
End If
|
|
|
|
Else
|
|
'Keine Verknüpfungen
|
|
_Logger.Warn("Es liegen keine Verknüpfungen für dieses Profil vor!")
|
|
End If
|
|
End If
|
|
|
|
End If
|
|
_Logger.Info("####################################################End Profile DoWork####")
|
|
' nächstes Profil an ProgressBar1
|
|
bwProfil.ReportProgress(-2)
|
|
Next
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
|
|
End Sub
|
|
Public Function GetLineNumber(ByVal ex As Exception)
|
|
Dim lineNumber As Int32 = 0
|
|
Const lineSearch As String = ":line "
|
|
Dim index = ex.StackTrace.LastIndexOf(lineSearch)
|
|
If index <> -1 Then
|
|
Dim lineNumberText = ex.StackTrace.Substring(index + lineSearch.Length)
|
|
If Int32.TryParse(lineNumberText, lineNumber) Then
|
|
End If
|
|
End If
|
|
Return lineNumber
|
|
End Function
|
|
Private Sub bwProfil_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs)
|
|
|
|
If e.Cancelled Then
|
|
MsgBox("Die Nachindexierung wurde abgebrochen.", MsgBoxStyle.Information, "Vorgang abgebrochen")
|
|
ElseIf e.Error IsNot Nothing Then
|
|
' MsgBox("Fehler")
|
|
Else
|
|
_Logger.Debug("bwProfil_RunWorkerCompleted")
|
|
_Logger.Info("")
|
|
|
|
End If
|
|
Dim actdatetime = Now
|
|
Dim newrun_dt As DateTime = actdatetime.AddMinutes(Me.numIntervall.Value)
|
|
Me.lblStatus.Text = $"(Status: WARTEN auf den nächsten Durchlauf: {newrun_dt.ToString})"
|
|
tslblStatus.Text = $"Status: WARTEN auf den nächsten Durchlauf: {newrun_dt.ToString}"
|
|
Me.tslblStatus.Visible = True
|
|
|
|
End Sub
|
|
|
|
Private Sub bwProfil_ProgressChanged(ByVal sender As Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs)
|
|
|
|
If e.ProgressPercentage = -4 Then
|
|
Me.ProgressBar2.Minimum = 0
|
|
Me.ProgressBar2.Maximum = 2
|
|
Me.ProgressBar2.Value = Me.ProgressBar2.Maximum
|
|
Me.lblDatei.Text = "- keine Dateien für dieses Profil -"
|
|
ElseIf e.ProgressPercentage = -3 Then
|
|
Me.lblProfilname.Text = Me.aktivesProfil.Profilname
|
|
Me.lblDatei.Text = ""
|
|
ElseIf e.ProgressPercentage = -2 Then
|
|
Me.ProgressBar1.Value += 1
|
|
ElseIf e.ProgressPercentage = -1 Then
|
|
Me.lblDatei.Text = Me.aktivesDokument.aName
|
|
Me.ProgressBar2.Value += 1
|
|
Else
|
|
Me.ProgressBar2.Minimum = 0
|
|
Me.ProgressBar2.Maximum = e.ProgressPercentage
|
|
Me.ProgressBar2.Value = 0
|
|
End If
|
|
|
|
End Sub
|
|
Public aktivesProfil As ClassNIProfil
|
|
Private Shared aktivesDokument As WMObject
|
|
|
|
Public Sub Profile_Durchlaufen()
|
|
Try
|
|
lblNotWorking.Visible = False
|
|
pnlInfos.Visible = True
|
|
|
|
If My.Settings.Sleep_Begin > 0 And My.Settings.Sleep_End > 0 Then
|
|
If Now.Hour >= CInt(My.Settings.Sleep_Begin) And Now.Hour <= CInt(My.Settings.Sleep_End) Then
|
|
_Logger.Info(String.Format(">> ToolCollection is in SleepMode - {0}-{1}-{2}", Now.Hour.ToString, My.Settings.Sleep_Begin.ToString, My.Settings.Sleep_End.ToString))
|
|
Dim actdatetime = Now
|
|
Dim newrun_dt As DateTime = actdatetime.AddMinutes(Me.numIntervall.Value)
|
|
lblNotWorking.Text = $"In SleepMode - Next Check: {newrun_dt.ToString}"
|
|
lblNotWorking.Visible = True
|
|
pnlInfos.Visible = False
|
|
Exit Sub
|
|
End If
|
|
End If
|
|
Dim IsWorking_Hour = False
|
|
If My.Settings.NI_WORKING_HOURS <> "" Then
|
|
Dim hourarray As String() = My.Settings.NI_WORKING_HOURS.Split(";")
|
|
For Each _hour As String In hourarray
|
|
If Now.Hour = _hour Then
|
|
IsWorking_Hour = True
|
|
End If
|
|
Next
|
|
If IsWorking_Hour = False Then
|
|
Dim actdatetime = Now
|
|
Dim newrun_dt As DateTime = actdatetime.AddMinutes(Me.numIntervall.Value)
|
|
|
|
lblNotWorking.Text = $"No working-slot - working hours are: {My.Settings.NI_WORKING_HOURS} Next Check: {newrun_dt.ToString}"
|
|
lblNotWorking.Visible = True
|
|
pnlInfos.Visible = False
|
|
_Logger.Info(String.Format(">> ToolCollection is not in WorkingMode - NowHour: {0} - Working hours are: {1}", Now.Hour.ToString, My.Settings.NI_WORKING_HOURS))
|
|
Exit Sub
|
|
End If
|
|
Else
|
|
IsWorking_Hour = True
|
|
End If
|
|
If _windreamNI.Init() = False Then
|
|
clsHelper.Add_Application_log("Die Windream-Klasse konnte nicht initialisiert werden. Windream-Client unvollständig gestartert?")
|
|
|
|
Exit Sub
|
|
End If
|
|
'nur weiter machen wenn kein BackgroundWorker mehr läuft
|
|
If Not Me.bwProfil.IsBusy And Not Me.bwDatei.IsBusy And Not Me.bwsearch.IsBusy Then
|
|
_Logger.Info("Nachindexierungsvorgang gestartet ")
|
|
Me.lblStatus.Text = "(Status: Nachindexieren läuft)"
|
|
Me.tslblStatus.Text = "Status: Nachindexieren läuft"
|
|
Me.tslblStatus.Visible = True
|
|
'If debug = False Then
|
|
' ClassLoggerNI.Init("", My.Settings.vLogNI & "_", True)
|
|
'End If
|
|
' Profile laden
|
|
ClassNIProfile.Init()
|
|
|
|
Dim profil_id As Integer = 1
|
|
|
|
If ClassNIProfile.Profile IsNot Nothing Then
|
|
_Logger.Debug("Anzahl der Profile: " & ClassNIProfile.Count)
|
|
If debug Then
|
|
Dim resultProfilnamen As String = ""
|
|
For Each profil As ClassNIProfil In ClassNIProfile.Profile
|
|
_Logger.Debug($"Start Profile-Run for ProfilName [{ profil.Profilname}] ")
|
|
resultProfilnamen &= "- " & profil.Profilname & vbNewLine
|
|
Next
|
|
|
|
End If
|
|
|
|
Me.ProgressBar1.Minimum = 0
|
|
Me.ProgressBar1.Maximum = ClassNIProfile.Count
|
|
Me.ProgressBar1.Value = 0
|
|
|
|
Me.Refresh()
|
|
Me.startProfileDurchlauf()
|
|
Else
|
|
_Logger.Warn("Attention: ClassNIProfile.Profile IsNothing")
|
|
End If
|
|
Else
|
|
_Logger.Info("ATTENTION: Threads are still running...")
|
|
'If Me.bwProfil.IsBusy Then
|
|
' _Logger.Warn("ACHTUNG: der Thread Profil arbeitet noch unerwartet - es wird nun der Thread abgebrochen")
|
|
' Me.bwProfil.CancelAsync()
|
|
|
|
' If bwDatei.IsBusy Then
|
|
' _Logger.Warn("ACHTUNG: Thread Datei wird ebenso abgebrochen")
|
|
' Me.bwDatei.CancelAsync()
|
|
' End If
|
|
|
|
'End If
|
|
'If Me.bwsearch.IsBusy Then
|
|
' _Logger.Warn("ACHTUNG: der Thread Search arbeitet noch unerwartet - es wird nun der Thread abgebrochen")
|
|
' Me.bwsearch.CancelAsync()
|
|
'End If
|
|
'If Me.bwDatei.IsBusy Then
|
|
' _Logger.Warn("der Thread Datei arbeitet noch unerwartet")
|
|
' Try
|
|
' _Logger.Warn("Thread Datei wird abgebrochen....")
|
|
' Me.bwDatei.CancelAsync()
|
|
' manuallyRun = False
|
|
' Catch ex As Exception
|
|
' _Logger.Warn("Fehler beim Abbrechen des Threads (Profile_Durchlaufen) bwDatei: " & ex.Message)
|
|
' End Try
|
|
'End If
|
|
'_Logger.Warn("Es wird versucht die Nachindexierung neu zu starten - 10sec Break")
|
|
'System.Threading.Thread.Sleep(10000)
|
|
'Start_NachindexierungThreads()
|
|
End If
|
|
Catch ex As Exception
|
|
' bei einem Fehler einen Eintrag in der Logdatei machen
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
manuallyRun = False
|
|
End Sub
|
|
|
|
Private Sub timRun_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles timRun.Tick
|
|
Me.Profile_Durchlaufen()
|
|
End Sub
|
|
'Public Shared Sub _Logger.Info(ByVal _error As String, Optional _mitPraefix As Boolean = False, Optional _inJedemFallLoggen As Boolean = False)
|
|
' If My.Settings.vLogErrorsonly = False Or _inJedemFallLoggen = True Then
|
|
' Select Case _mitPraefix
|
|
' Case False
|
|
' _Logger.Warn(" >> " & _error)
|
|
' Case True
|
|
' _Logger.Warn(_error, True)
|
|
' End Select
|
|
' End If
|
|
'End Sub
|
|
Private Function Check_Desk_Index()
|
|
'Als erste überprüfen ob überhaupt ein Dekriptiver Index ausgelesen werden kann
|
|
Dim DESKINDEX_VALUE As Object = Nothing
|
|
Dim errormsg As String
|
|
Try
|
|
If aktivesProfil.Desk_windreamIndex <> String.Empty Then
|
|
'den Wert des deskriptiven Indexes für das aktuelle Dokument auslesen
|
|
DESKINDEX_VALUE = aktivesDokument.GetVariableValue(aktivesProfil.Desk_windreamIndex)
|
|
Else
|
|
_Logger.Warn($"Check_Desk_Index: Es wurde kein deskriptiver Index für das Profil [{aktivesProfil.OriginalProfilname}] hinterlegt!")
|
|
Return True
|
|
End If
|
|
Catch ex As Exception
|
|
errormsg = " FEHLER bei Check_Desk_Index (GetVariableValue für Index '" & aktivesProfil.Desk_windreamIndex & "'): " & ex.Message
|
|
_Logger.Warn(errormsg)
|
|
' wenn ein Fehler aufgetreten ist, muss das Flag gesetzt werden
|
|
Return True
|
|
|
|
End Try
|
|
If DESKINDEX_VALUE Is String.Empty Then
|
|
errormsg &= vbNewLine & " ACHTUNG - Für DESKINDEX konnte kein Wert gelesen werden - Indexierungsvorgang wird abgebrochen"
|
|
' wenn die Abfrage in windream kein Ergebnis gab, muss das Fehlerflag gesetzt werden
|
|
Return True
|
|
_Logger.Warn(errormsg)
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Indexiert die windream-Suchergebnisse
|
|
Public Sub IndexiereVerarbeiteDokument(ByVal pMyWMDoc As WMObject)
|
|
Dim oResultNachindexierung = Nothing
|
|
|
|
Try
|
|
If bwDatei.CancellationPending Then
|
|
_Logger.Info("bwDatei.CancellationPending - IndexiereVerarbeiteDokument - Exit Sub")
|
|
Exit Sub
|
|
End If
|
|
Dim moved_Folder As String = ""
|
|
Dim swWorkDocument_All As New ClassStopwatch("WorkDocument_All")
|
|
Dim swRegIndex As New ClassStopwatch("RegularIndexing")
|
|
' _Logger.Info($"IndexiereVerarbeiteDokument [{Me.aktivesDokument.aName}]...")
|
|
' dient zum Überprüfen auf Fehler
|
|
Dim oUnexpectedError As Boolean = False
|
|
Dim unvollstaendig As Boolean = False
|
|
_MRKONVERT_FEHLER = 0
|
|
Dim result As String = ""
|
|
Dim fehlermsg As String = ""
|
|
Dim IndexwertAusWindream As Object = Nothing
|
|
Dim eindeutigerWertausWindream As String
|
|
Dim _pathxmlfile As String
|
|
'Liefert nur den PFad des aktiven Dokumens
|
|
Dim ordnerpfad As String = IO.Path.GetDirectoryName(My.Settings.vWLaufwerk & ":" & pMyWMDoc.aPath)
|
|
_Logger.Debug("OrdnerPfad der Datei: " & ordnerpfad)
|
|
Try
|
|
CURRENT_DOCID = CInt(pMyWMDoc.GetVariableValue("Dokument-ID"))
|
|
Catch ex As Exception
|
|
CURRENT_DOCID = 0
|
|
End Try
|
|
|
|
'Schalter um zu überprüfen ob es im Durchlauf ein SQL-Ergebnis gab
|
|
Dim _ergebnisSQL As Boolean = False
|
|
'Die Tabelle mit den select werten leeren
|
|
MyDataset.TBVEKTOR_ARRAY.Clear()
|
|
'Als erste überprüfen ob überhaupt ein Deskriptiver Index ausgelesen werden kann
|
|
Select Case Me.aktivesProfil.Ni_Art.ToLower
|
|
Case "fulltext"
|
|
Dim fulltext
|
|
Try
|
|
_fulltext = New clsNIFulltext(_MyLogger)
|
|
_Logger.Debug(">> _fulltext initialized.")
|
|
fulltext = pMyWMDoc.GetVariableValue(aktivesProfil.Desk_windreamIndex)
|
|
If Len(fulltext) > 0 Then
|
|
_Logger.Info($"{aktivesProfil.Desk_windreamIndex} is empty...")
|
|
Else
|
|
_Logger.Info($"## No fulltext from [{aktivesProfil.Desk_windreamIndex}] extracted!")
|
|
fulltext = pMyWMDoc.GetVariableValue("Manueller Volltext")
|
|
End If
|
|
If Len(fulltext) > 0 Then
|
|
Volltext_indexer(pMyWMDoc, fulltext)
|
|
Else
|
|
_Logger.Info($"## Even no fulltext from Manueller Volltext extracted!")
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
oUnexpectedError = True
|
|
unvollstaendig = True
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
|
|
End Try
|
|
|
|
|
|
Case "db"
|
|
oUnexpectedError = Check_Desk_Index()
|
|
'If aktivesProfil.checkIndexsql = "" Then
|
|
' _Logger.Debug("# HINWEIS: Eine sql-Überprüfung des Indexwertes ist nicht hinterlegt! Dies kann zu falsch-positiven Werten führen!#")
|
|
'End If
|
|
If aktivesProfil.checkIndexsql <> String.Empty And oUnexpectedError = False Then
|
|
_Logger.Debug("Überprüfung des deskriptiven Indexwertes gegen die DB")
|
|
Dim oResultCheck As Integer
|
|
'##################
|
|
'Zuerst überprüfen ob der Deskriptive Idnex einen gültigen Wert zurückliefert
|
|
Try
|
|
Dim odescIndexValue As String
|
|
Dim oAttribute = _windreamNI.oWMSession.GetWMObjectByName(WINDREAMLib.WMEntity.WMEntityAttribute, aktivesProfil.Desk_windreamIndex)
|
|
Try
|
|
Dim vType = oAttribute.getVariableValue("dwAttrType")
|
|
|
|
If vType >= 4097 Or vType = 8 Then
|
|
oResultCheck = 1
|
|
_Logger.Warn($"Could not check descriptiveIndex as Index is a Vectorfield!")
|
|
|
|
Else
|
|
' den Wert des deskriptiven Indexes für das aktuelle Dokument auslesen
|
|
odescIndexValue = pMyWMDoc.GetVariableValue(aktivesProfil.Desk_windreamIndex)
|
|
oResultCheck = Check_DeskIndexValue(odescIndexValue, aktivesProfil.checkIndexsql, pMyWMDoc)
|
|
End If
|
|
|
|
Catch ex As Exception
|
|
|
|
_Logger.Warn($" Error getting {pMyWMDoc.aName} # Der deskriptive Indexwert '{odescIndexValue}' of Index [{aktivesProfil.Desk_windreamIndex}] verweist auf KEINEN Eintrag in der Datenbank!")
|
|
|
|
End Try
|
|
|
|
|
|
'Überprüfen welcher WErt zurücgekommen ist
|
|
Select Case oResultCheck
|
|
Case 0
|
|
'Kein Ergebnis für den Deskriptiven Index also Kennzeichnen des Dokumentes über den Index der das Dokument für die Validierung kennzeichnet
|
|
_Logger.Warn($"{pMyWMDoc.aName} # Der deskriptive Indexwert '{odescIndexValue}' of Index [{aktivesProfil.Desk_windreamIndex}] verweist auf KEINEN Eintrag in der Datenbank!")
|
|
fehlermsg &= " >> Der deskriptive Indexwert " & odescIndexValue & " verweist auf KEINEN Eintrag in der Datenbank!"
|
|
'Fehler = True
|
|
unvollstaendig = True
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
SetErrorMeldung("Value '" & odescIndexValue & "' not found in Database", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
Case 1
|
|
_Logger.Debug($"{pMyWMDoc.aName} # Der deskriptive Indexwert '{odescIndexValue}' verweist genau auf EINEN Eintrag in der Datenbank - Alles OK")
|
|
unvollstaendig = False
|
|
Case 2
|
|
'Mehr als ein Ergebnis für den Deskriptiven Index also Kennzeichnen des Dokumentes über den Index der das Dokument für die Validierung kennzeichnet
|
|
_Logger.Warn($"{pMyWMDoc.aName} # Der deskriptive Indexwert '{odescIndexValue}' of Index [{aktivesProfil.Desk_windreamIndex}] verweist auf MEHR ALS EINEN Eintrag in der Datenbank oder es trat ein genereller Fehler auf!")
|
|
fehlermsg &= " >> Der deskriptive Indexwert " & odescIndexValue & " verweist auf MEHR ALS EINEN Eintrag in der Datenbank oder es trat ein genereller Fehler auf!"
|
|
oUnexpectedError = True
|
|
unvollstaendig = True
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
SetErrorMeldung("More then 1 row found in Database", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
End Select
|
|
|
|
Catch ex As Exception
|
|
' wenn ein Fehler aufgetreten ist, muss das Flag gesetzt werden
|
|
_Logger.Error(ex)
|
|
|
|
oUnexpectedError = True
|
|
SetErrorMeldung("Error while Checking DeskriptiveIndex", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
End Try
|
|
End If
|
|
Case "xml" '#### Indexierung über xml-Dokument
|
|
_pathxmlfile = ordnerpfad & "\" & System.IO.Path.GetFileNameWithoutExtension(pMyWMDoc.aPath) & "."
|
|
If aktivesProfil.xmlEnd = "xml (ZugFerd)" Then
|
|
_pathxmlfile &= "xml"
|
|
Else
|
|
_pathxmlfile &= aktivesProfil.xmlEnd
|
|
End If
|
|
|
|
If clsHelper.file_exists(_pathxmlfile, "NI") = False Then
|
|
_pathxmlfile = ordnerpfad & "\" & System.IO.Path.GetFileNameWithoutExtension(pMyWMDoc.aPath) & "." & "xfres"
|
|
If clsHelper.file_exists(_pathxmlfile, "NI") = False Then
|
|
_Logger.Warn("ACHTUNG 1: Nachindexdatei '" & _pathxmlfile & "' existiert nicht!")
|
|
' Markierung des Dokumentes
|
|
SetErrorMeldung("Nachindexdatei NOT EXISTING", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
fehlermsg &= " >> ACHTUNG 1: Nachindexdatei '" & _pathxmlfile & "' existiert nicht!"
|
|
oUnexpectedError = True
|
|
End If
|
|
End If
|
|
Case "activedirectory"
|
|
|
|
End Select
|
|
myNIDatatable = Nothing
|
|
myNIArrayIndexe = Nothing ' zum Speichern der Indexe
|
|
myNIArrayValues = Nothing ' zum Speichern der Werte
|
|
Dim oDt As New DataTable
|
|
oDt.Columns.Add("IndexName")
|
|
oDt.Columns.Add("Value")
|
|
myNIDatatable = oDt
|
|
|
|
|
|
|
|
Dim verknüpfungZähler As Integer = 0
|
|
|
|
Dim selectArray()
|
|
|
|
|
|
If IsNothing(Me.aktivesProfil.Verknüpfungen.Links) = False And oUnexpectedError = False And unvollstaendig = False And Me.aktivesProfil.Ni_Art.ToLower <> "fulltext" Then
|
|
' alle Verknüpfungen/Links des aktuellen Suchergebnisses durchlaufen
|
|
Dim ocounter As Integer = 0
|
|
For Each INDEX_SQL_BEFEHL As ClassNIVerknüpfung In Me.aktivesProfil.Verknüpfungen.Links
|
|
ocounter += 1
|
|
_Logger.Debug($"### For each Verknüpfung [{ocounter}]...###")
|
|
'Regulären Ausdruck zum Auslesen der windream-Indexe definieren
|
|
Dim preg As String = "\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
' SQL-String für aktuelle Verknüpfung laden
|
|
Dim oSqlCommand As String = INDEX_SQL_BEFEHL.SelectAnweisung
|
|
If Len(oSqlCommand) > 0 Then
|
|
'Ersetzen des Dateinamens - für CURSOR NachindexierungPr
|
|
If oSqlCommand.Contains("[DATEINAME]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[DATEINAME]", pMyWMDoc.aName)
|
|
End If
|
|
If oSqlCommand.Contains("[FULLNAME]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[FULLNAME]", My.Settings.MRWD_Laufwerk & ":" & pMyWMDoc.aPath)
|
|
End If
|
|
|
|
If oSqlCommand.Contains("[DOCFilename]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[DOCFilename]", pMyWMDoc.aName)
|
|
End If
|
|
If oSqlCommand.Contains("[DOCFilenameoE]") Then
|
|
Dim Filename As String = aktivesDokument.aName.ToString.Substring(0, aktivesDokument.aName.LastIndexOf("."))
|
|
oSqlCommand = oSqlCommand.Replace("[DOCFilenameoE]", Path.GetFileNameWithoutExtension(Filename))
|
|
End If
|
|
|
|
If oSqlCommand.Contains("[DOCPath]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[DOCPath]", Path.GetDirectoryName(My.Settings.vWLaufwerk & ":" & pMyWMDoc.aPath))
|
|
End If
|
|
If oSqlCommand.Contains("[%DATENow]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[%DATENow]", Now.ToShortDateString)
|
|
End If
|
|
If oSqlCommand.Contains("[DOCFULLPATH]") Then
|
|
oSqlCommand = oSqlCommand.Replace("[DOCFULLPATH]", My.Settings.MRWD_Laufwerk & ":" & pMyWMDoc.aPath)
|
|
End If
|
|
_Logger.Debug($"oSqlCommand after Replace 1([{oSqlCommand}])")
|
|
' einen Regulären Ausdruck laden
|
|
Dim regulärerAusdruck As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(preg)
|
|
' die Vorkommen im SQL-String auslesen
|
|
Dim elemente As System.Text.RegularExpressions.MatchCollection = regulärerAusdruck.Matches(oSqlCommand)
|
|
|
|
' alle Vorkommen der windream-Indexe im SQL-String durchlaufen
|
|
For Each element As System.Text.RegularExpressions.Match In elemente
|
|
' wenn es sich nicht um die Spalten- oder Viewangabe handelt (es sollen ja nur die Indexe ausgelesen werden)
|
|
If Not element.Value.ToUpper = "[%SPALTE]" And Not element.Value.ToUpper = "[%VIEW]" Then
|
|
|
|
' die Zeichen [% und ] entfernen (liefert den wirklichen windream-Index)
|
|
Dim idxName_ohneSonderzeichen As String = element.Value.Substring(2, element.Value.Length - 3)
|
|
_Logger.Debug("### Working on Index(" & idxName_ohneSonderzeichen & ")...###")
|
|
Try
|
|
' den Wert des deskriptiven Indexes für das aktuelle Dokument auslesen
|
|
IndexwertAusWindream = pMyWMDoc.GetVariableValue(idxName_ohneSonderzeichen)
|
|
If element.ToString = aktivesProfil.Desk_windreamIndex Then
|
|
eindeutigerWertausWindream = IndexwertAusWindream
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
' wenn ein Fehler aufgetreten ist, muss das Flag gesetzt werden
|
|
result &= vbNewLine & " - Schwerwiegender Fehler bei Auslesen des einschränkenden Wertes aus Index':" & idxName_ohneSonderzeichen & "'"
|
|
oUnexpectedError = True
|
|
fehlermsg &= vbNewLine & "Schwerwiegender Fehler bei Auslesen des einschränkenden Wertes aus Index':" & idxName_ohneSonderzeichen & "' - Fehler: " & ex.Message
|
|
End Try
|
|
|
|
' wenn beim Auslesen des Wertes für den aktuellen windream-Index kein Fehler auftrat
|
|
' und die Abfrage ein Ergebnis zurück gab
|
|
If IndexwertAusWindream Is Nothing And Not oUnexpectedError Then
|
|
' IndexwertAusWindream ist Nothing (idxName_ohneSonderzeichen)
|
|
_Logger.Warn("ACHTUNG: der einschränkende Wert aus Windream für Index '" & idxName_ohneSonderzeichen & "' is NOTHING")
|
|
_Logger.Warn("SQL-String bisher: " & oSqlCommand)
|
|
' wenn die Abfrage in windream kein Ergebnis gab, muss das error_in_Indexierungflag gesetzt werden
|
|
oUnexpectedError = True
|
|
Else
|
|
' den Platzhalter im SQL-String durch den Wert ersetzen
|
|
oSqlCommand = oSqlCommand.Replace(element.Value, IndexwertAusWindream.ToString)
|
|
|
|
End If
|
|
|
|
Else ' wenn es sich um den Platzhalter für die Spalte bzw. den View handelt
|
|
' wenn es sich um den Platzhalter für die Spalte handelt
|
|
If element.Value.ToUpper = "[%SPALTE]" Then
|
|
' den Platzhalter für die auszulesende Spalte durch den Spaltennamen ersetzen
|
|
oSqlCommand = oSqlCommand.Replace(element.Value, INDEX_SQL_BEFEHL.Spalte)
|
|
|
|
ElseIf element.Value.ToUpper = "[%VIEW]" Then
|
|
' den Platzhalter für den auszulesenden View durch den Viewnamen ersetzen
|
|
oSqlCommand = oSqlCommand.Replace(element.Value, INDEX_SQL_BEFEHL.From)
|
|
End If
|
|
|
|
End If
|
|
|
|
Next ' zum nächsten Wert in der SQL-Anweisung gehen
|
|
result &= vbNewLine & " " & oSqlCommand
|
|
_Logger.Debug($"oSqlCommand after Replace 2([{oSqlCommand}])")
|
|
Else
|
|
_Logger.Debug("### oSqlCommand is empty!! ###")
|
|
End If
|
|
|
|
' wenn kein error_in_Indexierung aufgetreten ist
|
|
If oUnexpectedError = False Then
|
|
oResultNachindexierung = Nothing ' Der Nachindexierungswert: entweder aus Datenbankabrage oder aus xml-File
|
|
'Indexierung gegen ein Indexfeld
|
|
If INDEX_SQL_BEFEHL.Spalte.StartsWith("%") And INDEX_SQL_BEFEHL.Spalte.EndsWith("%") Then
|
|
'Ein manueller Wert in der Verknüpfung
|
|
_Logger.Debug("Indexierung mit einem manuellem Wert")
|
|
Dim _wert As String = INDEX_SQL_BEFEHL.Spalte.Replace("%", "")
|
|
oResultNachindexierung = _wert
|
|
_Logger.Debug("Manueller Wert: '" & oResultNachindexierung & "'")
|
|
Else
|
|
Dim Arr() As Object
|
|
''###########
|
|
Dim Anzahl_NI_Werte As Integer = 0
|
|
If IndexwertAusWindream Is Nothing = False Then
|
|
'Es wird gegen ein Vektorfeld nachindexiert
|
|
If IndexwertAusWindream.GetType.ToString.Contains("System.Object") Then
|
|
_Logger.Debug("...INDEXIERUNG GEGEN EIN VEKTORFELD")
|
|
'Zuweisen der Indexwerte des Vektorfeldes zu Array
|
|
Arr = IndexwertAusWindream
|
|
For Each str As Object In Arr
|
|
If str Is Nothing = False Then
|
|
Anzahl_NI_Werte += 1
|
|
End If
|
|
Next
|
|
ReDim Preserve selectArray(Anzahl_NI_Werte - 1)
|
|
_Logger.Debug("Anzahl Elemente: " & Anzahl_NI_Werte)
|
|
'MsgBox("Aha ein Vektorindex" & vbNewLine & "Anzahl Elemente: " & Anzahl_NI_Werte)
|
|
|
|
Dim selectstring = oSqlCommand
|
|
Dim i As Integer = 0
|
|
For Each obj As Object In Arr
|
|
'Im Select den Objektverweis mit Werta aus Vektorfeld ersetzen
|
|
oSqlCommand = selectstring
|
|
' MsgBox(obj.ToString)
|
|
oSqlCommand = oSqlCommand.Replace("System.Object[]", obj.ToString)
|
|
'Select-Befehl an Array übergeben
|
|
selectArray(i) = oSqlCommand
|
|
'_Logger.Info("SELECT-BEFEHL: " & selectArray(i))
|
|
i += 1
|
|
Next
|
|
Else
|
|
_Logger.Debug("...Indexierung gegen einen Einfachindex")
|
|
If Len(oSqlCommand) > 0 Then
|
|
ReDim Preserve selectArray(0)
|
|
'MsgBox("Nur ein Einfachindex :(" & vbNewLine & IndexwertAusWindream.ToString)
|
|
selectArray(0) = oSqlCommand
|
|
End If
|
|
|
|
End If
|
|
Else
|
|
ReDim Preserve selectArray(0)
|
|
'MsgBox("Nur ein Einfachindex :(" & vbNewLine & IndexwertAusWindream.ToString)
|
|
selectArray(0) = oSqlCommand
|
|
_Logger.Warn("IndexwertAusWindream Is Nothing: Select so far: '" & oSqlCommand & "'")
|
|
End If
|
|
|
|
|
|
'Nur wenn KEIN INDEXWERT also KEIN MANUELLER WERT
|
|
If oResultNachindexierung Is Nothing And selectArray.Length > 0 Then
|
|
'Indexwert über DB oder Datei
|
|
Select Case aktivesProfil.Ni_Art.ToLower
|
|
Case "db"
|
|
_Logger.Debug("SQL-Abfrage/n durchlaufen...")
|
|
Dim i As Integer
|
|
Dim Quelle_is_vektor = False
|
|
If selectArray.Length > 1 Then
|
|
Quelle_is_vektor = True
|
|
End If
|
|
|
|
For i = 0 To selectArray.Length - 1
|
|
'MessageBox.Show("Select: " & vbNewLine & selectArray(i))
|
|
' die SQL-Abfrage durchführen (liefert den Wert der in den windream-Index geschrieben werden soll)
|
|
If Me.aktivesProfil.DbArt = "Oracle" Then
|
|
oResultNachindexierung = database.GetValueFromOracleDb(aktivesProfil.Profilname, selectArray(i), Me.aktivesProfil.DataSource, aktivesProfil.InitialCatalog, aktivesProfil.UserId, aktivesProfil.Password, MyDataset, INDEX_SQL_BEFEHL.Index, Quelle_is_vektor)
|
|
ElseIf Me.aktivesProfil.DbArt = "MS-SQL" Then
|
|
_Logger.Debug($"Executing MSSQL ...")
|
|
oResultNachindexierung = database.GetValueFromMssqlDb(pMyWMDoc.aName, aktivesProfil.Profilname, selectArray(i), Me.aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password, MyDataset, aktivesProfil.InitialCatalog, INDEX_SQL_BEFEHL.Index, Quelle_is_vektor)
|
|
ElseIf Me.aktivesProfil.DbArt = "ODBC" Then
|
|
oResultNachindexierung = database.GetValueFromOdbcDb(aktivesProfil.Profilname, selectArray(i), Me.aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password, INDEX_SQL_BEFEHL.Index)
|
|
' MsgBox(oResultNachindexierung)
|
|
ElseIf Me.aktivesProfil.DbArt = "OLE (Access)" Then
|
|
oResultNachindexierung = database.GetValueFromOleDb(aktivesProfil.Profilname, selectArray(i), Me.aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password, INDEX_SQL_BEFEHL.Index)
|
|
ElseIf Me.aktivesProfil.DbArt = "Firebird" Then
|
|
oResultNachindexierung = database.GetValueFromFirebird(aktivesProfil.Profilname, selectArray(i), INDEX_SQL_BEFEHL.Index, MyDataset)
|
|
End If
|
|
Next
|
|
Case "xml"
|
|
'#### Indexierung über xml-Dokument
|
|
Dim dok As String = System.IO.Path.GetFileNameWithoutExtension(pMyWMDoc.aPath)
|
|
'Indexierung über luratech-Ergebnis Files
|
|
If aktivesProfil.xmlEnd = "xffres" Then
|
|
_Logger.Debug("Indexierung über XML-Dokument Abby/Luratech")
|
|
'Dateipfad für xffres/xml-Datei zusammenbauen
|
|
If File.Exists(_pathxmlfile) Then
|
|
'Übergabe der Dateiparameter und des xml-Knotens
|
|
oResultNachindexierung = Trim(xml.GetValueFromLuratechxml(System.IO.Path.GetFileNameWithoutExtension(pMyWMDoc.aPath) & "." & aktivesProfil.xmlEnd, _pathxmlfile, INDEX_SQL_BEFEHL.Spalte, aktivesProfil.Profilname))
|
|
'wert aus Luratech darf nicht leer sein
|
|
If oResultNachindexierung Is Nothing Then
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
SetErrorMeldung("Wert aus Formrec. ist nothing", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
End If
|
|
Else
|
|
_Logger.Warn("ACHTUNG 2: Nachindexdatei: " & _pathxmlfile & " existiert nicht!")
|
|
oUnexpectedError = True
|
|
fehlermsg &= vbNewLine & " >> ACHTUNG 2: Datei: " & _pathxmlfile & " existiert nicht!"
|
|
End If
|
|
ElseIf aktivesProfil.xmlEnd = "xml (ZugFerd)" Then
|
|
_Logger.Debug("Indexierung über XML-Dokument ZugFerd")
|
|
'Dateipfad für xffres/xml-Datei zusammenbauen
|
|
If File.Exists(_pathxmlfile) Then
|
|
'Übergabe der Dateiparameter und des xml-Knotens
|
|
oResultNachindexierung = Trim(xml.GetValueFromZugFerdxml(System.IO.Path.GetFileNameWithoutExtension(_pathxmlfile), _pathxmlfile, INDEX_SQL_BEFEHL.Spalte, aktivesProfil.Profilname))
|
|
'wert aus Luratech darf nicht leer sein
|
|
If oResultNachindexierung Is Nothing Then
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
SetErrorMeldung("Wert aus Formrec. ist nothing", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
End If
|
|
Else
|
|
_Logger.Warn("ACHTUNG 2: Nachindexdatei: " & _pathxmlfile & " existiert nicht!")
|
|
oUnexpectedError = True
|
|
fehlermsg &= vbNewLine & " >> ACHTUNG 2: Datei: " & _pathxmlfile & " existiert nicht!"
|
|
End If
|
|
End If
|
|
'wenn kein error_in_Indexierung und wert geliefert und Index ist deskriptiver Index
|
|
If Not oUnexpectedError And aktivesProfil.Desk_windreamIndex = INDEX_SQL_BEFEHL.Index And aktivesProfil.checkIndexsql <> "" Then
|
|
If (oResultNachindexierung = "") Or (oResultNachindexierung Is Nothing) Then
|
|
_Logger.Warn("ACHTUNG: der XML-Wert (Formrecognition) ist leer! Dies kann zu Fehlern führen!")
|
|
'Markierung Validation
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'errormeldung setzen
|
|
SetErrorMeldung("Wert aus Formrec. ist leer", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
|
|
fehlermsg &= vbNewLine & " >> der Wert in der Indexdatei ist leer"
|
|
oResultNachindexierung = Nothing
|
|
unvollstaendig = True
|
|
oUnexpectedError = True
|
|
Else
|
|
Dim _dokxml As WINDREAMLib.WMObject
|
|
_dokxml = Nothing
|
|
'Dim _path2xmlfile As String = ordnerpfad & "\" & System.IO.Path.GetFileNameWithoutExtension(dokument.aPath) & "." & aktivesProfil.xmlEnd
|
|
_dokxml = _windreamNI.oWMSession.GetWMObjectByPath(ConstWMEntityDocument, _pathxmlfile.Substring(2))
|
|
'Überprüfen ob deskriptiver Wert eindeutig?
|
|
_Logger.Debug("Überprüfung ob deskriptiver Wert eindeutig?")
|
|
Dim Check As Integer = Check_DeskIndexValue(oResultNachindexierung, aktivesProfil.checkIndexsql, pMyWMDoc)
|
|
Select Case Check
|
|
Case 0
|
|
'Kein Ergebnis für den Deskriptiven Index also Kennzeichnen des Dokumentes über den Index der das Dokument für die Validierung kennzeichnet
|
|
_Logger.Warn("Der deskriptive Indexwert '" & oResultNachindexierung & "' verweist auf keinen Eintrag in der Datenbank!")
|
|
SetErrorMeldung("Value '" & oResultNachindexierung & "' not found in Database", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
unvollstaendig = True
|
|
oUnexpectedError = True
|
|
|
|
|
|
'Überprüfung ob Wert dennoch indexiert werden soll?!
|
|
If INDEX_SQL_BEFEHL.SelectAnweisung = "WRITE_ALWAYS" Then
|
|
_Logger.Debug("Dennoch soll der Wert eingetragen werden")
|
|
Dim arrIndex() As String = Nothing
|
|
Dim arrValue() As String = Nothing
|
|
ReDim Preserve arrIndex(0)
|
|
ReDim Preserve arrValue(0)
|
|
arrIndex(0) = INDEX_SQL_BEFEHL.Index
|
|
arrValue(0) = oResultNachindexierung.ToString
|
|
Me._windreamNI.RunIndexing(pMyWMDoc, arrIndex, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
_Logger.Debug("Der falsche OCR-Wert: '" & oResultNachindexierung.ToString & "' wurde eingetragen")
|
|
Else
|
|
fehlermsg &= vbNewLine & " - Der deskriptive Indexwert " & oResultNachindexierung & " verweist auf keinen Eintrag in der Datenbank!"
|
|
End If
|
|
'1. aktives Dok
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'2. Indexierungs-Datei
|
|
File_SetBooleanIndex(True, _dokxml, aktivesProfil.IndexValidation)
|
|
'Fehlermarkierung setzen
|
|
|
|
Case 1
|
|
_Logger.Debug("Der deskriptive Indexwert " & oResultNachindexierung & " verweist genau auf EINEN Eintrag in der Datenbank - Alles OK")
|
|
oUnexpectedError = False
|
|
Case 2
|
|
'Mehr als ein Ergebnis für den Deskriptiven Index also Kennzeichnen des Dokumentes über den Index der das Dokument für die Validierung kennzeichnet
|
|
_Logger.Warn("Der deskriptive Indexwert " & oResultNachindexierung & " verweist auf MEHR ALS EINEN Eintrag in der Datenbank!")
|
|
SetErrorMeldung("More then 1 row found in Database", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
fehlermsg &= vbNewLine & " - Der deskriptive Indexwert " & oResultNachindexierung & " verweist auf MEHR ALS EINEN Eintrag in der Datenbank!"
|
|
oUnexpectedError = True
|
|
'1. aktives Dok
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'2. Indexierungs-Datei
|
|
File_SetBooleanIndex(True, _dokxml, aktivesProfil.IndexValidation)
|
|
End Select
|
|
End If
|
|
Else
|
|
If aktivesProfil.Desk_windreamIndex = "" Then
|
|
_Logger.Warn("# ACHTUNG: der deskriptive Indexwert ist nicht hinterlegt! Dies kann zu Fehlern führen! #")
|
|
Else
|
|
If aktivesProfil.checkIndexsql = "" Then
|
|
_Logger.Warn("# ACHTUNG: Eine sql-Überprüfung des aus xml-gelesenen Indexwertes ist nicht hinterlegt! Dies kann zu falsch-positiven Werten führen! #")
|
|
Else
|
|
If oResultNachindexierung = "" Then
|
|
_Logger.Warn("# ACHTUNG: der gelesene Wert ist leer! Dies kann zu Fehlern führen! #")
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
Case "activedirectory"
|
|
_Logger.Debug("Indexierung gegen ActiveDirectory")
|
|
|
|
oResultNachindexierung = ClassActiveDirectory.GetAD_Attribut(selectArray(0), INDEX_SQL_BEFEHL.Spalte, aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password)
|
|
If oResultNachindexierung = ">1" Then
|
|
_Logger.Warn("Es wurde mehr als 1 Wert ausgelesen! Entweder ist der Filter AD nicht eindeutig oder ein anderer error_in_Indexierung ist aufgetreten")
|
|
Else
|
|
_Logger.Debug("Gelesener Attribut-Wert: " & oResultNachindexierung)
|
|
End If
|
|
|
|
|
|
|
|
End Select
|
|
|
|
End If
|
|
|
|
End If
|
|
'#####
|
|
'bis hier in _clsWorkfile integriert
|
|
'######
|
|
'nur wenn kein Fehler
|
|
If Not oUnexpectedError Then
|
|
If oResultNachindexierung Is Nothing Then
|
|
_Logger.Debug("oResultNachindexierung is nothing...Continue next")
|
|
Continue For
|
|
End If
|
|
Try
|
|
If Not IsNothing(oResultNachindexierung) Then
|
|
_Logger.Debug("oResultNachindexierung is not nothing...")
|
|
_Logger.Debug($"oResultNachindexierung = [{oResultNachindexierung.ToString}]...")
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn("Unexpected error in checking isnothing for oResultNachindexierung: " & ex.Message)
|
|
_Logger.Warn("oResultNachindexierung Is Nothing..Continue For...")
|
|
Continue For
|
|
End Try
|
|
|
|
' wenn sowohl ein Index, als auch ein Wert gefunden/angegeben wurde,
|
|
' der in den windream-Index geschrieben werden kann
|
|
If INDEX_SQL_BEFEHL.Index IsNot Nothing Then
|
|
result &= " - " & oResultNachindexierung.ToString
|
|
_ergebnisSQL = True
|
|
Try
|
|
_Logger.Debug("Arraygößen werden angepasst:")
|
|
' die Arraygrößen anpassen
|
|
ReDim Preserve myNIArrayIndexe(verknüpfungZähler)
|
|
ReDim Preserve myNIArrayValues(verknüpfungZähler)
|
|
' den angegebenen Index eintragen
|
|
myNIArrayIndexe(verknüpfungZähler) = INDEX_SQL_BEFEHL.Index
|
|
|
|
' den, übergebenen/gefundenen IndexWert, eintragen
|
|
myNIArrayValues(verknüpfungZähler) = Convert.ToString(oResultNachindexierung)
|
|
|
|
Dim oRow As DataRow = myNIDatatable.NewRow
|
|
oRow(0) = INDEX_SQL_BEFEHL.Index
|
|
oRow(1) = Convert.ToString(oResultNachindexierung)
|
|
myNIDatatable.Rows.Add(oRow)
|
|
|
|
_Logger.Debug("INDEXWERT: '" & Convert.ToString(oResultNachindexierung) & "'")
|
|
verknüpfungZähler += 1
|
|
Catch ex As Exception
|
|
result &= " (" & verknüpfungZähler & ") => " & ex.Message & vbNewLine
|
|
End Try
|
|
Else
|
|
If oResultNachindexierung Is Nothing And aktivesProfil.Ni_Art.ToLower = "db" Then
|
|
'_Logger.Debug("SQL-Abfrage ergab kein Ergebnis - früher Ausstieg aus Routine ")
|
|
'Exit For
|
|
End If
|
|
If IndexwertAusWindream.GetType.ToString.Contains("System.Object") Then
|
|
' die Arraygrößen anpassen
|
|
ReDim Preserve myNIArrayIndexe(verknüpfungZähler)
|
|
ReDim Preserve myNIArrayValues(verknüpfungZähler)
|
|
' den angegebenen Index eintragen
|
|
myNIArrayIndexe(verknüpfungZähler) = INDEX_SQL_BEFEHL.Index
|
|
|
|
' den, übergebenen/gefundenen IndexWert, eintragen
|
|
myNIArrayValues(verknüpfungZähler) = Convert.ToString("")
|
|
_Logger.Debug("Nachindexwert ist Object")
|
|
verknüpfungZähler += 1
|
|
|
|
Dim oRow As DataRow = myNIDatatable.NewRow
|
|
oRow(0) = INDEX_SQL_BEFEHL.Index
|
|
oRow(1) = Convert.ToString("")
|
|
myNIDatatable.Rows.Add(oRow)
|
|
Else
|
|
'_Logger.Warn("SQL-Abfrage ergab kein Ergebnis")
|
|
If aktivesProfil.Ni_Art.ToLower = "xml" Then
|
|
If clsHelper.file_exists(_pathxmlfile, "NI") Then
|
|
|
|
If INDEX_SQL_BEFEHL.Index = aktivesProfil.Desk_windreamIndex Then
|
|
_Logger.Info("# Achtung: Der Deskriptive Index: " & aktivesProfil.Desk_windreamIndex & " sollte gesetzt werden! Wert konnte aber nicht gelesen werden bzw ist leer - Markierung des Doks")
|
|
'Kein Ergebnis für den Deskriptiven Index also Kennzeichnen des Dokumentes über den Index der das Dokument für die Validierung kennzeichnet
|
|
Dim _dokxml As WINDREAMLib.WMObject
|
|
_dokxml = Nothing
|
|
|
|
_dokxml = _windreamNI.oWMSession.GetWMObjectByPath(ConstWMEntityDocument, _pathxmlfile.Substring(2))
|
|
'1. aktives Dok
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'2. Indexierungs-Datei
|
|
File_SetBooleanIndex(True, _dokxml, aktivesProfil.IndexValidation)
|
|
'Fehlermarkierung setzen
|
|
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
Else
|
|
_Logger.Info("Unexpected error while indexing...(error_in_Indexierung is true)")
|
|
End If
|
|
|
|
|
|
End If
|
|
Next ' zur nächsten Verknüpfung gehen
|
|
End If
|
|
|
|
' wenn kein error_in_Indexierung aufgetreten ist
|
|
If oUnexpectedError = False Then
|
|
If unvollstaendig = False And Me.aktivesProfil.Ni_Art.ToLower <> "fulltext" Or Me.aktivesProfil.Ni_Art.ToLower <> "nurordnerrechte" Or Me.aktivesProfil.Ni_Art.ToLower <> "nur-ordner-indizes" Then
|
|
'###############################################################################################
|
|
'#### Nachindexierung ##########################################################################
|
|
Dim sw As New ClassStopwatch("RunIndexing_Case1")
|
|
oUnexpectedError = Me._windreamNI.RunIndexing(pMyWMDoc, myNIArrayIndexe, myNIArrayValues, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
Dim msg = sw.Done
|
|
If msg <> "" Then
|
|
Stopwatch1 = $"{msg}"
|
|
End If
|
|
'#### Nachindexierung Ende #####################################################################
|
|
'###############################################################################################
|
|
If oUnexpectedError = True Then
|
|
_Logger.Debug("error_in_Indexierung is True - none of following steps will be run!")
|
|
End If
|
|
'Wenn ein SQL-Ergebnis im Durchlauf einen Wert lieferte wird der finale Index auf True gesetzt
|
|
If myNIArrayValues Is Nothing = False And Not oUnexpectedError Then
|
|
If Me.aktivesProfil.finalerIndex <> "" And Not oUnexpectedError And myNIArrayValues.Length >= 1 And myNIArrayValues(0) <> "" Then
|
|
Me._windreamNI.SetfinalIndex(pMyWMDoc, Me.aktivesProfil.finalerIndex, True)
|
|
End If
|
|
'###### Spezifisches SQL nach jeder Datei!
|
|
If Me.aktivesProfil.SQL_Anweisung IsNot Nothing And Not oUnexpectedError And myNIArrayValues.Length >= 1 And myNIArrayValues(0) <> "" Then
|
|
_Logger.Debug("Me.aktivesProfil.SQL_Anweisung: " & Me.aktivesProfil.SQL_Anweisung)
|
|
If Me.aktivesProfil.SQL_Anweisung.StartsWith("EXECUTEVB") Then
|
|
_Logger.Debug("Execute VB-Script after indexing......")
|
|
Dim oVBScriptRAW As String = Me.aktivesProfil.SQL_Anweisung.Replace("EXECUTEVB ", "")
|
|
oVBScriptRAW = oVBScriptRAW.Replace("EXECUTEVB", "")
|
|
oVBScriptRAW = oVBScriptRAW.Replace("EXECUTEVB ", "")
|
|
|
|
_Logger.Debug("oVBScriptRAW [" & oVBScriptRAW & "]")
|
|
' Regulären Ausdruck zum Auslesen der windream-Indexe definieren
|
|
Dim preg As String = "\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
|
|
' SQL-String für aktuelles Profil laden
|
|
Dim oVBScriptCommand As String = oVBScriptRAW
|
|
' einen Regulären Ausdruck laden
|
|
Dim regulärerAusdruck As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(preg)
|
|
' die Vorkommen im SQL-String auslesen
|
|
Dim elemente As System.Text.RegularExpressions.MatchCollection = regulärerAusdruck.Matches(oVBScriptCommand)
|
|
' alle Vorkommen der windream-Indexe im SQL-String durchlaufen
|
|
For Each element As System.Text.RegularExpressions.Match In elemente
|
|
|
|
' die Zeichen [% und ] entfernen (liefert den wirklichen windream-Index)
|
|
Dim elementOhneSonderzeichen As String = element.Value.Replace("[%", "")
|
|
elementOhneSonderzeichen = elementOhneSonderzeichen.Replace("]", "")
|
|
If elementOhneSonderzeichen.StartsWith("ddv") Then
|
|
Dim ddvariable As String = ""
|
|
elementOhneSonderzeichen = elementOhneSonderzeichen.Replace("ddv", "")
|
|
Dim filepath = My.Settings.vWLaufwerk & ":" & pMyWMDoc.aPath
|
|
Select Case elementOhneSonderzeichen
|
|
Case "FULLFILENAME"
|
|
ddvariable = filepath
|
|
Case "FOLDERNAME"
|
|
ddvariable = Path.GetDirectoryName(filepath)
|
|
End Select
|
|
|
|
oVBScriptCommand = oVBScriptCommand.Replace(element.Value, ddvariable)
|
|
Else
|
|
Try
|
|
' den Wert des deskriptiven Indexes für das aktuelle Dokument auslesen
|
|
IndexwertAusWindream = pMyWMDoc.GetVariableValue(elementOhneSonderzeichen)
|
|
Catch ex As Exception
|
|
' wenn ein Fehler aufgetreten ist, muss das Flag gesetzt werden
|
|
oUnexpectedError = True
|
|
|
|
_Logger.Warn("Fehler in Get Indexwert aus windream bei Spezifischem SQL: " & ex.Message.ToString)
|
|
End Try
|
|
oVBScriptCommand = oVBScriptCommand.Replace(element.Value, IndexwertAusWindream.ToString)
|
|
End If
|
|
|
|
Next
|
|
|
|
_Logger.Debug("VBSCRIPTCOMMAND after replacing variables [" & oVBScriptCommand & "]")
|
|
|
|
Try
|
|
|
|
Dim oArrParams As String()
|
|
oArrParams = oVBScriptCommand.Split("#")
|
|
_Logger.Debug("VBSCRIPTCOMMAND - Path [" & oArrParams(0).ToString & "]")
|
|
Dim oVBScriptFile = oArrParams(0).ToString
|
|
_Logger.Debug("oVBScriptFile - Path [" & oVBScriptFile & "]")
|
|
If File.Exists(oVBScriptFile) Then
|
|
Dim start As New ProcessStartInfo
|
|
Dim task As New Process
|
|
|
|
Dim oParamArg As String = ""
|
|
|
|
Dim i As Integer = 0
|
|
Dim oStepArg As String
|
|
For Each oParam As String In oArrParams
|
|
If i <> 0 Then
|
|
If i = 1 Then
|
|
oStepArg = $"{oParam.Replace("'", """")}"
|
|
Else
|
|
oStepArg = $" {oParam.Replace("'", """")}"
|
|
End If
|
|
oParamArg += oStepArg
|
|
End If
|
|
|
|
i += 1
|
|
Next
|
|
|
|
|
|
Dim args As String = String.Format("""{0}"" ""{1}""", oArrParams(0).ToString, oParamArg)
|
|
start.FileName = "C:\WINDOWS\system32\cscript.exe"
|
|
start.Arguments = args
|
|
_Logger.Debug("Argument(s) For myProcess [" & args & "]")
|
|
start.UseShellExecute = False
|
|
' start.RedirectStandardOutput = True
|
|
' start.RedirectStandardError = False
|
|
task.StartInfo = start
|
|
task.StartInfo.CreateNoWindow = True
|
|
Dim _sw As Stopwatch = New Stopwatch()
|
|
_sw.Start()
|
|
task.Start()
|
|
' so = task.StandardOutput
|
|
Do While task.HasExited = False
|
|
If _sw.Elapsed.TotalSeconds = 30 Then
|
|
_Logger.Debug("Still waiting (30 sec) for ending of Task")
|
|
ElseIf _sw.Elapsed.TotalMinutes = 1 Then
|
|
_Logger.Debug("Still waiting (60 sec) for ending of Task - Exit now", True)
|
|
Exit Do
|
|
End If
|
|
Loop
|
|
_Logger.Debug("...process has exited: ")
|
|
_sw.Stop()
|
|
|
|
'Dim myProcess As New Process
|
|
'Dim oProcessID
|
|
'myProcess.StartInfo.FileName = oVBScriptFile
|
|
|
|
'Dim startInfo As New ProcessStartInfo(oVBScriptFile)
|
|
'startInfo.CreateNoWindow = True
|
|
'myProcess.StartInfo.Arguments = oParamArg
|
|
'_Logger.Debug("Argument For myProcess [" & myProcess.StartInfo.Arguments & "]")
|
|
'myProcess.Start()
|
|
'oProcessID = myProcess.Id
|
|
'_Logger.Debug("Script executed!")
|
|
'If IsNumeric(oProcessID) Then
|
|
' _Logger.Debug("got an PROCID: " & oProcessID.ToString)
|
|
|
|
|
|
' Dim oMyProcess1 As Process
|
|
' oMyProcess1 = Process.GetProcessById(oProcessID)
|
|
|
|
' Dim _sw1 As Stopwatch = New Stopwatch()
|
|
' _sw1.Start()
|
|
|
|
' Do While oMyProcess1.HasExited = False
|
|
|
|
' If _sw1.Elapsed.TotalSeconds = 30 Then
|
|
' _Logger.Debug("Still waiting (30 sec) for ending of process-id: " & oProcessID.ToString)
|
|
' ElseIf _sw1.Elapsed.TotalMinutes = 1 Then
|
|
' _Logger.Debug("Still waiting (60 sec) for ending of process-id: " & oProcessID.ToString & " - Exit now", True)
|
|
' Exit Do
|
|
' End If
|
|
' Loop
|
|
' _Logger.Debug("...process has exited: ")
|
|
' _sw1.Stop()
|
|
'End If
|
|
|
|
|
|
|
|
Else
|
|
_Logger.Warn($"VBSCRIPT not File.exists: {oVBScriptFile}")
|
|
End If
|
|
|
|
|
|
|
|
'task.WaitForExit()
|
|
' MsgBox(so.ReadToEnd)
|
|
'myProcess.StartInfo.Arguments = oParamArg
|
|
'_Logger.Debug("Argument For myProcess [" & myProcess.StartInfo.Arguments & "]")
|
|
'myProcess.Start()
|
|
|
|
''Process.Start(startInfo)
|
|
|
|
'oProcessID = myProcess.Id
|
|
'_Logger.Debug("Script executed!")
|
|
|
|
'If IsNumeric(oProcessID) Then
|
|
' _Logger.Debug("got an PROCID: " & oProcessID.ToString)
|
|
|
|
|
|
' Dim oMyProcess As Process
|
|
' oMyProcess = Process.GetProcessById(oProcessID)
|
|
|
|
' Dim _sw As Stopwatch = New Stopwatch()
|
|
' _sw.Start()
|
|
|
|
' Do While oMyProcess.HasExited = False
|
|
|
|
' If _sw.Elapsed.TotalSeconds = 30 Then
|
|
' _Logger.Debug("Still waiting (30 sec) for ending of process-id: " & oProcessID.ToString)
|
|
' ElseIf _sw.Elapsed.TotalMinutes = 1 Then
|
|
' _Logger.Debug("Still waiting (60 sec) for ending of process-id: " & oProcessID.ToString & " - Exit now", True)
|
|
' Exit Do
|
|
' End If
|
|
' Loop
|
|
' _Logger.Debug("...process has exited: ")
|
|
' _sw.Stop()
|
|
'End If
|
|
|
|
Catch ex As Exception
|
|
_Logger.Warn("Unexpected error in running script: " & ex.Message)
|
|
End Try
|
|
|
|
Else
|
|
If Me.aktivesProfil.SQL_Anweisung <> "" Then
|
|
_Logger.Debug("Spezifisches SQL nach erfolgreichem Indexieren der Datei wird durchgeführt")
|
|
_Logger.Debug("SQL: " & Me.aktivesProfil.SQL_Anweisung)
|
|
' Regulären Ausdruck zum Auslesen der windream-Indexe definieren
|
|
Dim preg As String = "\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
|
|
' SQL-String für aktuelles Profil laden
|
|
Dim Sqlcommand As String = aktivesProfil.SQL_Anweisung
|
|
' einen Regulären Ausdruck laden
|
|
Dim regulärerAusdruck As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(preg)
|
|
' die Vorkommen im SQL-String auslesen
|
|
Dim elemente As System.Text.RegularExpressions.MatchCollection = regulärerAusdruck.Matches(Sqlcommand)
|
|
' alle Vorkommen der windream-Indexe im SQL-String durchlaufen
|
|
For Each element As System.Text.RegularExpressions.Match In elemente
|
|
|
|
' die Zeichen [% und ] entfernen (liefert den wirklichen windream-Index)
|
|
Dim elementOhneSonderzeichen As String = element.Value.Replace("[%", "")
|
|
elementOhneSonderzeichen = elementOhneSonderzeichen.Replace("]", "")
|
|
Try
|
|
' den Wert des deskriptiven Indexes für das aktuelle Dokument auslesen
|
|
IndexwertAusWindream = pMyWMDoc.GetVariableValue(elementOhneSonderzeichen)
|
|
Catch ex As Exception
|
|
' wenn ein Fehler aufgetreten ist, muss das Flag gesetzt werden
|
|
oUnexpectedError = True
|
|
_Logger.Warn("Indexname/elementOhneSonderzeichen aus Regex: " & elementOhneSonderzeichen)
|
|
_Logger.Warn("Indexwert aus Windream: " & IndexwertAusWindream.ToString)
|
|
_Logger.Warn("Fehler in Get Indexwert aus windream bei Spezifischem SQL: ")
|
|
_Logger.Warn(ex.Message)
|
|
End Try
|
|
Sqlcommand = Sqlcommand.Replace(element.Value, IndexwertAusWindream.ToString)
|
|
'Wenn Speicherort gespeichert werden soll wird Platzhalter ersetzt!
|
|
Sqlcommand = Sqlcommand.Replace("vSpeicherort", "'" & My.Settings.vWLaufwerk & ":" & Me.aktivesDokument.aPath & "'")
|
|
_Logger.Debug("SQL-Command: " & Sqlcommand)
|
|
|
|
Next
|
|
If Me.aktivesProfil.DbArt = "Oracle" Then
|
|
If database.ExecuteonOracleDb(aktivesProfil.Profilname, Sqlcommand, aktivesProfil.DataSource, aktivesProfil.InitialCatalog, aktivesProfil.UserId, aktivesProfil.Password) = 1 Then
|
|
_Logger.Debug("ORACLE SQL-Command erfolgreich ausgeführt!")
|
|
End If
|
|
ElseIf Me.aktivesProfil.DbArt = "MS-SQL" Then
|
|
_Logger.Debug("MSSQL-Command will be executed now.....")
|
|
_Logger.Debug("Sqlcommand: " & Sqlcommand)
|
|
If database.ExecuteonMSSQL(aktivesProfil.Profilname, Sqlcommand, aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password, aktivesProfil.InitialCatalog) = 1 Then
|
|
_Logger.Debug("MSSQL-Command erfolgreich ausgeführt!")
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
Else
|
|
If IsNothing(myNIArrayValues) Then
|
|
_Logger.Debug("NI_Values is nothing!")
|
|
Else
|
|
_Logger.Debug("NI_Values.Length: " & myNIArrayValues.Length)
|
|
_Logger.Debug("NI_Values(0): " & myNIArrayValues(0))
|
|
End If
|
|
|
|
End If
|
|
Else
|
|
If IsNothing(myNIArrayValues) Then
|
|
_Logger.Debug("oNiArrayValues is nothing!")
|
|
Else
|
|
|
|
End If
|
|
|
|
End If
|
|
If aktivesProfil.Ni_Art.ToLower = "xml" Then
|
|
If oUnexpectedError = False Then
|
|
Dim valid As Boolean
|
|
Try
|
|
'Überprüfen ob Validierung auf False steht?
|
|
valid = pMyWMDoc.GetVariableValue(aktivesProfil.IndexValidation) '_windreamNI.GetValueforIndex(dokument.aPath & dokument.aName, aktivesProfil.vSQL_Anweisung)
|
|
Catch ex As Exception
|
|
_Logger.Warn("Schwerwiegender Fehler bei Auslesen des Validierungswertes:" & ex.Message)
|
|
End Try
|
|
If valid = True Then
|
|
'nur Zurücksetzten wenn Wert zuweisbar
|
|
If (myNIArrayValues.Length = 1 And myNIArrayValues(0) = "") = False Then
|
|
_Logger.Debug("Dokument sollte validiert werden - Nun erfolgreich indexiert - also Index '" & aktivesProfil.IndexValidation & "' zurücksetzen!")
|
|
'Den Flag Validation wieder auf False setzen
|
|
File_SetBooleanIndex(False, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'Ebenso die Fehlermeldung
|
|
SetErrorMeldung("", aktivesDokument, My.Settings.ERROR_INDEX)
|
|
End If
|
|
End If
|
|
|
|
'###### Nachindexierung über XML - Löschen des Dokumentes ######
|
|
If unvollstaendig = False Then
|
|
'##### Löschen der xml-Indexdatei
|
|
If myNIArrayValues.Length = 1 And myNIArrayValues(0) = "" Then
|
|
_Logger.Debug("XML-Wert ist Leer und somit nicht auswertbar - Dok für Validierung markieren")
|
|
'Den Flag Validation auf True setzen
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
'Fehlermarkierung setzen
|
|
|
|
_Logger.Debug("Indexierung der xffres-Datei '" & System.IO.Path.GetFileNameWithoutExtension(pMyWMDoc.aName) & "." & aktivesProfil.xmlEnd & "' - für die Validierung kennzeichnen")
|
|
'Nun die xffres Datei indexieren
|
|
Dim _dokxml As WINDREAMLib.WMObject
|
|
_dokxml = Nothing
|
|
_dokxml = _windreamNI.oWMSession.GetWMObjectByPath(ConstWMEntityDocument, _pathxmlfile.Substring(2))
|
|
'2. Indexierungs-Datei
|
|
File_SetBooleanIndex(True, _dokxml, aktivesProfil.IndexValidation)
|
|
'Fehlermarkierung setzen
|
|
|
|
Else
|
|
'Löschen der xml-Indexdatei
|
|
If CBool(Me.aktivesProfil.delete) = True Then
|
|
_Logger.Debug("Indexdatei soll gelöscht werden")
|
|
'Datei über die nachindexiert wurde soll gelöscht werden
|
|
System.IO.File.Delete(_pathxmlfile)
|
|
_Logger.Debug("XML-Index-Datei: " & _pathxmlfile)
|
|
_Logger.Debug("XML Index Datei ERFOLGREICH gelöscht!")
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
Else
|
|
'MsgBox("Fehler" & vbNewLine & _MRKONVERT_FEHLER & vbNewLine & aktivesProfil.vSQL_Anweisung)
|
|
Select Case _MRKONVERT_FEHLER
|
|
Case 1
|
|
Dim valid As Boolean = pMyWMDoc.GetVariableValue(aktivesProfil.IndexValidation) '_windreamNI.GetValueforIndex(dokument.aPath & dokument.aName, aktivesProfil.vSQL_Anweisung)
|
|
If valid = True Then
|
|
_Logger.Info("Konvertierungsfehler bei Nachindexierung xml - Index '" & aktivesProfil.IndexValidation & "' für Validierung bereits auf True gesetzt")
|
|
Else
|
|
_Logger.Info("Konvertierungsfehler bei Nachindexierung xml - Setze Index '" & aktivesProfil.IndexValidation & "' für Validierung!")
|
|
'Konvertierungsfehler
|
|
File_SetBooleanIndex(True, aktivesDokument, aktivesProfil.IndexValidation)
|
|
End If
|
|
'Fehlermarkierung setzen
|
|
|
|
|
|
If aktivesProfil.xmlEnd = "xffres" Then
|
|
'Den Flag Validation für das aktuelle Dok auf True setzen
|
|
Dim _dokxml As WINDREAMLib.WMObject
|
|
_dokxml = Nothing
|
|
_dokxml = _windreamNI.oWMSession.GetWMObjectByPath(ConstWMEntityDocument, _pathxmlfile.Substring(2)) 'WINDREAMLib.WMEntity.WMEntityDocument
|
|
'2. Indexierungs-Datei
|
|
File_SetBooleanIndex(True, _dokxml, aktivesProfil.IndexValidation)
|
|
'Fehlermarkierung setzen
|
|
|
|
End If
|
|
End Select
|
|
End If
|
|
End If
|
|
End If
|
|
Else
|
|
If unvollstaendig = False And Me.aktivesProfil.Ni_Art.ToLower <> "fulltext" Then
|
|
_Logger.Warn("Fehler bei IndexiereVerarbeiteDokument für die Datei: " & pMyWMDoc.aName.ToString)
|
|
_Logger.Warn("Fehlermeldung: " & fehlermsg)
|
|
|
|
End If
|
|
End If
|
|
'#### Ende Nachindexierung
|
|
'#################################################################################################################################################
|
|
Dim swMessage As String
|
|
swMessage = swRegIndex.Done
|
|
If swMessage <> "" Then
|
|
Stopwatch1 += vbNewLine & $"{swMessage}"
|
|
End If
|
|
|
|
'Move and Rename ausführen
|
|
If LICENSE_MoveRename = True And Not oUnexpectedError And unvollstaendig = False Then
|
|
Dim swMoveandrename As New ClassStopwatch("MoveandRename")
|
|
oUnexpectedError = FNMoveRename(pMyWMDoc)
|
|
|
|
Dim msg1 = swMoveandrename.Done
|
|
If msg1 <> "" Then
|
|
Stopwatch1 += vbNewLine & $"{msg1}"
|
|
|
|
End If
|
|
Else
|
|
If LICENSE_MoveRename = True And oUnexpectedError = True Or unvollstaendig = True Then
|
|
_Logger.Info("MoveRename Yes but error_in_Indexierung = True Or unvollstaendig = True")
|
|
_Logger.Debug("MoveRename Yes but error_in_Indexierung = True Or unvollstaendig = True")
|
|
End If
|
|
|
|
|
|
End If
|
|
|
|
'Indexierung gegen die Indizes des Ordners
|
|
If oUnexpectedError = False And (aktivesProfil.Ni_Art.ToLower = "nurordnerrechte" Or aktivesProfil.Ni_Art.ToLower = "nur-ordner-indizes" Or (aktivesProfil.GetOrdnerTypes = True And aktivesProfil.OriginalOrdnerType <> "")) Then
|
|
_Logger.Debug("Nachbearbeitung Indexe nach Ordner-Typen ist aktiviert")
|
|
'Die Ordernindizes-Namen laden
|
|
Dim Oindexe = _windream.GetIndicesByFoldertype(Me.aktivesProfil.OrdnerType, False)
|
|
'Die Objekttypindizes laden
|
|
Dim Dindexe = _windream.GetIndicesByObjecttype(Me.aktivesProfil.DokumenttypString, False, "NI")
|
|
If IsArray(Oindexe) And IsArray(Dindexe) Then
|
|
OrdnerIndizes_zuweisen(pMyWMDoc)
|
|
Else
|
|
_Logger.Debug("IsArray(Oindexe) = False")
|
|
End If
|
|
End If
|
|
|
|
|
|
'Move2Folder ausführen
|
|
If aktivesProfil.move2Folder <> "" Then
|
|
If My.Settings.vLogErrorsonly = False Then _Logger.Info("Move2Folder is activated...")
|
|
|
|
If oUnexpectedError = False And unvollstaendig = False Then
|
|
Dim sw As New ClassStopwatch("Move2Folder")
|
|
_Logger.Debug("Move 2 Folder ist aktiviert")
|
|
Dim oDescriptiveIndexValue = pMyWMDoc.GetVariableValue(aktivesProfil.Desk_windreamIndex)
|
|
Dim err As Boolean = Move2Folder(aktivesDokument.aName, My.Settings.MRWD_Laufwerk & ":" & pMyWMDoc.aPath.ToString, oDescriptiveIndexValue.ToString)
|
|
Dim msg = sw.Done
|
|
If msg <> "" Then
|
|
Stopwatch1 += vbNewLine & $"{msg}"
|
|
|
|
End If
|
|
Else
|
|
If My.Settings.vLogErrorsonly = False Then _Logger.Info("... no Move2Folder as something went wrong!")
|
|
End If
|
|
End If
|
|
|
|
'CREATEFOLDER
|
|
|
|
|
|
If oUnexpectedError = False And aktivesProfil.CrFolderIndex <> "" And unvollstaendig = False Then
|
|
Dim docpath As String
|
|
If moved_Folder = "" Then
|
|
docpath = My.Settings.MRWD_Laufwerk & ":" & pMyWMDoc.aPath
|
|
Else
|
|
docpath = moved_Folder
|
|
End If
|
|
Dim oMyDocumentName = pMyWMDoc.aName
|
|
Dim err As Boolean = CrFolderForIndex(docpath, oMyDocumentName)
|
|
If err = True Then
|
|
|
|
End If
|
|
Else
|
|
aktivesProfil.CrFolder_Created_Folder = ""
|
|
CURRENT_MOVE_FILEPATH = ""
|
|
End If
|
|
'Nachbearbeitung AD ausführen
|
|
If oUnexpectedError = False And aktivesProfil.NachbearbeitungAD = True And unvollstaendig = False Then
|
|
_Logger.Debug("Nachbearbeitung AD ist aktiviert")
|
|
Dim sw As New ClassStopwatch("AD-Rework")
|
|
Nachbearbeitung_AD(pMyWMDoc)
|
|
Dim msg = sw.Done
|
|
If msg <> "" Then
|
|
Stopwatch1 += vbNewLine & $"{msg}"
|
|
End If
|
|
Else
|
|
If aktivesProfil.NachbearbeitungAD = True Then
|
|
_Logger.Info($"Nachbearbeitung AD ist aktiviert aber Unexpected Error ist{oUnexpectedError.ToString}")
|
|
End If
|
|
End If
|
|
oUnexpectedError = False
|
|
Try
|
|
If aktivesDokument.aLocked Then
|
|
_Logger.Debug("Document still is locked...now unlocking")
|
|
aktivesDokument.unlock()
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Info("### Unexpected error in final Unlocking: " & ex.Message)
|
|
End Try
|
|
swMessage = swWorkDocument_All.Done
|
|
If swMessage <> "" Then
|
|
Stopwatch1 += vbNewLine & $"{swMessage}"
|
|
End If
|
|
_Logger.Debug("## Result Stopwatch: ##" & vbNewLine & Stopwatch1)
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
_Logger.Warn($"oResultNachindexierung so far: {oResultNachindexierung.ToString}")
|
|
End Try
|
|
End Sub
|
|
Private Function FolderForIndex(oDynamicFolder As String, myWMDocument As WMObject) As String
|
|
Try
|
|
'######
|
|
Dim oPRegex As String = "\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
' einen Regulären Ausdruck laden
|
|
Dim regularExpression As Regex = New Regex(oPRegex)
|
|
' die Vorkommen im Folder-String auslesen
|
|
Dim oElements As MatchCollection = regularExpression.Matches(oDynamicFolder)
|
|
'####
|
|
' alle Vorkommen innerhalb des Ordnerstrings durchlaufen
|
|
For Each oMatchElement As Match In oElements
|
|
_Logger.Debug("Elementname in oDynamicFolder: '" & oMatchElement.ToString & "'")
|
|
Select Case oMatchElement.Value.Substring(2, 1)
|
|
'Manueller Indexwert
|
|
Case "m"
|
|
Dim oWMIndexname = oMatchElement.Value.Substring(3, oMatchElement.Value.Length - 4)
|
|
_Logger.Debug("getting metavalue from '" & oWMIndexname & "'...")
|
|
Dim oWMIndexValue As String = myWMDocument.GetVariableValue(oWMIndexname)
|
|
_Logger.Debug("oWMIndexValue: '" & oWMIndexValue & "'", False)
|
|
If Not oWMIndexValue = String.Empty Then
|
|
If IsDate(oWMIndexValue) Then
|
|
oWMIndexValue = CDate(oWMIndexValue).ToString("yyyyMMdd")
|
|
End If
|
|
' oWMIndexValue = oWMIndexValue.Replace("\", "")
|
|
oDynamicFolder = oDynamicFolder.Replace(oMatchElement.ToString, oWMIndexValue)
|
|
_Logger.Debug(" FolderPattern: '" & oDynamicFolder & "'", False)
|
|
Else
|
|
_Logger.Warn($"[{myWMDocument.aName}] - Attention in 'FolderForIndex': the Index-Value [{oWMIndexname}] is empty! No Dynamic folder will be used!", True)
|
|
Return ""
|
|
End If
|
|
Case "v"
|
|
Dim oFolderTemp As String
|
|
Dim oMonth As String = My.Computer.Clock.LocalTime.Month
|
|
If oMonth.Length = 1 Then
|
|
oMonth = "0" & oMonth
|
|
End If
|
|
Dim oDay As String = My.Computer.Clock.LocalTime.Day
|
|
If oDay.Length = 1 Then
|
|
oDay = "0" & oDay
|
|
End If
|
|
Dim oType = oMatchElement.Value.Substring(3, oMatchElement.Value.Length - 4)
|
|
If oType.StartsWith("_") Then
|
|
oType = oType.Replace("_", "")
|
|
End If
|
|
Select Case oType
|
|
Case "YYYY/MM/DD"
|
|
oFolderTemp = My.Computer.Clock.LocalTime.Year & "\" & oMonth & "\" & oDay
|
|
Case "YYYY/MM"
|
|
oFolderTemp = My.Computer.Clock.LocalTime.Year & "\" & oMonth
|
|
Case "YYYY"
|
|
oFolderTemp = My.Computer.Clock.LocalTime.Year
|
|
Case "YYYY-MM"
|
|
oFolderTemp = My.Computer.Clock.LocalTime.Year & "-" & oMonth
|
|
Case "MM"
|
|
oFolderTemp = oMonth
|
|
Case "DD"
|
|
oFolderTemp = oDay
|
|
End Select
|
|
oDynamicFolder = oDynamicFolder.Replace(oMatchElement.ToString, oFolderTemp)
|
|
_Logger.Debug("FolderPatter after V-element: '" & oDynamicFolder & "'", False)
|
|
Case Else
|
|
_Logger.Info("Attention in DynamicFolderConvention an invalid element has been found: Elementname: " & oMatchElement.Value.ToUpper)
|
|
Return ""
|
|
|
|
End Select
|
|
Next
|
|
_Logger.Debug("Checking oDynamicFolder on illegal PathChars: " & oDynamicFolder, False)
|
|
Dim invalidPathChars() As Char = Path.GetInvalidPathChars()
|
|
Dim oPathSplit As String() = oDynamicFolder.Split("\")
|
|
For Each oFolder In oPathSplit
|
|
If oFolder = "" Then
|
|
Continue For
|
|
End If
|
|
Dim rgPattern = My.Settings.REGEX_INVALID_PATH '----Invalid Characters
|
|
Dim objRegEx As New Regex(rgPattern)
|
|
Dim oClearFolder = objRegEx.Replace(oFolder, "")
|
|
If oFolder <> oClearFolder Then
|
|
oDynamicFolder = oDynamicFolder.Replace(oFolder, oClearFolder)
|
|
End If
|
|
|
|
Next
|
|
|
|
If Directory.Exists(oDynamicFolder) = False Then
|
|
Try
|
|
Directory.CreateDirectory(oDynamicFolder)
|
|
_Logger.Debug("Folder '" & oDynamicFolder & "' has been created...", False)
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return ""
|
|
End Try
|
|
|
|
End If
|
|
|
|
|
|
Return oDynamicFolder
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return ""
|
|
End Try
|
|
End Function
|
|
Private Function FNMoveRename(myWMDocument As WMObject) As Boolean
|
|
Try
|
|
Dim oReturnString As String
|
|
Dim oActWMPath As String = "\\windream\objects" & myWMDocument.aPath
|
|
|
|
Dim oExtension As String = System.IO.Path.GetExtension(oActWMPath)
|
|
Dim oSQL = $"SELECT * FROM TBTC_MOVE_RENAME WHERE PROFILE_NAME = '{aktivesProfil.Profilname}'"
|
|
Dim oDT_TBTC_MOVE_RENAME As DataTable = DB_ECM.GetDatatable(oSQL)
|
|
|
|
Dim oVERSIONOFF As Boolean
|
|
If oDT_TBTC_MOVE_RENAME.Rows.Count = 1 Then
|
|
_Logger.Debug($"Found a Move and Rename Definition: [{oDT_TBTC_MOVE_RENAME.Rows(0).Item("FOLDER_FOR_INDEX")}]")
|
|
oVERSIONOFF = oDT_TBTC_MOVE_RENAME.Rows(0).Item("VERSION_OFF")
|
|
Dim oTargetpath As String
|
|
'Regulären Ausdruck zum Auslesen der Indexe definieren
|
|
Dim oPRegex As String = "\[%{1}[a-zA-Z0-9ß\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
If oDT_TBTC_MOVE_RENAME.Rows(0).Item("FOLDER_FOR_INDEX") <> "" Then
|
|
oTargetpath = oDT_TBTC_MOVE_RENAME.Rows(0).Item("FOLDER_FOR_INDEX")
|
|
oTargetpath = FolderForIndex(oTargetpath, myWMDocument)
|
|
Else
|
|
oTargetpath = Path.GetDirectoryName(oActWMPath)
|
|
End If
|
|
If oTargetpath = "" Then
|
|
Return True
|
|
End If
|
|
|
|
'schonmal den gesamten Pfad laden
|
|
Dim oNamenkonvention As String = oTargetpath & "\" & oDT_TBTC_MOVE_RENAME.Rows(0).Item("NAMECONVENTION") & oExtension
|
|
' einen Regulären Ausdruck laden
|
|
Dim oRegularExpression As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(oPRegex)
|
|
' die Vorkommen im SQL-String auslesen
|
|
Dim oMatchelements As System.Text.RegularExpressions.MatchCollection = oRegularExpression.Matches(oNamenkonvention)
|
|
'####
|
|
If oMatchelements.Count = 0 Then
|
|
_Logger.Info("No RegularExpression fields in nameconvention!", False)
|
|
End If
|
|
' alle Vorkommen innerhalbd er Namenkonvention durchlaufen
|
|
For Each oElement As System.Text.RegularExpressions.Match In oMatchelements
|
|
Select Case oElement.Value.Substring(2, 1)
|
|
'Manueller Indexwert
|
|
Case "m"
|
|
|
|
Dim oWMIndexname = oElement.Value.Substring(3, oElement.Value.Length - 4)
|
|
_Logger.Debug($"FNMoveRename: Index {oWMIndexname} will be checked...")
|
|
Dim oWMIndexValue As String = myWMDocument.GetVariableValue(oWMIndexname)
|
|
|
|
If oWMIndexValue <> String.Empty Then
|
|
|
|
Dim oClearedContent As String = String.Join("", oWMIndexValue.Split(Path.GetInvalidFileNameChars()))
|
|
If oClearedContent <> oWMIndexValue Then
|
|
_Logger.Debug($"Cleaned the WMContent with GetInvalidFileNameChars from [{oWMIndexValue}] to [{oClearedContent}]")
|
|
oWMIndexValue = oClearedContent
|
|
End If
|
|
Dim firstVectorValue = oWMIndexValue.Split("~").First()
|
|
oNamenkonvention = oNamenkonvention.Replace(oElement.Value, firstVectorValue)
|
|
Else
|
|
_Logger.Info($"Attention: the indexvalue of index {oWMIndexname} is empty!")
|
|
Return True
|
|
End If
|
|
|
|
Case "v"
|
|
Dim oDatetemp As String
|
|
Dim oMonth As String = My.Computer.Clock.LocalTime.Month
|
|
If oMonth.Length = 1 Then
|
|
oMonth = "0" & oMonth
|
|
End If
|
|
Dim oDay As String = My.Computer.Clock.LocalTime.Day
|
|
If oDay.Length = 1 Then
|
|
oDay = "0" & oDay
|
|
End If
|
|
Dim oType = oElement.Value '.ToUpper.Replace("[v%", "")
|
|
oType = oType.Replace("[%v_", "")
|
|
oType = oType.Replace("[%v", "")
|
|
oType = oType.Replace("]", "")
|
|
Select Case oType
|
|
Case "YY_MM_DD"
|
|
oDatetemp = My.Computer.Clock.LocalTime.Year.ToString.Substring(2) & "_" & oMonth & "_" & oDay
|
|
Case "YYYY_MM_DD"
|
|
oDatetemp = My.Computer.Clock.LocalTime.Year & "_" & oMonth & "_" & oDay
|
|
Case "DD_MM_YY"
|
|
oDatetemp = oDay & "_" & oMonth & "_" & My.Computer.Clock.LocalTime.Year.ToString.Substring(2)
|
|
Case "DD_MM_YYYY"
|
|
oDatetemp = oDay & "_" & oMonth & "_" & My.Computer.Clock.LocalTime.Year
|
|
Case "YYMMDD"
|
|
oDatetemp = My.Computer.Clock.LocalTime.Year.ToString.Substring(2) & oMonth & oDay
|
|
Case "YYYYMMDD"
|
|
oDatetemp = My.Computer.Clock.LocalTime.Year & oMonth & oDay
|
|
Case "DDMMYY"
|
|
oDatetemp = oDay & oMonth & My.Computer.Clock.LocalTime.Year.ToString.Substring(2)
|
|
Case "DDMMYYYY"
|
|
oDatetemp = oDay & oMonth & My.Computer.Clock.LocalTime.Year
|
|
Case "YYYY"
|
|
oDatetemp = My.Computer.Clock.LocalTime.Year
|
|
Case "MM"
|
|
oDatetemp = oMonth
|
|
Case "DD"
|
|
oDatetemp = oDay
|
|
Case "DDMMYYYY"
|
|
oDatetemp = oDay & oMonth & My.Computer.Clock.LocalTime.Year
|
|
Case "OFilename"
|
|
oNamenkonvention = oNamenkonvention.Replace(oElement.Value, System.IO.Path.GetFileNameWithoutExtension(oActWMPath))
|
|
'Case "Username".ToUpper
|
|
' oNamenkonvention = oNamenkonvention.Replace(oElement.Value, Environment.UserName)
|
|
'Case "Usercode".ToUpper
|
|
' oNamenkonvention = oNamenkonvention.Replace(oElement.Value, USER_SHORT_NAME)
|
|
Case ""
|
|
End Select
|
|
If oDatetemp <> "" Then
|
|
oNamenkonvention = oNamenkonvention.Replace(oElement.Value, oDatetemp)
|
|
End If
|
|
|
|
Case "[%Version]".ToUpper
|
|
Try
|
|
Dim oNewFileName As String
|
|
Dim oVersion As Integer = 1
|
|
Dim oStammname As String = oNamenkonvention.Replace(oElement.Value, "")
|
|
Dim oNeuerName As String = oNamenkonvention.Replace(oElement.Value, "")
|
|
oStammname = oNeuerName.Replace("~", "")
|
|
oNeuerName = oNeuerName.Replace("~", "")
|
|
'Dim MoveFilename As String = DATEINAME.Replace(element.Value, "")
|
|
'Überprüfen ob File existiert
|
|
If File.Exists(oNeuerName & oExtension) = False Then
|
|
oNewFileName = oNeuerName
|
|
oNamenkonvention = oNewFileName
|
|
Else
|
|
Do While File.Exists(oNeuerName & oExtension)
|
|
oVersion = oVersion + 1
|
|
oNeuerName = oStammname & "~" & oVersion
|
|
oNewFileName = oNeuerName
|
|
Loop
|
|
oNamenkonvention = oNewFileName
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn("Unexpected error in Umbenennnen der Datei - Fehler: " & vbNewLine & ex.Message)
|
|
Return True
|
|
End Try
|
|
Case Else
|
|
_Logger.Info("Attention: in nameconvention file an invalid elemt has been found - Elementname: " & oElement.Value.ToUpper)
|
|
Return True
|
|
End Select
|
|
Next
|
|
oReturnString = oNamenkonvention
|
|
Else
|
|
If oDT_TBTC_MOVE_RENAME.Rows.Count = 0 Then
|
|
Return False
|
|
Else
|
|
oReturnString = oActWMPath
|
|
End If
|
|
|
|
|
|
|
|
|
|
End If
|
|
Dim oOldFilename = oReturnString.Substring(oReturnString.LastIndexOf("\") + 1)
|
|
_Logger.Debug($"oOldFilename: {oOldFilename}")
|
|
Dim oCleanFileName As String = String.Join("", oOldFilename.Split(Path.GetInvalidFileNameChars()))
|
|
If oCleanFileName <> oOldFilename Then
|
|
_Logger.Info($"Cleaned the filename with GetInvalidFileNameChars from [{oOldFilename}] to [{oCleanFileName}]")
|
|
oReturnString = oReturnString.Replace(oOldFilename, oCleanFileName)
|
|
End If
|
|
Dim oOriginalPath = oReturnString.Substring(1, oReturnString.LastIndexOf("\"))
|
|
|
|
Dim oCleanPathName As String = String.Join("", oOriginalPath.Split(Path.GetInvalidPathChars()))
|
|
If oCleanPathName <> oOriginalPath Then
|
|
_Logger.Info($"Cleaned the path with GetInvalidPathChars from [{oOriginalPath}] to [{oCleanPathName}]")
|
|
oReturnString = oReturnString.Replace(oOriginalPath, oCleanPathName)
|
|
End If
|
|
|
|
Dim oPathFile As String = oReturnString.Replace(oExtension, "")
|
|
Dim oNewPathFilename = oPathFile + oExtension
|
|
'Dim MoveFilename As String = DATEINAME.Replace(element.Value, "")
|
|
If oVERSIONOFF = True Then
|
|
|
|
If File.Exists(oNewPathFilename) Then
|
|
Try
|
|
_Logger.Debug("MOVERENAME-VERSIONING is OFF - Deleting existing file...")
|
|
File.Delete(oNewPathFilename)
|
|
Catch ex As Exception
|
|
_Logger.Warn($"Could Not delete file As VERSIONOFF Is True [{ex.Message}]")
|
|
End Try
|
|
End If
|
|
Else
|
|
'Überprüfen ob File existiert
|
|
Dim oNewVersion As Integer = 1
|
|
Do While File.Exists(oNewPathFilename)
|
|
|
|
oNewVersion = oNewVersion + 1
|
|
oNewPathFilename = oPathFile & "~" & oNewVersion & oExtension
|
|
|
|
Loop
|
|
If oNewPathFilename <> oReturnString Then
|
|
oReturnString = oNewPathFilename
|
|
End If
|
|
End If
|
|
Dim oFilename = myWMDocument.aName
|
|
If myWMDocument.aLocked Then
|
|
_Logger.Debug("Document still is locked...now unlocking...")
|
|
myWMDocument.unlock()
|
|
End If
|
|
|
|
myWMDocument = Nothing
|
|
If _windreamNI.NEW_MOVE_FILE(oReturnString, oActWMPath, "MO_RE", oFilename) = True Then
|
|
Return False
|
|
Else
|
|
Return True
|
|
End If
|
|
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return True
|
|
End Try
|
|
End Function
|
|
Private Function OrdnerIndizes_zuweisen(ByVal _dokument As WMObject)
|
|
Try
|
|
'Die Ordernindizes-Namen laden
|
|
Dim Ordner_Indexe = _windream.GetIndicesByFoldertype(Me.aktivesProfil.OrdnerType, False)
|
|
'Die Objekttypindizes laden
|
|
Dim Objecttype_Indexe = _windream.GetIndicesByObjecttype(Me.aktivesProfil.DokumenttypString, False, "NI")
|
|
' Den Ordner als Objekt deklarieren
|
|
Dim WMFolder As WINDREAMLib.WMObject
|
|
|
|
If Me.aktivesProfil.OrdnerType_Ebene <> "Parent" Then
|
|
Dim _path = ""
|
|
Dim _folderArray As String() = _dokument.aPath.Split("\")
|
|
Dim index = (_folderArray.Length - 1) + CObj(Me.aktivesProfil.OrdnerType_Ebene) - 1
|
|
Dim i As Integer = 0
|
|
For Each _Ordner As String In _folderArray
|
|
_path = _path & "\" & _Ordner
|
|
If i = index Then
|
|
Exit For
|
|
End If
|
|
i += 1
|
|
Next
|
|
|
|
_Logger.Debug("der Folder '" & _path & "' soll die Quelle für die Indexwerte sein")
|
|
Try
|
|
WMFolder = _windreamNI.oWMSession.GetWMObjectByPath(WINDREAMLib.WMEntity.WMEntityFolder, _path)
|
|
Catch ex As Exception
|
|
_Logger.Warn("## Fehler in OrdnerIndizes_zuweisen WMFolder 'Not Parent' " & ex.Message)
|
|
Return False
|
|
End Try
|
|
Else
|
|
_Logger.Debug("der Parentfolder ist die Quelle für die Indexwerte")
|
|
Try
|
|
WMFolder = _dokument.aParentWMObject
|
|
Catch ex As Exception
|
|
_Logger.Warn("## Fehler in OrdnerIndizes_zuweisen WMFolder 'Parent': " & ex.Message)
|
|
Return False
|
|
End Try
|
|
|
|
End If
|
|
|
|
If IsArray(Ordner_Indexe) And IsArray(Objecttype_Indexe) And (Not WMFolder Is Nothing) Then
|
|
|
|
'Jeden Ordnertyp-Index durchlaufen
|
|
For Each OrdnerIdxName As String In Ordner_Indexe
|
|
'Dann jeden Objekttyp-Index durchlaufen
|
|
For Each DateiIdxName As String In Objecttype_Indexe
|
|
'Wenn der Name identisch ist
|
|
If DateiIdxName.ToLower = OrdnerIdxName.ToLower Then
|
|
_Logger.Debug("Indexname Ordnertyp: '" & OrdnerIdxName & "' wird als Quelle genutzt")
|
|
'MsgBox("Indexname Datei Ordner gleich!")
|
|
'Den Indexwert aus dem Ordner auslesen
|
|
Dim fold_idxValue = WMFolder.GetVariableValue(OrdnerIdxName)
|
|
If IsNothing(fold_idxValue) = False Then
|
|
If fold_idxValue <> "" Then
|
|
Dim arrIndex() As String = Nothing
|
|
Dim arrValue() As String = Nothing
|
|
'Nun die Datei indexieren
|
|
arrIndex = Nothing
|
|
arrValue = Nothing
|
|
ReDim Preserve arrIndex(0)
|
|
ReDim Preserve arrValue(0)
|
|
arrIndex(0) = OrdnerIdxName
|
|
arrValue(0) = fold_idxValue
|
|
Me._windreamNI.RunIndexing(aktivesDokument, arrIndex, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
Else
|
|
_Logger.Warn("Indexwert ist leer")
|
|
End If
|
|
End If
|
|
|
|
End If
|
|
Next
|
|
Next
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return False
|
|
End Try
|
|
Return True
|
|
End Function
|
|
Private Function Nachbearbeitung_AD(ByVal _dokument As WMObject)
|
|
Dim _erfolgreich As Boolean = True
|
|
Try
|
|
Dim DT As DataTable = _sqlite.Return_Datatable("select * from TBNI_NACHBEARBEITUNG_AD WHERE AKTIV = 1 AND NI_PROFILNAME = '" & aktivesProfil.Profilname & "'", True)
|
|
If DT.Rows.Count = 1 Then
|
|
Dim profilID As Integer
|
|
profilID = DT.Rows(0).Item("GUID")
|
|
'For Each DTrow As DataRow In DT.Rows
|
|
' profilID = DTrow.Item("GUID")
|
|
'Next
|
|
Dim DTR As DataTable = _sqlite.Return_Datatable("select * from TBNI_NB_STEP_AD WHERE PROFIL_ID = " & profilID, False)
|
|
If DTR.Rows.Count > 0 Then
|
|
Dim i As Integer = 0
|
|
Dim folgeRegel As Boolean
|
|
For Each row As DataRow In DTR.Rows
|
|
Try
|
|
If i > 0 Then
|
|
folgeRegel = True
|
|
End If
|
|
If _windreamRechte.FileFolder_DeleteAndOrSetRight(_dokument.aPath, profilID, row.Item("GUID"), folgeRegel, CURRENT_MOVE_FILEPATH, False) = False Then 'aktivesProfil.CrFolder_Created_Folder
|
|
_Logger.Warn("## Fehler in _windreamRechte.FileFolder_DeleteAndOrSetRight - Abbruch")
|
|
_erfolgreich = False
|
|
Exit For
|
|
End If
|
|
i += 1
|
|
Catch ex As Exception
|
|
|
|
End Try
|
|
|
|
Next
|
|
End If
|
|
Else
|
|
_Logger.Warn("## Achtung in Nachbearbeitung_AD: Der Select für Profil lieferte KEINE oder MEHR ALS EINE Zeile zurück!")
|
|
End If
|
|
Return _erfolgreich
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return False
|
|
End Try
|
|
End Function
|
|
Private Function Volltext_indexer(_dokument As WMObject, fulltext As String)
|
|
Try
|
|
' MsgBox(fulltext)
|
|
Dim namedoc = _dokument.aName
|
|
fulltext = fulltext.Replace(vbCrLf, "")
|
|
Dim ign_whitespace As Boolean = False
|
|
Dim IndexArray As String()
|
|
Dim ErgebnisArray As String()
|
|
Dim counter As Integer = 0
|
|
Dim Erfolgreich As Boolean = True
|
|
_Logger.Debug("working Volltext_indexer...")
|
|
' alle Regex-Links des Profils durchlaufen
|
|
For Each Fulltext_Indexierung As ClassNIVerknüpfung In Me.aktivesProfil.Verknüpfungen.Links
|
|
If Erfolgreich = True Then
|
|
'Ignore Whitespace
|
|
If Fulltext_Indexierung.SelectAnweisung.Contains("ignore=''") Then
|
|
fulltext = fulltext.Replace(" ", "")
|
|
End If
|
|
ErgebnisArray = Nothing
|
|
'#####
|
|
If Fulltext_Indexierung.Spalte.StartsWith("%") And Fulltext_Indexierung.Spalte.EndsWith("%") Then
|
|
Dim manwert As String
|
|
'Ein manueller Wert in der Verknüpfung
|
|
_Logger.Debug(">> Volltext_indexer: Indexierung mit einem manuellem Wert")
|
|
manwert = Fulltext_Indexierung.Spalte.Replace("%", "")
|
|
_Logger.Debug(">> Manueller Wert: " & manwert)
|
|
'Indexieren der Datei
|
|
' die Arraygrößen anpassen
|
|
ReDim Preserve IndexArray(0)
|
|
' den angegebenen Index eintragen
|
|
IndexArray(0) = Fulltext_Indexierung.Index
|
|
Dim arrValue() As String = Nothing
|
|
arrValue = Nothing
|
|
ReDim Preserve arrValue(0)
|
|
arrValue(0) = manwert
|
|
Erfolgreich = Me._windreamNI.RunIndexing(_dokument, IndexArray, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
Else
|
|
Dim pos_von, pos_bis As Integer
|
|
'##
|
|
If Fulltext_Indexierung.SelectAnweisung.Contains(";") Then
|
|
Dim _posArray As String() = Fulltext_Indexierung.SelectAnweisung.Split(";")
|
|
Try
|
|
pos_von = _posArray(0)
|
|
Catch ex As Exception
|
|
pos_von = 0
|
|
End Try
|
|
Try
|
|
pos_bis = _posArray(1)
|
|
Catch ex As Exception
|
|
pos_bis = 0
|
|
End Try
|
|
Try
|
|
ign_whitespace = CBool(_posArray(2))
|
|
Catch ex As Exception
|
|
ign_whitespace = False
|
|
End Try
|
|
_Logger.Debug("Volltext-Indexierung - Regex: '" & Fulltext_Indexierung.Spalte & "' - Alle Vorkommen")
|
|
Else
|
|
pos_von = 10000
|
|
pos_bis = 0
|
|
_Logger.Debug("Volltext-Indexierung - Regex: '" & Fulltext_Indexierung.Spalte & "' - Pos.-Von: '" & pos_von & "' - Pos.-Bis: '" & pos_bis)
|
|
End If
|
|
|
|
|
|
ErgebnisArray = _fulltext.GetValuesFromFulltext(_dokument.aName, fulltext, Fulltext_Indexierung.Spalte, pos_von, pos_bis, ign_whitespace)
|
|
If Not ErgebnisArray Is Nothing Then
|
|
'im Array mehrfachvorkommen ausschliessen
|
|
ErgebnisArray = ErgebnisArray.Distinct.ToArray
|
|
Array.Sort(ErgebnisArray)
|
|
'Werte zwischenspeichern
|
|
MyDataset.Tables("TBVEKTOR_ARRAY").Clear()
|
|
For Each Value As String In ErgebnisArray
|
|
Dim RowNew As DataRow
|
|
RowNew = MyDataset.Tables("TBVEKTOR_ARRAY").NewRow()
|
|
'filling the row with values. Item property is used to set the field value.
|
|
RowNew.Item("IndexName") = Fulltext_Indexierung.Index
|
|
RowNew.Item("Value") = Value
|
|
MyDataset.Tables("TBVEKTOR_ARRAY").Rows.Add(RowNew)
|
|
Next
|
|
|
|
'Den Indexierungsvorgang für diesen RegEx ausführen
|
|
' die Arraygrößen anpassen
|
|
ReDim Preserve IndexArray(0)
|
|
' den angegebenen Index eintragen
|
|
IndexArray(0) = Fulltext_Indexierung.Index
|
|
'Indexieren
|
|
If ErgebnisArray.Length = 1 Then
|
|
Dim arrValue() As String = Nothing
|
|
arrValue = Nothing
|
|
ReDim Preserve arrValue(0)
|
|
arrValue(0) = ErgebnisArray(0)
|
|
Erfolgreich = Me._windreamNI.RunIndexing(_dokument, IndexArray, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
If Erfolgreich = False Then
|
|
Erfolgreich = True
|
|
Else
|
|
Erfolgreich = False
|
|
End If
|
|
|
|
'Erfolgreich = Me._windreamNI.RunIndexing_Vektor(_dokument, IndexArray, arrValue)
|
|
Else
|
|
Erfolgreich = Me._windreamNI.RunIndexing_Vektor(_dokument, IndexArray, ErgebnisArray)
|
|
End If
|
|
|
|
|
|
Else
|
|
|
|
End If
|
|
End If
|
|
|
|
'counter = 0
|
|
'' Regulären Ausdruck zum Auslesen der windream-Indexe definieren
|
|
'Dim preg As String = Fulltext_Indexierung.Spalte '"\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
'' einen Regulären Ausdruck laden
|
|
'Dim regulärerAusdruck As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(preg)
|
|
'' die Vorkommen im SQL-String auslesen
|
|
'Dim elemente As System.Text.RegularExpressions.MatchCollection = regulärerAusdruck.Matches(fulltext)
|
|
'' alle Vorkommen der windream-Indexe im SQL-String durchlaufen
|
|
'For Each element As System.Text.RegularExpressions.Match In elemente
|
|
|
|
' ReDim Preserve ErgebnisArray(counter)
|
|
' 'filling the row with values. Item property is used to set the field value.
|
|
' ErgebnisArray(counter) = element.ToString
|
|
' Dim RowNew As DataRow
|
|
' RowNew = MyDataset.Tables("TBVEKTOR_ARRAY").NewRow()
|
|
' 'filling the row with values. Item property is used to set the field value.
|
|
' RowNew.Item("IndexName") = Fulltext_Indexierung.Index
|
|
|
|
' RowNew.Item("Value") = element.ToString
|
|
|
|
' MyDataset.Tables("TBVEKTOR_ARRAY").Rows.Add(RowNew)
|
|
' 'ArrayCounter hochsetzen
|
|
' counter += 1
|
|
|
|
|
|
' 'Für jeden Wert im Array werden nun Duplikate gezählt
|
|
'Next ' zum nächsten Vorkommen
|
|
|
|
'ErgebnisArray = ErgebnisArray.Distinct.ToArray
|
|
'Array.Sort(ErgebnisArray)
|
|
|
|
'MyDataset.Tables("TBVEKTOR_ARRAY").Clear()
|
|
|
|
|
|
'For Each Value As String In ErgebnisArray
|
|
' Dim RowNew As DataRow
|
|
' RowNew = MyDataset.Tables("TBVEKTOR_ARRAY").NewRow()
|
|
' 'filling the row with values. Item property is used to set the field value.
|
|
' RowNew.Item("IndexName") = Fulltext_Indexierung.Index
|
|
' RowNew.Item("Value") = Value
|
|
' MyDataset.Tables("TBVEKTOR_ARRAY").Rows.Add(RowNew)
|
|
'Next
|
|
|
|
''Den Indexierungsvorgang für diesen RegEx ausführen
|
|
'' die Arraygrößen anpassen
|
|
'ReDim Preserve IndexArray(0)
|
|
'' den angegebenen Index eintragen
|
|
'IndexArray(0) = Fulltext_Indexierung.Index
|
|
''den, übergebenen/gefundenen IndexWert, eintragen
|
|
|
|
'Erfolgreich = Me._windreamNI.RunIndexing_Vektor(_dokument, IndexArray, ErgebnisArray)
|
|
Else
|
|
_Logger.Warn("## Fehler in Volltext_indexer- Erfolgreich = False")
|
|
End If
|
|
Next
|
|
|
|
Return Erfolgreich
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
Return True
|
|
End Try
|
|
End Function
|
|
'Ab Hier Error prüfen
|
|
Sub File_SetBooleanIndex(ByVal _value As Boolean, ByVal _dok As WINDREAMLib.WMObject, ByVal _Indexname As String)
|
|
Try
|
|
If _Indexname <> "" Then
|
|
'Überprüfen ob Boolean-Value bereits gesetzt wurde?
|
|
Dim akt_Status As Boolean = CBool(_dok.GetVariableValue(_Indexname))
|
|
If akt_Status <> _value Then
|
|
'Index muß angepasst werden
|
|
_Logger.Debug("Validation Index not set to '" & _value.ToString & "'.")
|
|
Dim arrIndex() As String = Nothing
|
|
Dim arrValue() As String = Nothing
|
|
'Nun die Datei indexieren
|
|
arrIndex = Nothing
|
|
arrValue = Nothing
|
|
ReDim Preserve arrIndex(0)
|
|
ReDim Preserve arrValue(0)
|
|
arrIndex(0) = _Indexname
|
|
arrValue(0) = _value.ToString
|
|
Me._windreamNI.RunIndexing(_dok, arrIndex, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
If aktivesProfil.IndexFehler <> "" Then
|
|
_Logger.Debug("History-error will be set to true!")
|
|
arrIndex = Nothing
|
|
arrValue = Nothing
|
|
ReDim Preserve arrIndex(0)
|
|
ReDim Preserve arrValue(0)
|
|
arrIndex(0) = aktivesProfil.IndexFehler
|
|
arrValue(0) = "True"
|
|
Me._windreamNI.RunIndexing(_dok, arrIndex, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
End If
|
|
Else
|
|
'Validation muß nicht angepasst werden
|
|
_Logger.Debug("Validation Index already set to '" & _value & "'.")
|
|
End If
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn("Error in File_SetBooleanIndex")
|
|
_Logger.Error(ex)
|
|
End Try
|
|
|
|
|
|
End Sub
|
|
Sub SetErrorMeldung(ByVal _error As String, ByVal _dok As WINDREAMLib.WMObject, ByVal _Indexname As String)
|
|
Try
|
|
If Not _Indexname = String.Empty Then
|
|
'Überprüfen ob Validierung bereits gesetzt wurde?
|
|
Dim WMVALUE = Nothing
|
|
WMVALUE = _dok.GetVariableValue(_Indexname)
|
|
Dim _continue As Boolean = False
|
|
|
|
If WMVALUE Is Nothing Then
|
|
_continue = True
|
|
Else
|
|
If WMVALUE.ToString <> _error Then
|
|
_continue = True
|
|
Else
|
|
'Validation muß nicht angepasst werden
|
|
_Logger.Debug("value already equal errormessage")
|
|
_continue = False
|
|
End If
|
|
End If
|
|
If _continue = True Then
|
|
_Logger.Debug("indexvalue <> errormessage '" & _error & "'")
|
|
'Error muß angepasst werden
|
|
Dim arrIndex() As String
|
|
Dim arrValue() As String
|
|
'Nun die Datei indexieren
|
|
ReDim arrIndex(0)
|
|
ReDim arrValue(0)
|
|
arrIndex(0) = _Indexname
|
|
arrValue(0) = _error
|
|
Me._windreamNI.RunIndexing(_dok, arrIndex, arrValue, MyDataset, aktivesProfil.Profilname, aktivesProfil.DokumenttypString)
|
|
End If
|
|
End If
|
|
Catch ex As Exception
|
|
|
|
If ex.Message.Contains("Variable: Error not found") Then
|
|
_Logger.Warn("Error in SetErrorMeldung - Der 'Error'-Index existiert nicht!")
|
|
_Logger.Warn($"ERROR MESSAGE to set: [{_error}]")
|
|
Else
|
|
_Logger.Error(ex)
|
|
|
|
End If
|
|
End Try
|
|
End Sub
|
|
Private Function IsNotEmpty(ByVal aValue As Object)
|
|
|
|
If aValue IsNot Nothing Then
|
|
Dim itsType As Type = aValue.GetType
|
|
If itsType Is GetType(String) Then
|
|
|
|
If Not aValue = "" Then
|
|
Return True
|
|
End If
|
|
|
|
Return False
|
|
Else
|
|
Return True
|
|
End If
|
|
Else
|
|
Return False
|
|
End If
|
|
|
|
|
|
End Function
|
|
Private Shared Function REGEX_REPLACE(_STRING As String, ByVal oWMFile As WMObject)
|
|
Try
|
|
' Regulären Ausdruck zum Auslesen der windream-Indexe definieren
|
|
Dim preg As String = "\[%{1}[a-zA-Z0-9\!\$\&\/\(\)\=\?\,\.\-\;\:_öÖüÜäÄ\#\'\+\*\~\{\}\@\€\<\>\ ]+]{1}"
|
|
' einen Regulären Ausdruck laden
|
|
Dim regulärerAusdruck As System.Text.RegularExpressions.Regex = New System.Text.RegularExpressions.Regex(preg)
|
|
' die Vorkommen im SQL-String auslesen
|
|
Dim reg_elemente As System.Text.RegularExpressions.MatchCollection = regulärerAusdruck.Matches(_STRING)
|
|
Dim i As Integer = 0
|
|
' alle Vorkommen der windream-Indexe im SQL-String durchlaufen
|
|
For Each reg_element As System.Text.RegularExpressions.Match In reg_elemente
|
|
' die Zeichen [% und ] entfernen (liefert den wirklichen windream-Index)
|
|
Dim reg_element_Ohne_SZ As String = reg_element.Value.Replace("[%", "")
|
|
reg_element_Ohne_SZ = reg_element_Ohne_SZ.Replace("]", "")
|
|
_Logger.Debug($"{oWMFile.aName} # Indexwert aus Index/Variable [" & reg_element_Ohne_SZ & "] auslesen....")
|
|
Dim wdIndexwert
|
|
|
|
' den Wert des Indexes für das aktuelle Dokument auslesen
|
|
wdIndexwert = oWMFile.GetVariableValue(reg_element_Ohne_SZ)
|
|
If wdIndexwert Is Nothing = False Then
|
|
If Not wdIndexwert.GetType.ToString.Contains("System.Object") Then
|
|
_Logger.Debug($"{oWMFile.aName} # Namenkonvention (" & i & ") " & _STRING)
|
|
wdIndexwert = wdIndexwert.ToString.TrimEnd
|
|
wdIndexwert = wdIndexwert.ToString.TrimStart
|
|
_Logger.Debug($"{oWMFile.aName} # Ausgelesener Indexwert = '" & wdIndexwert & "'")
|
|
|
|
_STRING = _STRING.Replace(reg_element.Value, wdIndexwert.ToString)
|
|
i += 1
|
|
Else
|
|
_Logger.Warn("Achtung gelesener Wert ist ein Vektorfeld - keine Umbenennung möglich ")
|
|
Return Nothing
|
|
End If
|
|
End If
|
|
|
|
|
|
|
|
Next
|
|
Return _STRING
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
Return Nothing
|
|
End Try
|
|
End Function
|
|
Private Function Check_DeskIndexValue(ByVal _indexvalue As String, ByVal _sql As String, ByVal oWMFile As WMObject)
|
|
Try
|
|
Dim sql As String = _sql
|
|
Dim _vsql
|
|
Dim _replace As String
|
|
'LIKE UPPER('%[%String 01]')'
|
|
If IsNumeric(_indexvalue) Then
|
|
_replace = _indexvalue
|
|
' Else
|
|
' _replace = "'" & _indexvalue & "'"
|
|
End If
|
|
_vsql = REGEX_REPLACE(sql, oWMFile)
|
|
If _vsql = Nothing Then
|
|
Return 0
|
|
End If
|
|
_Logger.Debug("Check_DeskIndexValue - Select Scalar: " & _vsql)
|
|
|
|
If aktivesProfil.DbArt = "Oracle" Then
|
|
Dim ergebnis As Integer = database.CheckIndex_oracle(_vsql, aktivesProfil.DataSource, aktivesProfil.InitialCatalog, aktivesProfil.UserId, aktivesProfil.Password)
|
|
If ergebnis = 1 Then
|
|
Return 1
|
|
Else
|
|
If ergebnis > 1 Then
|
|
Return 2
|
|
Else
|
|
Return 0
|
|
End If
|
|
End If
|
|
ElseIf aktivesProfil.DbArt = "MS-SQL" Then
|
|
Dim ergebnis As Integer = database.CheckIndex_MSSSQL(aktivesProfil.Profilname, _vsql, aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password, aktivesProfil.InitialCatalog)
|
|
If ergebnis = 1 Then
|
|
Return 1
|
|
Else
|
|
If ergebnis > 1 Then
|
|
Return 2
|
|
Else
|
|
Return 0
|
|
End If
|
|
End If
|
|
ElseIf aktivesProfil.DbArt = "ODBC" Then
|
|
Dim ergebnis As Integer = database.CheckIndex_ODBC(aktivesProfil.Profilname, _vsql, aktivesProfil.DataSource, aktivesProfil.UserId, aktivesProfil.Password)
|
|
If ergebnis = 1 Then
|
|
Return 1
|
|
Else
|
|
If ergebnis > 1 Then
|
|
Return 2
|
|
Else
|
|
Return 0
|
|
End If
|
|
End If
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
End Function
|
|
|
|
|
|
|
|
Private Sub tcMain_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles tcmain.SelectedIndexChanged
|
|
Select Case tcmain.SelectedIndex
|
|
Case 0
|
|
|
|
My.Settings.Save()
|
|
Case 1
|
|
|
|
End Select
|
|
End Sub
|
|
Sub Start_NachindexierungThreads()
|
|
If My.Settings.vLogErrorsonly = False Then
|
|
_MyLogger.Debug = True
|
|
Else
|
|
_MyLogger.Debug = False
|
|
End If
|
|
|
|
If bwProfil.IsBusy Or bwsearch.IsBusy Then
|
|
_Logger.Info("Achtung die Threads laufen noch!")
|
|
_Logger.Info("bwProfil: " & bwProfil.IsBusy)
|
|
_Logger.Info("bwsearch: " & bwsearch.IsBusy)
|
|
_Logger.Info("Restart der Nachindexierung wird eingeleitet - Form wird geschlossen")
|
|
NI_Restart = True
|
|
Me.Close()
|
|
Exit Sub
|
|
End If
|
|
Try
|
|
Dim directory As New IO.DirectoryInfo(_MyLogger.LogDirectory)
|
|
|
|
For Each file As IO.FileInfo In directory.GetFiles
|
|
If (Now - file.CreationTime).Days > 29 Then
|
|
file.Delete()
|
|
Else
|
|
Exit For
|
|
End If
|
|
|
|
Next
|
|
Catch ex As Exception
|
|
|
|
End Try
|
|
'Die NI wird ganz normal gestartet
|
|
Me.btnStartStop.Text = "Nachindexierung stoppen"
|
|
Me.numIntervall.Enabled = False
|
|
Me.pnlInfos.Visible = True
|
|
If Me.numIntervall.Value = 0 Then
|
|
Me.numIntervall.Value = 5
|
|
End If
|
|
manually_cancel = False
|
|
Me.timRun.Interval = Me.numIntervall.Value * 60 * 1000
|
|
Me.timRun.Start()
|
|
'Variable für den Fall Programmabbruch und Neustart!
|
|
bwProfil = New BackgroundWorker
|
|
bwsearch = New BackgroundWorker
|
|
bwDatei = New BackgroundWorker
|
|
AddHandler bwProfil.DoWork, AddressOf bwProfil_DoWork
|
|
AddHandler bwProfil.RunWorkerCompleted, AddressOf bwProfil_RunWorkerCompleted
|
|
AddHandler bwProfil.ProgressChanged, AddressOf bwProfil_ProgressChanged
|
|
bwProfil.WorkerReportsProgress = True
|
|
bwProfil.WorkerSupportsCancellation = True
|
|
|
|
AddHandler bwsearch.DoWork, AddressOf bwsearch_Documents
|
|
AddHandler bwsearch.RunWorkerCompleted, AddressOf bwsearch_RunWorkerCompleted
|
|
bwsearch.WorkerSupportsCancellation = True
|
|
|
|
|
|
AddHandler bwDatei.DoWork, AddressOf bwDatei_DoWork
|
|
AddHandler bwDatei.RunWorkerCompleted, AddressOf bwDatei_RunWorkerCompleted
|
|
AddHandler bwDatei.ProgressChanged, AddressOf bwDatei_ProgressChanged
|
|
bwDatei.WorkerReportsProgress = True
|
|
bwDatei.WorkerSupportsCancellation = True
|
|
|
|
My.Settings.NI_RUNNING = True
|
|
My.Settings.Save()
|
|
' den Indexierungsvorgang direkt (zum ersten Mal) durchführen
|
|
Me.Profile_Durchlaufen()
|
|
|
|
End Sub
|
|
Sub Abbruch_NI(cancel_Reason As String, Abbruch As Boolean, keeprunning As Boolean)
|
|
Try
|
|
_Logger.Info("Nachindexierung wird abgebrochen - Reason: " & cancel_Reason)
|
|
Try
|
|
If Me.bwProfil.IsBusy Or cancel_Reason = "Abbruch nach Timeout Suche" Then
|
|
_Logger.Warn("Thread Profil wird abgebrochen....")
|
|
Me.bwProfil.CancelAsync()
|
|
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
Try
|
|
If Me.bwsearch.IsBusy Or cancel_Reason = "Abbruch nach Timeout Suche" Then
|
|
_Logger.Warn("Thread Search wird abgebrochen....")
|
|
Me.bwsearch.CancelAsync()
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn("Fehler beim Abbrechen des Threads bwsearch: " & ex.Message)
|
|
End Try
|
|
Try
|
|
If Me.bwDatei.IsBusy Or cancel_Reason = "Abbruch nach Timeout Suche" Then
|
|
_Logger.Warn("Thread Datei wird abgebrochen....")
|
|
Me.bwDatei.CancelAsync()
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Warn("Fehler beim Abbrechen des Threads bwDatei: " & ex.Message)
|
|
End Try
|
|
|
|
manually_cancel = True
|
|
_Logger.Info("Threads gestoppt - " & Now)
|
|
|
|
If keeprunning = False Then
|
|
_Logger.Debug("keeprunning = False - Zurücksetzen")
|
|
'Abbruch der Nachindexierung
|
|
My.Settings.NI_RUNNING = False
|
|
Me.numIntervall.Enabled = True
|
|
Me.pnlInfos.Visible = False
|
|
Me.tslblStatus.Visible = False
|
|
My.Settings.Save()
|
|
End If
|
|
If keeprunning = True And cancel_Reason = "Abbruch nach Timeout Suche" Then
|
|
_Logger.Warn("windream-Dienste werden neugestartet!!")
|
|
'Neustart windream-Client
|
|
Try
|
|
Process.Start("schtasks", "/run /I /TN " & My.Settings.VFS_RESTART)
|
|
_Logger.Warn("VFS-Dienst neugestartet")
|
|
System.Threading.Thread.Sleep(7000)
|
|
Process.Start("schtasks", "/run /I /TN " & My.Settings.WMCC_RESTART)
|
|
_Logger.Warn("wmcc neugestartet")
|
|
|
|
_Logger.Warn("Restart NI wird eingeleitet - Form wird geschlossen")
|
|
NI_Restart = True
|
|
Me.Close()
|
|
Catch ex As Exception
|
|
_Logger.Warn("Fehler bei Neustart der windream Dienste: " & ex.Message)
|
|
End Try
|
|
End If
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
End Try
|
|
End Sub
|
|
Private Sub btnStartStop_Click_1(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnStartStop.Click
|
|
If TimerRefresh.Enabled = False Then
|
|
TimerRefresh.Start()
|
|
Else
|
|
TimerRefresh.Stop()
|
|
End If
|
|
If Me.btnStartStop.Text = "Nachindexierung stoppen" Then
|
|
If timRun.Enabled = True Then
|
|
timRun.Stop()
|
|
End If
|
|
Abbruch_NI("Manueller Abbruch 1 durch User " & Environment.UserName, False, False)
|
|
Me.btnStartStop.Text = "Nachindexierung starten"
|
|
Else
|
|
Me.btnStartStop.Text = "Nachindexierung stoppen"
|
|
Start_NachindexierungThreads()
|
|
End If
|
|
manuallyRun = False
|
|
End Sub
|
|
|
|
'Private Function MRGetValuesFromFile(ByVal vDatei As String, ByVal vIndexnameDA As String, ByVal vIndexnameKD As String, ByVal vindexnameDesIndex As String)
|
|
' Try
|
|
' _MRKundenKennzeichen = ""
|
|
' _MRDokumentart = _windreamNI.GetValueforIndex(vDatei.Substring(2), vIndexnameDA)
|
|
' If vIndexnameKD.ToString <> "" Then
|
|
' If vIndexnameKD = "xxxx" Then
|
|
' _MRKundenKennzeichen = "xxxx"
|
|
' Else
|
|
' _MRKundenKennzeichen = _windreamNI.GetValueforIndex(vDatei.Substring(2), vIndexnameKD)
|
|
' End If
|
|
|
|
' End If
|
|
|
|
' _Logger.Warn("Move and Rename gestartet")
|
|
' _Logger.Warn("Datum/Zeit: " & Now.Date & " " & Now.Date.ToShortTimeString)
|
|
' _Logger.Warn("Datei: " & vDatei)
|
|
' If vIndexnameKD.ToString <> "" Then
|
|
' _Logger.Warn("Indexname Kundenidentifikator: " & vIndexnameKD)
|
|
' Else
|
|
' _Logger.Info("Ein allgemeines Dokument für Move and Rename")
|
|
' End If
|
|
' If _MRKundenKennzeichen.ToString <> "" Then
|
|
' If _MRKundenKennzeichen = "xxxx" Then
|
|
' _Logger.Info("Es handelt sich um ein Allgemeines Kundenkennzeichen")
|
|
' Else
|
|
' _Logger.Info("Ausgelesener Kundenidentifikator: " & _MRKundenKennzeichen)
|
|
' End If
|
|
|
|
' End If
|
|
' _Logger.Info("Indexname Dokumentart: " & vIndexnameDA)
|
|
' _Logger.Info("Ausgelesene Dokumentart: " & _MRDokumentart)
|
|
' _Logger.Info("Indexname Deskriptiver Index: " & vindexnameDesIndex)
|
|
' _MRDeskrIndex = _windreamNI.GetValueforIndex(vDatei.Substring(2), vindexnameDesIndex)
|
|
' If _MRDeskrIndex = "" Then
|
|
' _Logger.Info("- Achtung: ein eindeutiger/deskriptiver Indexwert existiert noch nicht! Dok kann nicht verschoben und umbenannt werden!")
|
|
' _Logger.Info("Move and Rename wird abgebrochen")
|
|
' Return False
|
|
' Else
|
|
' _Logger.Info("Ausgelesener Deskriptiver Index: " & _MRDeskrIndex)
|
|
' End If
|
|
' If _MRKundenKennzeichen = "" Then
|
|
' _Logger.Info("ACHTUNG: Kundenidentifikator ist leer - Das Dokument stammt von einem Interessenten")
|
|
' _MRKundenKennzeichen = ""
|
|
' End If
|
|
|
|
' VWMO_RE_DOKUMENTARTZUORDNUNGTableAdapter.FillByDokartKD(DS_More.VWMO_RE_DOKUMENTARTZUORDNUNG, _MRDokumentart, _MRKundenKennzeichen)
|
|
' Dim _path, _praefix, _kunde, _ziel As String
|
|
' Dim DT As DataTable = DS_More.VWMO_RE_DOKUMENTARTZUORDNUNG
|
|
' If DT.Rows.Count = 1 Then
|
|
|
|
' End If
|
|
|
|
|
|
|
|
' Return MRfile_rename_move(vDatei)
|
|
' Catch ex As Exception
|
|
' ClassLoggerNI.Add(" Fehler bei: GetValuesFromFile")
|
|
' ClassLoggerNI.Add(" ###########################################################################")
|
|
' ClassLoggerNI.Add(" Fehlermeldung")
|
|
' ClassLoggerNI.Add(" " & ex.Message)
|
|
' Return False
|
|
' End Try
|
|
|
|
'End Function
|
|
'Private Function MRfile_rename_move(ByVal _file As String)
|
|
' _Logger.Info("Jetzt in Sub MRfile_rename_move")
|
|
' Try
|
|
' Dim extension As String = Path.GetExtension(_file)
|
|
|
|
' Dim myFolderPath As String
|
|
' myFolderPath = Path.GetDirectoryName(_file)
|
|
|
|
' Dim _WDLaufwerk, _newfilename As String
|
|
' _WDLaufwerk = My.Settings.MRWD_Laufwerk
|
|
' VWMO_RE_DOKUMENTARTZUORDNUNGTableAdapter.FillByDokartKD(DS_More.VWMO_RE_DOKUMENTARTZUORDNUNG, _MRDokumentart, _MRKundenKennzeichen)
|
|
' Dim _path, _praefix, _kunde, _ziel As String
|
|
' Dim DT As DataTable = DS_More.VWMO_RE_DOKUMENTARTZUORDNUNG
|
|
' If DT.Rows.Count = 1 Then
|
|
' _path = DT.Rows(0).Item("DOKUMENTARTORDNER")
|
|
' _Logger.Info("Ausgelesener Pfad: " & _path)
|
|
' _kunde = DT.Rows(0).Item("KUNDEN_NAME")
|
|
' _praefix = DT.Rows(0).Item("PRAEFIX")
|
|
' _Logger.Info("Umbennennen des Dokumentes:")
|
|
' 'Dokument kann umbenannt werden
|
|
' _newfilename = _praefix
|
|
' _Logger.Info("Ausgelesener Kurzname: " & _newfilename)
|
|
' _newfilename = _newfilename & _MRDeskrIndex & extension
|
|
' _Logger.Info("Neuer Dateiname: " & _newfilename)
|
|
|
|
' 'MsgBox("Dokart: " & _Dokumentart & vbNewLine & "KD-KZ: " & _KundenKennzeichen & vbNewLine & "PFad:" & P)
|
|
' _Logger.Info("Überprüfen file exists/Doppelter Dateiname")
|
|
' '### VERSIONIERUNG ###
|
|
' Dim version As Integer = 2
|
|
' Dim Stammname As String = _newfilename.Substring(0, _newfilename.LastIndexOf("."))
|
|
' Dim neuername As String = _newfilename.Substring(0, _newfilename.LastIndexOf("."))
|
|
' 'Überprüfen ob File existiert
|
|
' Do While file_exists(_path & "\" & neuername & extension) = True
|
|
' neuername = Stammname & "~" & version
|
|
' _newfilename = neuername & extension
|
|
' version = version + 1
|
|
' Loop
|
|
|
|
' _Logger.Info("Neuer Dateiname: " & _newfilename)
|
|
' _Logger.Info("Aktion Verschieben der Datei")
|
|
' _Logger.Info("Quelle: " & _file)
|
|
' _ziel = _path & "\" & _newfilename
|
|
' _Logger.Info("Ziel: " & _ziel)
|
|
|
|
|
|
' If myFolderPath <> _path Then
|
|
' My.Computer.FileSystem.MoveFile(_file, _ziel)
|
|
' _Logger.Info("Erfolgsmeldung - Datei wurde erfolgreich verschoben")
|
|
' 'ClassLoggerNI.Add(" ######### Erfolgsmeldung - Datei wurde erfolgreich umbenannt und verschoben ###########")
|
|
' Else
|
|
' _Logger.Info("Verschieben nicht notwendig: Ordnerpfad identisch!")
|
|
' My.Computer.FileSystem.RenameFile(_file, _newfilename)
|
|
' _Logger.Info("Erfolgsmeldung - Datei wurde erfolgreich umbenannt")
|
|
' End If
|
|
' Me.TBMO_RE_HISTORYTableAdapter.Insert(_file, _newfilename, _kunde, _MRDeskrIndex, _MRDokumentart, "ToolCollection")
|
|
|
|
|
|
|
|
' End If
|
|
|
|
|
|
' Return True
|
|
' Catch ex As Exception
|
|
' ClassLoggerNI.Add(" Fehler bei: MRfile_rename_move")
|
|
' ClassLoggerNI.Add(" ###########################################################################")
|
|
' ClassLoggerNI.Add(" Fehlermeldung")
|
|
' ClassLoggerNI.Add(" " & ex.Message)
|
|
' Return False
|
|
' End Try
|
|
'End Function
|
|
Private Function Move2Folder(ByVal vDateiName As String, ByVal vFilestring As String, pFileName As String)
|
|
Try
|
|
_Logger.Debug("Move2Folder gestartet")
|
|
Dim extension As String = Path.GetExtension(vDateiName)
|
|
Dim _Pfad, _WDLaufwerk, _Ziel As String
|
|
_Ziel = Me.aktivesProfil.move2Folder & "\" & vDateiName
|
|
_Logger.Debug("Ziel: " & _Ziel, False)
|
|
Dim Stammname As String = _Ziel.Substring(0, _Ziel.LastIndexOf("."))
|
|
Dim version As Integer = 2
|
|
Do While clsHelper.file_exists(_Ziel, "NI") = True
|
|
_Logger.Debug("Achtung: Datei existiert bereits!", False)
|
|
Dim neuername As String = Stammname & "~" & version & extension
|
|
_Ziel = neuername
|
|
version = version + 1
|
|
Loop
|
|
|
|
If _windreamNI.NEW_MOVE_FILE(_Ziel, vFilestring, "Move2Folder", pFileName) = True Then
|
|
If clsHelper.file_exists(vFilestring, "NI") = True Then
|
|
_Logger.Info("Datei existiert trotz Move noch am ursprünglichen Ort noch....wird gelöscht wenn an Ziel existiert....", False)
|
|
If clsHelper.file_exists(_Ziel, "NI") = True Then
|
|
My.Computer.FileSystem.DeleteFile(vFilestring)
|
|
_Logger.Info("Existiert und Quelldatei wurde gelöscht!", False)
|
|
End If
|
|
End If
|
|
End If
|
|
Return True
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
|
|
Return False
|
|
End Try
|
|
End Function
|
|
|
|
|
|
Private Function CrFolderForIndex(fullfilename As String, pFileName As String)
|
|
|
|
Try
|
|
fullfilename = fullfilename.Replace("W:\", "\\windream\objects\")
|
|
|
|
If My.Settings.vLogErrorsonly = False Then _Logger.Info("fullfilename: '" & fullfilename & "'")
|
|
Dim newFolder = ""
|
|
Dim RootFolder As String = Path.GetDirectoryName(fullfilename)
|
|
|
|
'######
|
|
Dim _folderArray As String()
|
|
_folderArray = aktivesProfil.CrFolderIndex.Split("\")
|
|
|
|
'Für jeden Folder die maskierung entfernen
|
|
For Each _Uordner As String In _folderArray
|
|
Dim folder_temp
|
|
If _Uordner.StartsWith("[%") Then
|
|
Dim Indexwert As String
|
|
folder_temp = _Uordner.Replace("[%", "")
|
|
folder_temp = folder_temp.Replace("]", "")
|
|
_Logger.Debug("Index für CrFolder - Ordner: '" & folder_temp & "'")
|
|
'Den Indexwert auslesen
|
|
Try
|
|
_Logger.Debug("Versuch den Indexwert aus '" & CStr(folder_temp) & "' auszulesen.")
|
|
Indexwert = aktivesDokument.GetVariableValue(folder_temp)
|
|
_Logger.Debug("Ergebnis/Wert für neuen Ordner: '" & CStr(Indexwert) & "'")
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return True
|
|
End Try
|
|
|
|
If Not Indexwert = String.Empty Then
|
|
If IsDate(Indexwert) Then
|
|
Indexwert = CDate(Indexwert).ToString("yyyyMMdd")
|
|
End If
|
|
|
|
|
|
newFolder = newFolder & Indexwert & "\"
|
|
_Logger.Debug("newFolder: '" & newFolder & "'")
|
|
Else
|
|
_Logger.Warn("Achtung Ausnahme in 'CrFolderForIndex': der Index ist leer!")
|
|
Return True
|
|
End If
|
|
End If
|
|
'Überprüfen ob es ein Variable ORdneranlage sein soll (DATUM)
|
|
If _Uordner.StartsWith("[V%") Then
|
|
Dim _Month As String = My.Computer.Clock.LocalTime.Month
|
|
If _Month.Length = 1 Then
|
|
_Month = "0" & _Month
|
|
End If
|
|
Dim _day As String = My.Computer.Clock.LocalTime.Day
|
|
If _day.Length = 1 Then
|
|
_day = "0" & _day
|
|
End If
|
|
Dim type = _Uordner.Replace("[V%", "")
|
|
type = type.Replace("]", "")
|
|
Select Case type
|
|
Case "YYYY/MM/DD"
|
|
folder_temp = My.Computer.Clock.LocalTime.Year & "\" & _Month & "\" & _day
|
|
newFolder = newFolder & folder_temp & "\"
|
|
Case "YYYY/MM"
|
|
folder_temp = My.Computer.Clock.LocalTime.Year & "\" & _Month
|
|
newFolder = newFolder & folder_temp & "\"
|
|
Case "YYYY"
|
|
folder_temp = My.Computer.Clock.LocalTime.Year
|
|
newFolder = newFolder & folder_temp & "\"
|
|
Case "YYYY-MM"
|
|
folder_temp = My.Computer.Clock.LocalTime.Year & "-" & _Month
|
|
newFolder = newFolder & folder_temp & "\"
|
|
End Select
|
|
End If
|
|
'Überprüfen ob es ein manueller Ordner ist
|
|
If _Uordner.StartsWith("[M%") Then
|
|
folder_temp = _Uordner.Replace("[M%", "")
|
|
folder_temp = folder_temp.Replace("]", "")
|
|
newFolder = newFolder & folder_temp & "\"
|
|
End If
|
|
Next
|
|
|
|
If newFolder <> "" Then
|
|
If My.Settings.vLogErrorsonly = False Then _Logger.Info("newFolder: '" & newFolder & "'")
|
|
_Logger.Debug("Den Root-Folder zusammenfügen...")
|
|
'in einem separaten Ordner anlegen
|
|
If Me.aktivesProfil.CrFolder_Folder <> "" Then
|
|
RootFolder = Me.aktivesProfil.CrFolder_Folder
|
|
_Logger.Debug("RootFolder: '" & RootFolder & "'")
|
|
End If
|
|
RootFolder = RootFolder.Replace("W:\", "\\windream\objects\")
|
|
Dim fullpath As String = RootFolder & "\" & newFolder
|
|
fullpath.Replace("\\", "\")
|
|
_Logger.Debug("Fullpath (mit evtl. Sonderzeichen (SZ)) '" & fullpath & "'", False)
|
|
Dim invalidPathChars() As Char = IO.Path.GetInvalidPathChars()
|
|
For Each sonderChar As Char In invalidPathChars
|
|
'Sonderzeichen ausser Whitespace entfernen
|
|
If Char.IsWhiteSpace(sonderChar) = False Then
|
|
If fullpath.Contains(sonderChar) Then
|
|
fullpath = fullpath.Replace(sonderChar, "")
|
|
End If
|
|
End If
|
|
Next sonderChar
|
|
If My.Settings.vLogErrorsonly = False Then _Logger.Info("Fullpath (ohne SZ) '" & fullpath & "'")
|
|
|
|
If Directory.Exists(fullpath) = False Then
|
|
Directory.CreateDirectory(fullpath)
|
|
_Logger.Debug("Folder '" & fullpath & "' wurde angelegt")
|
|
End If
|
|
aktivesProfil.CrFolder_Created_Folder = fullpath
|
|
CURRENT_MOVE_FILEPATH = fullpath
|
|
|
|
|
|
If aktivesProfil.CrFolder_Move = True Then
|
|
|
|
_Logger.Debug("Datei soll direkt auch verschoben werden.")
|
|
'Die aktuelle Datei soll gleichzeitig verschoben werden
|
|
Dim extension As String = Path.GetExtension(fullfilename)
|
|
Dim Dateiname As String = Path.GetFileName(fullfilename)
|
|
Dim _Pfad, _WDLaufwerk, oWM_Target As String
|
|
oWM_Target = fullpath & Dateiname
|
|
|
|
_Logger.Debug("Ziel: " & oWM_Target)
|
|
'Nur verschieben und überprüfen wenn Pfad ungleich
|
|
If Path.GetDirectoryName(fullfilename) <> Path.GetDirectoryName(oWM_Target) Then
|
|
Dim Stammname As String = oWM_Target.Substring(0, oWM_Target.LastIndexOf("."))
|
|
Dim version As Integer = 2
|
|
Do While clsHelper.file_exists(oWM_Target, "NI") = True
|
|
version = version + 1
|
|
_Logger.Info("Achtung: Datei ' " & Path.GetFileName(oWM_Target) & "' existiert bereits!")
|
|
Dim neuername As String = Stammname & "~" & version & extension
|
|
oWM_Target = neuername
|
|
Loop
|
|
|
|
_windreamNI.NEW_MOVE_FILE(oWM_Target, fullfilename, "FolderForIndex", pFileName)
|
|
Else
|
|
_Logger.Info("(CrFolderForIndex) Quell- und Zielordner identisch")
|
|
If Path.GetFileName(fullfilename) <> Path.GetFileName(oWM_Target) And File.Exists(oWM_Target) Then
|
|
_Logger.Warn("(CrFolderForIndex) Quell- und Zielname nicht identisch")
|
|
Dim sw As New ClassStopwatch("FileSystem.Rename")
|
|
FileSystem.Rename(oWM_Target, Path.GetDirectoryName(oWM_Target) & Path.GetFileName(fullfilename))
|
|
_Logger.Info($"Datei {Path.GetFileName(oWM_Target)} wurde nach CrFolderIndex-Methode umbenannt")
|
|
Dim msg = sw.Done
|
|
If msg <> String.Empty Then _Logger.Info(msg)
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
Return False
|
|
Else
|
|
_Logger.Warn("Achtung es konnte kein dynamischer Pfad generiert werden!")
|
|
Return True
|
|
End If
|
|
|
|
Catch ex As Exception
|
|
_Logger.Error(ex)
|
|
Return True
|
|
End Try
|
|
End Function
|
|
|
|
Private Sub TimerRefresh_Tick(sender As Object, e As EventArgs) Handles TimerRefresh.Tick
|
|
If CURRENT_STATE <> "" Then
|
|
Select Case CURRENT_STATE
|
|
Case "Abbruch Timeout"
|
|
Me.lblStatus.Text = "(Status: WARTEN nach Abbruch durch Timeout.)"
|
|
Me.tslblStatus.Visible = True
|
|
tslblStatus.Text = "Status: WARTEN nach Abbruch durch Timeout"
|
|
CURRENT_STATE = ""
|
|
End Select
|
|
|
|
End If
|
|
End Sub
|
|
End Class |