715 lines
31 KiB
VB.net
715 lines
31 KiB
VB.net
Imports System.IO
|
|
Imports System.Text.RegularExpressions
|
|
Imports DigitalData.Modules.Logging
|
|
Imports DigitalData.Modules.Language
|
|
Imports MultiTool.Common.Exceptions
|
|
Imports MultiTool.Common.Templates
|
|
Imports MultiTool.Common.Winline
|
|
Imports MultiTool.Common.Winline.Entities
|
|
Imports MultiTool.Common.Constants
|
|
Imports DigitalData.Modules.Database
|
|
|
|
Namespace Documents
|
|
Public Class DocumentLoader
|
|
Inherits BaseClass
|
|
|
|
Private ReadOnly Winline As WinlineData
|
|
Private ReadOnly MappingConfig As MappingConfig
|
|
Private ReadOnly TemplateConfig As TemplateConfig
|
|
Private ReadOnly ApplicationConfig As Config
|
|
Private ReadOnly Patterns As Patterns
|
|
|
|
Public Property Files As New List(Of Document)
|
|
|
|
Public Property FilesTotal As Integer = 0
|
|
Public Property FilesLoaded As Integer = 0
|
|
|
|
Public Event FileLoadComplete As EventHandler(Of FileLoadInfo)
|
|
Public Event FileLoadProgress As EventHandler(Of FileLoadProgressInfo)
|
|
|
|
Public Class FileLoadInfo
|
|
Public FilesLoaded As Integer
|
|
Public FilesTotal As Integer
|
|
|
|
Public Sub New(pTotal As Integer, pLoaded As Integer)
|
|
FilesTotal = pTotal
|
|
FilesLoaded = pLoaded
|
|
End Sub
|
|
End Class
|
|
|
|
Public Class FileLoadProgressInfo
|
|
Inherits FileLoadInfo
|
|
|
|
Public RunningFunction As String
|
|
|
|
Public Sub New(pTotal As Integer, pLoaded As Integer)
|
|
MyBase.New(pTotal, pLoaded)
|
|
End Sub
|
|
End Class
|
|
|
|
Public Sub New(pLogConfig As LogConfig, pWinline As WinlineData, pDatabase As MSSQLServer, pMappingConfig As MappingConfig, pTemplateConfig As TemplateConfig, pGeneralConfig As GeneralConfig, pApplicationConfig As Config)
|
|
MyBase.New(pLogConfig, pDatabase)
|
|
Winline = pWinline
|
|
MappingConfig = pMappingConfig
|
|
TemplateConfig = pTemplateConfig
|
|
ApplicationConfig = pApplicationConfig
|
|
Patterns = New Patterns(pLogConfig, pGeneralConfig)
|
|
End Sub
|
|
|
|
Public Async Function LoadFiles(pTemplate As Template, pMandator As Mandator) As Task(Of Boolean)
|
|
Logger.Info("Loading files from directory [{0}]", pTemplate.InputDirectory)
|
|
Files.Clear()
|
|
|
|
Try
|
|
Dim oDirectory As New DirectoryInfo(pTemplate.InputDirectory)
|
|
Dim oFiles = oDirectory.GetFiles()
|
|
FilesTotal = oFiles.Count
|
|
|
|
Logger.Debug("Found [{0}] files in directory [{1}]", oFiles.Count, oDirectory)
|
|
|
|
For Each oFile In oFiles
|
|
Logger.Info("Loading file [{0}]", oFile.Name)
|
|
Dim oDocument = Await LoadFile(oFile, pTemplate, pMandator)
|
|
Files.Add(oDocument)
|
|
FilesLoaded = Files.Count
|
|
|
|
Dim oInfo As New FileLoadInfo(FilesTotal, FilesLoaded)
|
|
RaiseEvent FileLoadComplete(Me, oInfo)
|
|
Next
|
|
|
|
Return True
|
|
|
|
Catch ex As Exception
|
|
Logger.Error(ex)
|
|
Throw ex
|
|
|
|
End Try
|
|
End Function
|
|
|
|
Public Async Function LoadFile(pFileInfo As FileInfo, pTemplate As Template, pMandator As Mandator) As Task(Of Document)
|
|
Logger.Debug("Creating new Document object for file [{0}]", pFileInfo.Name)
|
|
Dim oDocument As Document = New Document With {
|
|
.File = pFileInfo,
|
|
.Schema = pTemplate
|
|
}
|
|
|
|
Try
|
|
oDocument = LoadDocumentData(oDocument, pTemplate, TemplateConfig)
|
|
|
|
Catch ex As Exception
|
|
Throw ex
|
|
Logger.Error(ex)
|
|
|
|
End Try
|
|
|
|
Try
|
|
oDocument = Await MatchDataFromWinLine(oDocument, Winline.Mandators, pMandator, pTemplate)
|
|
|
|
Catch ex As Exception
|
|
Throw ex
|
|
Logger.Error(ex)
|
|
|
|
End Try
|
|
|
|
Try
|
|
oDocument = MarkRequiredFields(oDocument)
|
|
|
|
Catch ex As Exception
|
|
Throw ex
|
|
Logger.Error(ex)
|
|
|
|
End Try
|
|
|
|
Return oDocument
|
|
End Function
|
|
|
|
Public Function MarkRequiredFields(pDocument As Document) As Document
|
|
For Each oRow In pDocument.Rows
|
|
For Each oField In oRow.Fields
|
|
If oField.Value.Final = String.Empty And oField.Value.IsRequired Then
|
|
oField.Value.AddFieldError(FieldErrorType.MissingValue, $"Attribut '{oField.Key}' ist ein Pflichtfeld, wurde aber nicht gefüllt.")
|
|
End If
|
|
Next
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Public Sub ReplaceDocument(pDocument As Document)
|
|
Dim oIndex = Files.IndexOf(pDocument)
|
|
Files.Item(oIndex) = pDocument
|
|
End Sub
|
|
|
|
|
|
Private Function IncludeSchema(pDocument As Document, pTemplate As Template) As Document
|
|
Logger.Debug("Adding schema to Document object.")
|
|
pDocument.Schema = pTemplate
|
|
Return pDocument
|
|
End Function
|
|
|
|
|
|
''' <summary>
|
|
''' Loads a single document from the FullName Property in the Document Object
|
|
''' </summary>
|
|
''' <example>
|
|
''' A document might look like this:
|
|
''' <MESOWebService>
|
|
''' <Row1></Row1>
|
|
''' <Row2></Row2>
|
|
''' <Row3></Row3>
|
|
''' </MESOWebService>
|
|
''' </example>
|
|
Private Function LoadDocumentData(pDocument As Document, pTemplate As Template, pTemplateConfig As TemplateConfig) As Document
|
|
Logger.Debug("Loading file contents")
|
|
|
|
Dim oText As String
|
|
Dim oDoc As XDocument
|
|
|
|
Try
|
|
Logger.Debug("Loading file from fs..")
|
|
oText = IO.File.ReadAllText(pDocument.FullName)
|
|
|
|
Logger.Debug("Parsing file..")
|
|
oDoc = XDocument.Parse(oText)
|
|
Catch ex As Exception
|
|
Logger.Error(ex)
|
|
Throw ex
|
|
End Try
|
|
|
|
Logger.Debug("File Loaded.")
|
|
|
|
Dim oRootElement As XElement = XmlData.GetElement(oDoc, "MESOWebService")
|
|
If oRootElement Is Nothing Then
|
|
pDocument.AddDocumentError(DocumentErrorType.MissingXmlAttribute, "Datei enthält kein MESOWebService-Attribut")
|
|
End If
|
|
|
|
Dim oTemplateName = XmlData.GetElementAttribute(oRootElement, "Template")
|
|
If oTemplateName Is Nothing Then
|
|
pDocument.AddDocumentError(DocumentErrorType.MissingXmlAttribute, "Datei enthält kein Template-Attribut")
|
|
End If
|
|
|
|
Dim oTemplateType = XmlData.GetElementAttribute(oRootElement, "TemplateType")
|
|
If oTemplateType Is Nothing Then
|
|
pDocument.AddDocumentError(DocumentErrorType.MissingXmlAttribute, "Datei enthält kein TemplateType-Attribut")
|
|
End If
|
|
|
|
Dim oOption = XmlData.GetElementAttribute(oRootElement, "option")
|
|
If oOption Is Nothing Then
|
|
pDocument.AddDocumentError(DocumentErrorType.MissingXmlAttribute, "Datei enthält kein option-Attribut")
|
|
End If
|
|
|
|
Dim oPrintVoucher = XmlData.GetElementAttribute(oRootElement, "printVoucher")
|
|
If oPrintVoucher Is Nothing Then
|
|
pDocument.AddDocumentError(DocumentErrorType.MissingXmlAttribute, "Datei enthält kein printVoucher-Attribut")
|
|
End If
|
|
|
|
' The first level of Elements are the document Rows
|
|
Dim oTopLevelElements As List(Of XElement) = oRootElement.Elements.ToList
|
|
Dim oDocumentRows As New List(Of DocumentRow)
|
|
Dim oRowSortKey As Integer = 0
|
|
|
|
' TODO: Somehow add all fields in the correct order
|
|
'
|
|
' Right now, the method of
|
|
' - first the filled field from xml
|
|
' - then the rest from schema
|
|
'
|
|
' leads to unordered fields.
|
|
For Each oTopLevelElement As XElement In oTopLevelElements
|
|
Dim oColumnSortKey = 0
|
|
Dim oFields As New Dictionary(Of String, DocumentRow.FieldValue)
|
|
Dim oSubElements = oTopLevelElement.Descendants().ToList()
|
|
Dim oTable = pTemplate.Tables.
|
|
Where(Function(t) t.Name = oTopLevelElement.Name).
|
|
FirstOrDefault()
|
|
|
|
Logger.Debug("Creating fields from [{0}] columns for Table [{1}]", oTable.Columns.Count, oTable.Name)
|
|
|
|
For Each oColumn In oTable.Columns
|
|
Dim oSubElement = oSubElements.
|
|
Where(Function(e) e.Name = oColumn.Name).
|
|
SingleOrDefault()
|
|
|
|
If oSubElement IsNot Nothing Then
|
|
Dim oRequired = oColumn.IsRequired
|
|
Dim oValue = oSubElement.Value.Trim()
|
|
|
|
Logger.Debug("Creating existing field from Element: [{0}]", oSubElement.Name.ToString)
|
|
|
|
' TODO: Needed when we have time for date times
|
|
'If oTemplateField.DataType = Constants.ColumnType.Date Then
|
|
' Dim oDate = Date.ParseExact(oValue, "yyyy-MM-dd", CultureInfo.InvariantCulture)
|
|
' oValue = oDate.ToString("d")
|
|
'End If
|
|
|
|
Dim oFieldValue = GetFieldValueFromColumn(oColumn, oColumnSortKey)
|
|
oFieldValue.SetOriginalValue(oValue)
|
|
|
|
oFields.Add(oSubElement.Name.ToString, oFieldValue)
|
|
Else
|
|
Logger.Debug("Creating new field from Configuration: [{0}]", oColumn.Name)
|
|
|
|
Dim oFieldValue = GetFieldValueFromColumn(oColumn, oColumnSortKey)
|
|
|
|
If oColumn.Config?.IsRequired Then
|
|
oFieldValue.AddFieldError(FieldErrorType.MissingValue, $"Attribut {oSubElement.Name} wird benötigt, ist aber nicht gefüllt.")
|
|
End If
|
|
|
|
oFields.Add(oColumn.Name, oFieldValue)
|
|
End If
|
|
|
|
oColumnSortKey += 1
|
|
Next
|
|
|
|
' Create a DocumentRow object for each Top Level Element
|
|
Dim oRow = New DocumentRow With {
|
|
.SortKey = oRowSortKey,
|
|
.TableName = oTopLevelElement.Name.ToString,
|
|
.Fields = oFields
|
|
}
|
|
|
|
oRowSortKey += 1
|
|
oDocumentRows.Add(oRow)
|
|
Next
|
|
|
|
' Update the document
|
|
pDocument.TemplateName = oTemplateName
|
|
pDocument.TemplateType = oTemplateType
|
|
pDocument.Option = oOption
|
|
pDocument.PrintVoucher = oPrintVoucher
|
|
pDocument.Rows = oDocumentRows
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Public Function GetFieldValueFromColumn(pColumn As Template.Column, pSortKey As Integer) As DocumentRow.FieldValue
|
|
Return New DocumentRow.FieldValue(LogConfig) With {
|
|
.DataType = pColumn.DataType,
|
|
.IsRequired = pColumn.IsRequired,
|
|
.IsVirtual = pColumn.Config.IsVirtual,
|
|
.PreferExternalValue = pColumn.Config.PreferExternalValue,
|
|
.SortKey = pSortKey
|
|
}
|
|
End Function
|
|
|
|
|
|
Private Async Function MatchDataFromWinLine(pDocument As Document, pMandators As List(Of Mandator), pMandator As Mandator, pTemplate As Template) As Task(Of Document)
|
|
Dim oMandators As List(Of Mandator) = pMandators.
|
|
Where(Function(m) m.IsWhitelisted = True).
|
|
OrderBy(Function(m) m.Order).
|
|
ToList()
|
|
|
|
Dim oInfo As New FileLoadProgressInfo(FilesTotal, FilesLoaded) With {.RunningFunction = "Mandant finden"}
|
|
RaiseEvent FileLoadProgress(Me, oInfo)
|
|
|
|
Dim oMandator As Mandator = Nothing
|
|
If pMandator IsNot Nothing Then
|
|
oMandator = pMandator
|
|
Else
|
|
oMandator = Winline.FindMatchingMandatorFromOrder(pDocument)
|
|
End If
|
|
|
|
If oMandator Is Nothing Then
|
|
Logger.Warn("Mandator not found for File [{0}]", pDocument.File.Name)
|
|
|
|
' Without mandator, we just exit, life is meaningless.
|
|
pDocument.AddDocumentError(DocumentErrorType.MandatorNotFound, "Mandant nicht gefunden. Verarbeitung wurde abgebrochen.")
|
|
Else
|
|
' Set mandator befor applying any functions that depend on a valid mandator
|
|
pDocument.Mandator = oMandator
|
|
|
|
RaiseEvent FileLoadProgress(Me, New FileLoadProgressInfo(FilesTotal, FilesLoaded) With {.RunningFunction = "Winline-Funktionen"})
|
|
|
|
pDocument = Await ApplyDefinedItemFunctionsForImportAsync(pDocument, oMandator, pTemplate)
|
|
pDocument = ApplyDynamicItemFunctionsForImport(pDocument, oMandator)
|
|
|
|
RaiseEvent FileLoadProgress(Me, New FileLoadProgressInfo(FilesTotal, FilesLoaded) With {.RunningFunction = "Preis-Funktionen"})
|
|
|
|
If ApplicationConfig.AutomaticPriceCalculation = True Then
|
|
' These functions will only be applied if the document does not have errors
|
|
pDocument = Await MaybeApplyPriceFunctions(pDocument, oMandator, pTemplate)
|
|
End If
|
|
|
|
RaiseEvent FileLoadProgress(Me, New FileLoadProgressInfo(FilesTotal, FilesLoaded) With {.RunningFunction = "Feld-Funktionen"})
|
|
|
|
|
|
pDocument = ApplySQLFunctionForImport(pDocument, TemplateConfig.SqlItems)
|
|
|
|
' This function needs to be the last one because
|
|
' it can relate to any previously set value
|
|
pDocument = ApplyFieldFunctionForImport(pDocument, oMandator, pTemplate)
|
|
End If
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Private Function ApplySQLFunctionForImport(pDocument As Document, pSQLConfig As List(Of FieldConfig)) As Document
|
|
For Each oSQLConfigItem In pSQLConfig
|
|
' FieldList is a list of fields that will be changed
|
|
' Example: Setting SQL for Article StorageLocation will invoke the sql for each row
|
|
Dim oRowList = pDocument.Rows.
|
|
Where(Function(row) row.Fields.Any(Function(field) field.Key = oSQLConfigItem.Name)).
|
|
ToList()
|
|
|
|
For Each oRow As DocumentRow In oRowList
|
|
Dim oSQL = oSQLConfigItem.Function.Params
|
|
Dim oField = oRow.Fields.
|
|
Where(Function(field) field.Key = oSQLConfigItem.Name).
|
|
SingleOrDefault()
|
|
|
|
oSQL = Patterns.ReplaceForImport(pDocument, oRow, oSQL)
|
|
|
|
Dim oValue = Database.GetScalarValue(oSQL)
|
|
|
|
If oValue IsNot Nothing Then
|
|
oField.Value.SetExternalValue(oValue)
|
|
End If
|
|
Next
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
|
|
''' <summary>
|
|
''' Apply price calculation to the documents products
|
|
'''
|
|
''' This needs to be strictly seperated from `ApplyDefinedItemFunctionsForImport`
|
|
''' because prices can only be calculated if GLN and EAN functions were already (successfully) processed
|
|
''' </summary>
|
|
Public Async Function MaybeApplyPriceFunctions(pDocument As Document, pMandator As Mandator, pTemplate As Template) As Task(Of Document)
|
|
If pDocument.HasErrors Then
|
|
Return pDocument
|
|
End If
|
|
|
|
For Each oRow As DocumentRow In pDocument.Rows
|
|
Dim oTable = pTemplate.Tables.Where(Function(table) table.Name = oRow.TableName).SingleOrDefault()
|
|
|
|
For Each oField In oRow.Fields
|
|
If oTable Is Nothing Then
|
|
Exit For
|
|
End If
|
|
|
|
Dim oColumn = oTable.Columns.Where(Function(c) c.Name = oField.Key).SingleOrDefault()
|
|
If oColumn Is Nothing Then
|
|
Continue For
|
|
End If
|
|
|
|
Dim oFunctionName = oColumn.Config.FunctionName
|
|
Dim oFunctionParams = oColumn.Config.FunctionParams
|
|
|
|
Logger.Debug("Running Function: [{0}]", oFunctionName)
|
|
Logger.Debug("With Parameters: [{0}]", oFunctionParams)
|
|
|
|
Dim oParamsDict = ParseFunctionParamsAsDict(oFunctionParams)
|
|
|
|
If oFunctionName = Constants.FUNCTION_PRICE Then
|
|
Await SetPrice(oRow, oField.Key, oParamsDict, pDocument, pMandator, pTemplate)
|
|
End If
|
|
Next
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Private Async Function ApplyDefinedItemFunctionsForImportAsync(pDocument As Document, pMandator As Mandator, pTemplate As Template) As Task(Of Document)
|
|
For Each oRow As DocumentRow In pDocument.Rows
|
|
Dim oTable = pTemplate.Tables.Where(Function(table) table.Name = oRow.TableName).SingleOrDefault()
|
|
|
|
For Each oField In oRow.Fields
|
|
If oTable Is Nothing Then
|
|
Exit For
|
|
End If
|
|
|
|
Dim oColumn = oTable.Columns.Where(Function(c) c.Name = oField.Key).SingleOrDefault()
|
|
If oColumn Is Nothing Then
|
|
Continue For
|
|
End If
|
|
|
|
Dim oFunctionName = oColumn.Config.FunctionName
|
|
Dim oFunctionParams = oColumn.Config.FunctionParams
|
|
Dim oParamsDict = ParseFunctionParamsAsDict(oFunctionParams)
|
|
|
|
If oFunctionName = FUNCTION_GLN Then
|
|
SetAccountByGLN(oRow, pMandator, oField.Key, Nothing, oParamsDict)
|
|
End If
|
|
|
|
If oFunctionName = FUNCTION_EAN Then
|
|
SetArticleByEAN(oRow, pMandator, oField.Key)
|
|
End If
|
|
|
|
If oFunctionName = FUNCTION_RUNNINGNUMBER Then
|
|
Await SetVersionedRunningNumber(pDocument, oRow, pMandator, oField.Key, oParamsDict)
|
|
End If
|
|
|
|
Next
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Private Function ApplyFieldFunctionForImport(pDocument As Document, pMandator As Mandator, pTemplate As Template) As Document
|
|
For Each oRow As DocumentRow In pDocument.Rows
|
|
Dim oTable = pDocument.Schema.Tables.Where(Function(table) table.Name = oRow.TableName).SingleOrDefault()
|
|
|
|
For Each oField In oRow.Fields
|
|
If oTable Is Nothing Then
|
|
Logger.Warn("Table [{0}] was not found in the Schema. Exiting.", oRow.TableName)
|
|
Exit For
|
|
|
|
End If
|
|
|
|
Dim oColumn = oTable.Columns.Where(Function(c) c.Name = oField.Key).SingleOrDefault()
|
|
If oColumn Is Nothing Then
|
|
Logger.Warn("Column [{0}] was not found in Table [{0}]. Skipping.", oField.Key, oTable.Name)
|
|
Continue For
|
|
|
|
End If
|
|
|
|
Dim oFunctionName = oColumn.Config.FunctionName
|
|
Dim oFunctionParams = oColumn.Config.FunctionParams
|
|
Dim oParamsDict = ParseFunctionParamsAsDict(oFunctionParams)
|
|
|
|
If oFunctionName = Constants.FUNCTION_FIELD Then
|
|
Try
|
|
Logger.Debug("Applying function FIELD to field [{0}]", oField.Key)
|
|
|
|
Dim oParam = oParamsDict.FirstOrDefault()
|
|
|
|
If IsNothing(oParam) Then
|
|
Logger.Warn("Function FIELD needs exactly one parameter. Skipping")
|
|
Continue For
|
|
|
|
End If
|
|
|
|
Dim oFieldName = oParam.Key
|
|
Dim oSubKey = oParam.Value
|
|
|
|
Dim oReferencedField = oRow.Fields.
|
|
Where(Function(field) field.Key = oFieldName).
|
|
FirstOrDefault()
|
|
|
|
If IsNothing(oReferencedField) = False Then
|
|
Dim oRawValue = oReferencedField.Value?.GetValue(oSubKey)
|
|
Dim oValue As String = Utils.NotNull(oRawValue, String.Empty)
|
|
|
|
If oValue <> String.Empty Then
|
|
oField.Value.SetExternalValue(oValue)
|
|
End If
|
|
|
|
Else
|
|
Logger.Warn("Referenced Field [{0}] was not found. Skipping.", oFieldName)
|
|
Continue For
|
|
|
|
End If
|
|
Catch ex As Exception
|
|
Logger.Warn("Function FIELD could not be applied to field [{0}]. Skipping.", oField.Key)
|
|
Continue For
|
|
|
|
End Try
|
|
End If
|
|
Next
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
''' <summary>
|
|
''' Execute Mappings defined in TBMT_MAPPING_CONFIG,
|
|
''' for example mapping Article Numbers to Winline Mandators
|
|
''' </summary>
|
|
Private Function ApplyDynamicItemFunctionsForImport(pDocument As Document, pMandator As Mandator) As Document
|
|
' We only want the mapping config for things in the xml file.
|
|
' that excludes things like setting the mandator.
|
|
Dim oFilteredMappingConfig = MappingConfig.Items.
|
|
Where(Function(item) item.DestinationItem <> String.Empty).
|
|
ToList()
|
|
|
|
For Each oMapping As MappingConfigItem In oFilteredMappingConfig
|
|
|
|
' Get Source Value
|
|
Dim oField As KeyValuePair(Of String, DocumentRow.FieldValue) = pDocument.Rows.
|
|
SelectMany(Function(row) row.Fields).
|
|
Where(Function(field) field.Key = oMapping.SourceItem).
|
|
FirstOrDefault()
|
|
|
|
' Test on Regex
|
|
Dim oRegex As New Regex(oMapping.SourceRegex)
|
|
|
|
If oRegex.IsMatch(oField.Value.Final) Then
|
|
|
|
pDocument.Rows.
|
|
SelectMany(Function(row) row.Fields).
|
|
Where(Function(field) field.Key = oMapping.DestinationItem).
|
|
SetValue(Sub(field) field.Value.SetExternalValue(oMapping.DestinationValue))
|
|
|
|
Else
|
|
' don't do anything
|
|
|
|
End If
|
|
Next
|
|
|
|
Return pDocument
|
|
End Function
|
|
|
|
Private Async Function SetPrice(pRow As DocumentRow, pPriceField As String, pParamMap As Dictionary(Of String, String), pDocument As Document, pMandator As Mandator, pTemplate As Template) As Task
|
|
Dim oPriceItem As DocumentRow.FieldValue = pRow.Fields.GetOrDefault(pPriceField)
|
|
|
|
' These fields are fetched from the current row
|
|
Const PARAMETER_ARTICLE = "Article"
|
|
Dim oArticleNumberField As String = pParamMap.GetOrDefault(PARAMETER_ARTICLE, Nothing)
|
|
If oArticleNumberField Is Nothing Then
|
|
Logger.Warn("Parameter '{0}' not found for Function PRICE", PARAMETER_ARTICLE)
|
|
End If
|
|
|
|
If pRow.Fields.ContainsKey(oArticleNumberField) = False Then
|
|
Logger.Warn("Value '{0}' for Parameter '{1}' not found for Function PRICE", oArticleNumberField, PARAMETER_ARTICLE)
|
|
End If
|
|
Dim oArticleNumber As String = pRow.Fields.Item(oArticleNumberField).Final
|
|
|
|
Const PARAMETER_QUANTITY = "Quantity"
|
|
Dim oQuantityField As String = pParamMap.GetOrDefault(PARAMETER_QUANTITY, Nothing)
|
|
If oQuantityField Is Nothing Then
|
|
Logger.Warn("Parameter '{0}' not found for Function PRICE", PARAMETER_QUANTITY)
|
|
End If
|
|
|
|
Dim oQuantity As Integer = 1
|
|
If Integer.TryParse(pRow.Fields.Item(oQuantityField).Final, oQuantity) = False Then
|
|
Logger.Warn("Value for parameter '{0}' could not be parsed. Setting to 1.", PARAMETER_QUANTITY)
|
|
End If
|
|
|
|
' These fields a fetched from the head row, ie. the first row
|
|
Dim oAccountNumberField As String = pParamMap.GetOrDefault("Account", Nothing)
|
|
Dim oAccountNumber = pDocument.GetFieldValue(oAccountNumberField)
|
|
|
|
Dim oDocumentDateField As String = pParamMap.GetOrDefault("DocumentDate", Nothing)
|
|
Dim oDocumentDate = pDocument.GetFieldValue(oDocumentDateField)
|
|
|
|
Dim oDocumentKindField As String = pParamMap.GetOrDefault("DocumentKind", Nothing)
|
|
Dim oDocumentKind As Integer = 0
|
|
If Integer.TryParse(pDocument.GetFieldValue(oDocumentKindField), oDocumentKind) = False Then
|
|
Logger.Warn("Value for parameter DocumentKind could not be parsed. Setting to 0.")
|
|
End If
|
|
|
|
' TODO: Add Field Names as Constants
|
|
' TODO: Check for missing values
|
|
|
|
' TODO: This function should not be hardcoded, but be replaced with virtual field or something..
|
|
' It is related to customer SCHAUM and nothing general
|
|
Dim oWaitingDays As Integer = Await Winline.TryGetWaitingDaysAsync(oDocumentKind, pMandator)
|
|
' END TODO
|
|
|
|
Dim oArticlePrice As Double = Await Winline.TryGetArticlePriceAsync(oArticleNumber, oAccountNumber, oQuantity, oDocumentDate, pMandator, pTemplate, oWaitingDays)
|
|
|
|
If oArticlePrice > 0 Then
|
|
oPriceItem.SetExternalValue(oArticlePrice)
|
|
Logger.Info("Price for Item [{0}] set to [{1}]", pPriceField, oArticlePrice)
|
|
Else
|
|
Logger.Warn("Price for Item [{0}] could not be found!", pPriceField)
|
|
End If
|
|
End Function
|
|
|
|
Private Sub SetArticleByEAN(pRow As DocumentRow, pMandator As Mandator, pArticleField As String)
|
|
Dim oNumberItem As DocumentRow.FieldValue = pRow.Fields.GetOrDefault(pArticleField)
|
|
Dim oArticleNumber = Winline.TryGetArticleNumber(oNumberItem.Original, pMandator)
|
|
|
|
If oArticleNumber IsNot Nothing Then
|
|
oNumberItem.SetExternalValue(oArticleNumber)
|
|
Logger.Info("EAN [{0}] resolved to ArticleNumber [{1}]", oNumberItem.Original, oArticleNumber)
|
|
Else
|
|
oNumberItem.AddFieldError(FieldErrorType.ArticleNotFound, $"EAN in Attribut '{pArticleField}' konnte nicht aufgelöst werden.")
|
|
Logger.Warn("EAN [{0}] could not be resolved ArticleNumber", oNumberItem.Original)
|
|
End If
|
|
End Sub
|
|
|
|
Private Sub SetAccountByGLN(oRow As DocumentRow, pMandator As Mandator, pNumberField As String, pNameField As String, pParams As Dictionary(Of String, String))
|
|
Try
|
|
' Try to read the Account number (which is a GLN really) and account Name
|
|
Dim oNumberItem As DocumentRow.FieldValue = oRow.Fields.GetOrDefault(pNumberField)
|
|
Dim oNameItem As DocumentRow.FieldValue = oRow.Fields.GetOrDefault(pNameField)
|
|
Dim oContainsAccountName As Boolean = Not IsNothing(oNameItem)
|
|
|
|
If oNumberItem Is Nothing Then
|
|
Exit Sub
|
|
End If
|
|
|
|
' Try to find an account that matches the GLN
|
|
Dim oAlternateField = pParams.GetOrDefault("AltField", String.Empty)
|
|
Dim oAccount = Winline.TryGetAccount(oNumberItem.Original, pMandator, "c260", oAlternateField)
|
|
|
|
' If an account was found, set it for External and Final value
|
|
If oAccount IsNot Nothing Then
|
|
oNumberItem.SetExternalValue(oAccount.Id)
|
|
|
|
If oContainsAccountName Then
|
|
oNameItem.SetExternalValue(oAccount.Name)
|
|
Else
|
|
' TODO: What to to if name field is missing or not set?
|
|
'oRow.Fields.Add(pNameField, New DocumentRow.FieldValue() With {
|
|
' .External = oAccount.Name,
|
|
' .Final = oAccount.Name
|
|
'})
|
|
End If
|
|
Else
|
|
' If no account was found and the field is required,
|
|
' mark it as error. Otherwise, do nothing.
|
|
If oNumberItem.IsRequired Then
|
|
'oNumberItem.Error = FieldErrorType.AccountNotFound
|
|
oNumberItem.AddFieldError(FieldErrorType.AccountNotFound, $"GLN in Attribut '{pNumberField}' konnte nicht aufgelöst werden.")
|
|
End If
|
|
End If
|
|
Catch ex As Exception
|
|
Logger.Error(ex)
|
|
Throw ex
|
|
End Try
|
|
End Sub
|
|
|
|
Public Async Function SetVersionedRunningNumber(pDocument As Document, pRow As DocumentRow, pMandator As Mandator, pRunningNumberField As String, pParams As Dictionary(Of String, String)) As Task
|
|
Try
|
|
Const PARAMETER_ACCOUNT = "Account"
|
|
Dim oAccountField As String = pParams.GetOrDefault(PARAMETER_ACCOUNT, Nothing)
|
|
If oAccountField Is Nothing Then
|
|
Logger.Warn("Parameter '{0}' not found for Function RUNNINGNUMBER", PARAMETER_ACCOUNT)
|
|
End If
|
|
|
|
Dim oRunningNumberItem As DocumentRow.FieldValue = pRow.Fields.GetOrDefault(pRunningNumberField)
|
|
Dim oRunningNumber = oRunningNumberItem.Final
|
|
|
|
Dim oAccountNumberItem As DocumentRow.FieldValue = pRow.Fields.GetOrDefault(oAccountField)
|
|
Dim oAccountNumber = oAccountNumberItem.Final
|
|
|
|
Dim oVersionedNumber = Await Winline.GetVersionedRunningNumberAsync(pDocument, pMandator, oAccountNumber, oRunningNumber)
|
|
|
|
If oVersionedNumber <> oRunningNumber Then
|
|
oRunningNumberItem.SetExternalValue(oVersionedNumber)
|
|
End If
|
|
|
|
Catch ex As Exception
|
|
Logger.Error(ex)
|
|
Throw ex
|
|
End Try
|
|
End Function
|
|
|
|
Private Function ParseFunctionParamsAsDict(pParams As String) As Dictionary(Of String, String)
|
|
Try
|
|
Dim oParamsDict As New Dictionary(Of String, String)
|
|
|
|
If pParams <> String.Empty Then
|
|
Dim oParamList = pParams.Split("|").ToList()
|
|
For Each oParam In oParamList
|
|
Dim oParamSplit = oParam.Split("=")
|
|
If oParamSplit.Count = 2 Then
|
|
oParamsDict.Add(oParamSplit(0), oParamSplit(1))
|
|
End If
|
|
Next
|
|
End If
|
|
|
|
Return oParamsDict
|
|
Catch ex As Exception
|
|
Logger.Error(ex)
|
|
Return New Dictionary(Of String, String)
|
|
End Try
|
|
End Function
|
|
End Class
|
|
|
|
End Namespace |