Weedu

1.0.0.40

PersonenImport.psm1


$Script:PersonenInfo;
$Script:PersonenmappingListe;
$Script:PersonenmappingSplitListe;


function Invoke-PersonenImport {
param (
    [Parameter(Mandatory, HelpMessage = "Liste der zu importierenden Parametern")]
    $parameterObject
)
process {
    $KomMittelTypes = @("festnetznummer", "mobilenummer", "faxnummer","emailadresse", "wwwadresse", "postadresse");

    $row = @{};
    $Script:PersonenInfo = @{};
    $Script:PersonenmappingListe = @{};
    $Script:PersonenmappingSplitListe = @{};
    $parameterObject.psobject.properties | Foreach { $row[$_.Name] = $_.Value };

     $Person = [PSCustomObject]@{};    
    $KomMittelListe = @{};
    $AnmeldungListe = @{};
    $RechnungssplitListe = @{};
    $TagListe = @{};

    [string]$Id = $row["Id"];
    $Gruppe = $row["Sicherheitsgruppe"];

    if ($Id -eq $null -or $Gruppe -eq $null) {
        Write-Error "Sicherheitsgruppe und Id sind erforderlich";
        return;
    }
    
    $Script:PersonenInfo = Invoke-BuildPersonUid -Gruppe $Gruppe -Id $Id;
    $Sicherheitseinstellung = New-Sicherheitseinstellung-Object $Gruppe;

    foreach ($key in $row.keys) {
        $elements = $key.Split('_');
        if ($elements.Count -gt 1) {
            $name = $elements[2];
            $type = $elements[0] + "_" + $elements[1];
        }

        if ($elements.Count -eq 1) {
            $Person | Add-Member -MemberType NoteProperty -Name $key -Value $row[$key];
        }
        elseif ($KomMittelTypes.Contains($elements[0].ToLower())) {
            if (-not $KomMittelListe[$type]) {
                $KomMittelListe[$type] =  [PSCustomObject]@{};
            }
            $KomMittelListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $row[$key];
        }
        elseif ($elements[0] -eq "anmeldung") {
            if (-not $AnmeldungListe[$type]) {
                $AnmeldungListe[$type] =  [PSCustomObject]@{};
            }
            $AnmeldungListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $row[$key];
        }
        elseif ($elements[0] -eq "rechnungssplit") {
           if (-not $RechnungssplitListe[$type]) {
                $RechnungssplitListe[$type] =  [PSCustomObject]@{};
            }
            $RechnungssplitListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $row[$key];
        }
        elseif ($elements[0] -eq "personenmapping") {
           if (-not $Script:PersonenmappingListe[$type]) {
                $Script:PersonenmappingListe[$type] =  [PSCustomObject]@{};
            }
            $Script:PersonenmappingListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $row[$key];
        }
        elseif ($elements[0] -eq "personenmappingsplit") {
           if (-not $Script:PersonenmappingSplitListe[$type]) {
                $Script:PersonenmappingSplitListe[$type] =  [PSCustomObject]@{};
            }
            $Script:PersonenmappingSplitListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $row[$key];
        }
        elseif ($elements[0] -eq "tag") {
            $tagName = Get-TagTyp3Bereinigung($row[$key]);
            if ($tagName) {
                $tagName = $Gruppe.Trim() +"/" + $tagName;

                if (-not $TagListe[$type]) {
                    $TagListe[$type] =  [PSCustomObject]@{};
                }
                $TagListe[$type] | Add-Member -MemberType NoteProperty -Name $name -Value $tagName;
            }
        }
        else {
            Write-Warning "Parameter '$key' ist unbekannt.";
        }
    }

    Enable-WeeduSyncOperation;

    Invoke-ImportPerson -Person $Person -KomMittelListe $KomMittelListe -TagListe $TagListe -Sicherheitseinstellung $Sicherheitseinstellung;
    if (Invoke-ImportPersonenmappings -PersonenmappingListe $Script:PersonenmappingListe) {
        if (Invoke-ImportPersonenmappings -PersonenmappingListe $Script:PersonenmappingSplitListe) {
            Invoke-ImportRechnungssplits -RechnungssplitListe $RechnungssplitListe;
        }
    }
    Invoke-ImportAnmeldungen -AnmeldungListe $AnmeldungListe;
  }
}

function Invoke-ImportPerson {
param (
    [Parameter(Mandatory)]
    $Person, 
    $TagListe, 
    [Parameter(Mandatory)]
    $KomMittelListe, 
    [Parameter(Mandatory)]
    $Sicherheitseinstellung
)
process {
    try {
        $kmListe = @();
        $AddTagsListe = @();
        Write-Information "`nImportiere Person: $($Person.Vorname) $($Person.Name)" -InformationAction Continue 
        Write-Information "====================" -InformationAction Continue

        if ($PSBoundParameters.ContainsKey("TagListe")) {
            foreach ($item in $TagListe.GetEnumerator()) {
                $params = $item.Value;
                $AddTagsListe += $params.name;
            }
        }

        foreach ($key in $KomMittelListe.keys) {
            $params = $KomMittelListe[$key];

            $KmType = $key.Split('_');
            if ($params.Notfall) {
                $Notfall = $params.Notfall;
            }
            else {
                $Notfall = $false;
            }
            if ($params.Wohnsitz) {
                $Wohnsitz = $params.Wohnsitz;
            }
            else {
                $Wohnsitz = $false;
            }
            if ($params.Kategorie) {
                $Kategorie = $params.Kategorie;
            }
            else {
                $Kategorie = "Privat";
            }

            if (($KmType[0] -eq "festnetznummer" -or $KmType[0] -eq "mobilenummer" -or $KmType[0] -eq "faxnummer") -and $params.nummer) {
                $kmListe += New-Kommunikationsmittel-Object -Type $KmType[0] -Kategorie $params.kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Nummer $params.nummer;            
            }
            elseif ($KmType[0] -eq "emailadresse" -and $params.adresse) {
                $kmListe += New-Kommunikationsmittel-Object -Type "EMailAdresse" -Kategorie $params.kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Adresse $params.adresse;
            }
            elseif ($KmType[0] -eq "wwwadresse" -and $params.Url) {
                $kmListe += New-Kommunikationsmittel-Object -Type "WwwAdresse" -Kategorie $params.kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Url $params.UrlUrl;
            }
            elseif ($KmType[0] -eq "postadresse") {
                if ($params.Land) {
                    $params.Land = $params.Land.ToUpper();
                    if ($params.Land -ne "CH" -and $params.Land -ne "LI" -and $params.Land -ne "DE") {
                        if(($params.Adresse1 -ne $null -and $params.Adresse1 -ne '') -or 
                        ($params.Adresse2 -ne $null -and $params.Adresse2 -ne '')  -or 
                        ($params.Adresse3 -ne $null -and $params.Adresse3 -ne '')){                        
                             $kmListe +=  New-PostAdresse-Object -Kategorie $Kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Land $params.Land -Zusatzzeile1 $params.Zusatzzeile1 -Zusatzzeile2 $params.Zusatzzeile2 -Adresse1 $params.Adresse1 -Adresse2 $params.Adresse2 -Adresse3 $params.Adresse3;
                        }
                        else{
                             $kmListe +=  New-PostAdresse-Object -Kategorie $Kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Land $params.Land -Zusatzzeile1 $params.Zusatzzeile1 -Zusatzzeile2 $params.Zusatzzeile2 -Strasse $params.Strasse -Hausnummer $params.Hausnummer -Postfach $params.Postfach -PLZ $params.PLZ -Ort $params.Ort;
                        }

                    }
                    else {
                        $kmListe +=  New-PostAdresse-Object -Kategorie $Kategorie -GueltigAb $params.GueltigAb -GueltigBis $params.GueltigBis -Bemerkungen $params.Bemerkungen -Notfall $Notfall -Wohnsitz $Wohnsitz -Land $params.Land -Zusatzzeile1 $params.Zusatzzeile1 -Zusatzzeile2 $params.Zusatzzeile2 -Strasse $params.Strasse -Hausnummer $params.Hausnummer -Postfach $params.Postfach -PLZ $params.PLZ -Ort $params.Ort;
                    }
                }
                elseif ($params.Ort -or $params.Strasse) {
                    Write-Error "Für Postadresse $key ist kein Land gesetzt und kann daher nicht importiert werden."
                }
            }
        }

        if ($Script:PersonenInfo.PersonExistiert -ne 0) {
            if ($Person.Type -eq "einzelperson") {
                Set-Einzelperson -PersonUid $script:PersonenInfo.PersonUid -Vorname $Person.Vorname -Name $Person.Name -Korrespondenzsprache $Person.Korrespondenzsprache -Geschlecht $Person.Geschlecht -Geburtsdatum $Person.Geburtsdatum -Muttersprache $Person.Muttersprache -Sozialversicherungsnummer $Person.Sozialversicherungsnummer -Anredezusatz $Person.Anredezusatz -AkademischerTitel $Person.AkademischerTitel -TitelZusatz $Person.TitelZusatz -Titel2 $Person.Titel2 -Funktion $Person.Funktion -Beruf $Person.Beruf -Branche $Person.Branche -Staatsangehoerigkeit $Person.Staatsangehoerigkeit -Heimatort $Person.Heimatort -Auslaenderkategorie $Person.Auslaenderkategorie -BewilligungBis $Person.BewilligungBis -Geburtsort $Person.Geburtsort -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe;
            }
            elseif ($Person.Type -eq "organisation") {
                Set-Organisation -OrganisationUid $script:PersonenInfo.PersonUid -Organisationsname $Person.Name -Organisationsform $Person.Organisationsform -Korrespondenzsprache $Person.Korrespondenzsprache -UnternehmensId $Person.UnternehmensId -Branche $Person.Branche -Mitarbeiteranzahl $Person.Mitarbeiteranzahl -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe;
            }
            elseif ($Person.Type -eq "familie") {
                Set-Familie -FamilieUid $script:PersonenInfo.PersonUid -Familienname $Person.Name -Vornamen $Person.Vorname -Korrespondenzsprache $Person.Korrespondenzsprache -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe;
            }
        }
        else {
            if ($Person.Type -eq "einzelperson") {
                New-Einzelperson -PersonUid $script:PersonenInfo.PersonUid -Vorname $Person.Vorname -Name $Person.Name -Korrespondenzsprache $Person.Korrespondenzsprache -Geschlecht $Person.Geschlecht -Geburtsdatum $Person.Geburtsdatum -Muttersprache $Person.Muttersprache -Sozialversicherungsnummer $Person.Sozialversicherungsnummer -Anredezusatz $Person.Anredezusatz -AkademischerTitel $Person.AkademischerTitel -TitelZusatz $Person.TitelZusatz -Titel2 $Person.Titel2 -Funktion $Person.Funktion -Beruf $Person.Beruf -Branche $Person.Branche -Staatsangehoerigkeit $Person.Staatsangehoerigkeit -Heimatort $Person.Heimatort -Auslaenderkategorie $Person.Auslaenderkategorie -BewilligungBis $Person.BewilligungBis -Geburtsort $Person.Geburtsort -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe -SicherheitsEinstellung $Sicherheitseinstellung;
            }
            elseif ($Person.Type -eq "organisation") {
                New-Organisation -OrganisationUid $script:PersonenInfo.PersonUid -Organisationsname $Person.Name -Organisationsform $Person.Organisationsform -Korrespondenzsprache $Person.Korrespondenzsprache -UnternehmensId $Person.UnternehmensId -Branche $Person.Branche -Mitarbeiteranzahl $Person.Mitarbeiteranzahl -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe -SicherheitsEinstellung $Sicherheitseinstellung;
            }
            elseif ($Person.Type -eq "familie") {
                New-Familie -FamilieUid $script:PersonenInfo.PersonUid -Familienname $Person.Name -Vornamen $Person.Vorname -Korrespondenzsprache $Person.Korrespondenzsprache -KommunikationsmittelListe $kmListe -AddTagsListe $AddTagsListe -SicherheitsEinstellung $Sicherheitseinstellung;
            }
        }
    }
    catch {
        $ErrMsg = $_.Exception.Message;
        if ($_.TargetObject.errors.message) {
            $ErrMsg += ": " + $_.TargetObject.errors.message;
        }
        Write-Error "Invoke-ImportPerson: $ErrMsg";
    }
  }
}

function Invoke-ImportAnmeldungen {
param (
    [Parameter(Mandatory)]
    $AnmeldungListe
)
process {
    try {
        foreach ($item in $AnmeldungListe.GetEnumerator()) {
            $params = $item.Value;

            if ($params.Modulversion -eq $null) {
                continue;
            }

            $AnmeldungUid = $null;
            $AnmeldungExist = $null;
            $UidString =  "!Anmeldung" + $script:PersonenInfo.UidSuffix + "!" + $params.Modulversion;

            if ($Script:PersonenInfo.PersonExistiert -eq 1) {
                # mit altem Tool importiert, Anmeldung suchen
                $AnmeldungUid = Get-AlteAnmeldungFurPersonModulversion -PersonUid $script:PersonenInfo.PersonUid -ModulversionUid $params.Modulversion
                if ($AnmeldungUid -eq $null) {
                   $AnmeldungUid = $UidString;
                   $AnmeldungExist = $false;
                }
                else {
                    $AnmeldungExist = $true;
               }
            }
            else {
               $AnmeldungUid = $UidString;
               $AnmeldungExist = Test-EntityExistsInIndex $AnmeldungUid;
            }

            if ($params.Status) {
                $Status = $params.Status;
            }
            else {
                $Status = "Definitiv";
            }
            if ($params.Vertragspartner) {
                $Vertragspartner = $params.Vertragspartner;
            }
            else {
                $Vertragspartner = $script:PersonenInfo.PersonUid;
            }

            if ($AnmeldungExist) {
                Set-Anmeldung -AnmeldungUid $AnmeldungUid -LeistungsempfaengerUid $script:PersonenInfo.PersonUid -AnlassUid $params.Anlass -ModulversionUid $params.Modulversion -VertragspartnerUid $Vertragspartner -LieferadresseUid $params.Lieferadresse -Bemerkungen $params.Bemerkungen -Status $Status;
            }
            else {
                Start-Sleep -Seconds 2
                New-Anmeldung -AnmeldungUid $AnmeldungUid -LeistungsempfaengerUid $script:PersonenInfo.PersonUid -AnlassUid $params.Anlass -ModulversionUid $params.Modulversion -VertragspartnerUid $Vertragspartner -LieferadresseUid $params.Lieferadresse -Bemerkungen $params.Bemerkungen -Status $Status;
            }
        }
    }
    catch {
        $ErrMsg = $_.Exception.Message;
        if ($_.TargetObject.errors.message) {
            $ErrMsg += ": " + $_.TargetObject.errors.message;
        }
        Write-Error "Invoke-ImportAnmeldungen: $ErrMsg";
    }
  }
}

function Invoke-ImportPersonenmappings {
param (
    [Parameter(Mandatory)]
    $PersonenmappingListe
)
process {
    try {
        foreach ($Personenmapping in $PersonenmappingListe.Values) {
            if ($Personenmapping.Id -eq $null -and $Personenmapping.MandantenNummer -eq $null) {
                # ungesetzte Zellen ignorieren
                continue;
            }
            $RechnungsemfaengerExists = 0;
            if ($Personenmapping.PersonId) {
                # Personenmapping des Rechnungssplits
                if (Test-IsGuid($Personenmapping.PersonId)) {
                    $PersonUid = $Personenmapping.PersonId;
                    $RechnungsemfaengerExists = Test-PersonenExistsInIndex $PersonUid;
                }
                else {
                    $PersonInfo = Invoke-BuildPersonUid -Gruppe $script:PersonenInfo.UidPrefix -Id $Personenmapping.PersonId
                    $RechnungsemfaengerExists = $PersonInfo.PersonExistiert;
                    $PersonUid = $PersonInfo.PersonUid;
                }
                if ($RechnungsemfaengerExists -eq 0) {
                    throw "Rechnungsempfaenger '" + $Personenmapping.PersonId + "' nicht gefunden oder ist inaktiv";
                }
            }
            else {
                # Personenmapping der importierten Person
                $PersonUid = $script:PersonenInfo.PersonUid;
            }

            Set-PersonenmappingFurPersonMandant -PersonUid $PersonUid -Personenmapping $Personenmapping;
        }
    }
    catch {
        $ErrMsg = $_.Exception.Message;
        if ($_.TargetObject.errors.message) {
            $ErrMsg += ": " + $_.TargetObject.errors.message;
        }
        Write-Error "Invoke-ImportPersonenmappings: $ErrMsg";
        return $false;
    }
    return $true;
  }
}

function Invoke-ImportRechnungssplits {
param (
    [Parameter(Mandatory)]
    $RechnungssplitListe
)
process {
    try {
        foreach ($Rechnungssplit in $RechnungssplitListe.Values) {
            if ($Rechnungssplit.SplitId -eq $null -and $Rechnungssplit.PersonenmappingId -eq $null) {
                # ungesetzte Zellen ignorieren
                continue;
            }
            Set-RechnungssplitFurPersonMappings -PersonUid $script:PersonenInfo.PersonUid -Rechnungssplit $Rechnungssplit;
        }
    }
    catch {
        $ErrMsg = $_.Exception.Message;
        if ($_.TargetObject.errors.message) {
            $ErrMsg += ": " + $_.TargetObject.errors.message;
        }
        Write-Error "Invoke-ImportRechnungssplits: $ErrMsg";
    }
  }
}


function Get-TagTyp3Bereinigung ($TagName) {
    if ($TagName -ne $null) {
        $TagName = $TagName.ToLower().Trim();

        $TagName = $TagName -replace "é", "e";
        $TagName = $TagName -replace "è", "e";
        $TagName = $TagName -replace "à", "a";
        $TagName = $TagName -replace "ç", "c";
        $TagName = $TagName -replace "ä", "ae";
        $TagName = $TagName -replace "ö", "oe";
        $TagName = $TagName -replace "ü", "ue";
        $TagName = $TagName -replace "@", "-at-";
        $TagName = $TagName -replace "%", "-prozent-";
        $TagName = $TagName -replace "[\s—/|\\-]+","-";
        $TagName = $TagName -replace "^[^a-z0-9]+|[^a-z0-9-]+|[^a-z0-9]+$","";

        $regex = [regex]("^[a-z0-9][a-z0-9-]*[a-z0-9]$");
        if ($regex.Match($TagName).Success)
        {
            return $TagName;
        }
    }
    return $null;
}


function Test-IsGuid ($String) {
    try {
        if ($String.StartsWith('!')) {
        return $true
        }
        [System.Guid]::Parse($String) | Out-Null;
        return $true
    } catch {
        return $false;
    }
}


function Invoke-BuildPersonUid {
param (
    [Parameter(Mandatory)]
    [string]$Gruppe, 
    [Parameter(Mandatory)]
    [string]$Id
)
process {
    $Id = $Id.Trim();
    $Gruppe = $Gruppe.Trim();
  
    $Spezialfall = $null;
    switch ($Gruppe.ToLower())
    {
        "ibwwi" {
            $UidPrefix = "IBW";
            $Spezialfall = "IBWWI";
        }
        "juventuswoodtli" {
            $UidPrefix = "Juventus";
            $Spezialfall = "JuventusWoodtli";
        }
         "juventuswirtschaft" {
            $UidPrefix = "JuventusWirtschaft";
        }
         "juventusmaturitaet" {
            $UidPrefix = "JuventusMaturitaet";
        }
        "bfswinterthur" {
            $UidPrefix = "BFSWinterthur";
        }
        "bfswinterthurallg" {
            $UidPrefix = "BFSWinterthurAllg";
        }
        "bfswinterthursozial" {
            $UidPrefix = "BFSWinterthurSozial";
        }
        default {
            $UidPrefix = $Gruppe.ToUpper();
        }
    }

    if($Spezialfall -eq $null) {
        $Spezialfall = $UidPrefix;
    }

    $PersonUidStrOld = "!$UidPrefix!$Id";
    $PersonUidStrNew = "!Person!$Spezialfall!$Id";
    
    $PersonOldUid = ConvertTo-WeeduGuid $PersonUidStrOld;
    $PersonNewUid = ConvertTo-WeeduGuid $PersonUidStrNew;

    $PersonExistiert = Test-PersonenExistsInIndex -Uids $PersonOldUid, $PersonNewUid;

    switch ($PersonExistiert) {
        1 {
            # nach altem Schema erstellt
            $PersonUid = $PersonUidStrOld;
            $UidSuffix = $PersonUidStrOld;
        }
        default {
            # nach neuem Schema erstellt
            $PersonUid = $PersonUidStrNew;
            $UidPrefix = "$Spezialfall";
            $UidSuffix = "!$Spezialfall!$Id";
        }
    }

    $PersonenInfo = [PSCustomObject]@{
        UidPrefix = $UidPrefix;
        UidSuffix = $UidSuffix;
        PersonUid = $PersonUid;
        PersonExistiert = $PersonExistiert;
    };

    return $PersonenInfo;
  }
}


function Test-PersonenExistsInIndex  {
param (
    [Parameter(Mandatory)]
    [array]$Uids
)
process {
    $Entities = Get-PersonenExistInIndex -Uids $Uids;

    if ($Entities -ne $null) {
        For ($i = 0; $i -lt $Uids.Count; $i++) {
            foreach ($Person in $Entities) {
               if ($Uids[$i].ToLower() -eq $Person.idb_uid.ToLower()) {
                    if ($i -eq 0 -and $Person.prs_aktiv -eq $false) {
                        # alte und inaktive Personen ignorieren
                        continue;
                    }
                    return $i + 1;
                }
            }
        }
    }

    return 0;
  }
}


function Get-PersonenExistInIndex  {
param (
    [Parameter(Mandatory)]
    [array]$Uids
)
process {
    $uidString = [string]::Join(",", ($uids | Foreach-Object { '"'+$_+'"' }));
    $WqlString = 'Personen mit UID in (' + $uidString + ')';
    $Entities = Invoke-WqlQuery -WQLAbfrage $WqlString 3>$null 6>$null;
    return $Entities;
  }
}


function Get-AlteAnmeldungFurPersonModulversion  {
param (
    [Parameter(Mandatory)]
    $PersonUid,
    [Parameter(Mandatory)]
    $ModulversionUid
)
process {
    $PersUid = ConvertTo-WeeduGuid $PersonUid;
    $VersUid = ConvertTo-WeeduGuid $ModulversionUid;
    $WqlString = 'Anmeldungen [UID] von ' + $PersUid + ' an ' + $VersUid;
    $Anmeldung = Invoke-WqlQuery -WQLAbfrage $WqlString 3>$null 6>$null;

    if ($Anmeldung) {
        return $Anmeldung.idb_uid | select -First 1
    }

    return $null;
  }
}


function Set-PersonenmappingFurPersonMandant {
param (
    [Parameter(Mandatory)]
    $PersonUid,
    [Parameter(Mandatory)]
    $Personenmapping
)
process {
    $PersonUid = ConvertTo-WeeduGuid $PersonUid;

    $EMailAdressListe = @();
    if ($Personenmapping.ZustellEmailAdressListe) {
        $EMailAdressen = $Personenmapping.ZustellEmailAdressListe.Split(';');

        foreach ($EMailAdresse in $EMailAdressen) {
            $EMailAdressListe += $EMailAdresse.Trim();
       }
    }

    if ($Personenmapping.GeneriereKundenNummer -eq 'Ja') {
        $GeneriereKundenNummer = $true;
    }
    else {
        $GeneriereKundenNummer = $false;
    }
    if ($Personenmapping.RechnungszustellungPerEMail -eq 'Ja') {
        $RechnungszustellungPerEMail = $true;
    }
    else {
        $RechnungszustellungPerEMail = $false;
    }
    
    if ($GeneriereKundenNummer) {
        Set-PersonenMapping -PersonUid $PersonUid -MandantenNummer $Personenmapping.MandantenNummer -GeneriereKundenNummer -ADLoginName $Personenmapping.ADLoginName -RechnungszustellungPerEMail $RechnungszustellungPerEMail -ZustellEmailAdressListe $EMailAdressListe;
    }
    else {
        Set-PersonenMapping -PersonUid $PersonUid -MandantenNummer $Personenmapping.MandantenNummer -KundenNummer $Personenmapping.KundenNummer -ADLoginName $Personenmapping.ADLoginName -RechnungszustellungPerEMail $RechnungszustellungPerEMail -ZustellEmailAdressListe $EMailAdressListe;
    }
  } 
}


function Set-RechnungssplitFurPersonMappings {
param (
    [Parameter(Mandatory)]
    $PersonUid,
    [Parameter(Mandatory)]
    $Rechnungssplit
)
process {
    $RechnungssplitId = Invoke-BuildRechnungssplitUid -PersonenmappingId $Rechnungssplit.PersonenmappingId -RechnungssplitId $Rechnungssplit.SplitId;
    $RechnungssplitId = ConvertTo-WeeduGuid $RechnungssplitId;
    $Anteil = $Rechnungssplit.Anteil / 100;

    $KontierungListe = @();
    if ($Rechnungssplit.Kontierungen) {
        $Kontierungen = $Rechnungssplit.Kontierungen.Split(';');

        foreach ($Kontierung in $Kontierungen) {
            $KontierungListe += $Kontierung.Trim();
       }
    }

    # finde Personenmapping fur Split
    foreach ($Personenmapping in $Script:PersonenmappingSplitListe.Values) {
        if ($Personenmapping.Id -eq $Rechnungssplit.PersonenmappingSplitId) {
            $PersonenmappingSplit = $Personenmapping;
            break;
        }
    }

    if ($PersonenmappingSplit -eq $null) {
       throw "Set-RechnungssplitFurPersonMappings: kein Personenmapping fuer '" + $Rechnungssplit.PersonenmappingSplitId + "' gefunden.";
    }

    # get Uid fuer Rechnungsempfaenger Split
    if (Test-IsGuid($PersonenmappingSplit.PersonId)) {
        $RgEmpfaenger = $PersonenmappingSplit.PersonId;
    }
    else {
        $PersonInfo = Invoke-BuildPersonUid -Gruppe $Script:PersonenInfo.UidPrefix -Id $PersonenmappingSplit.PersonId;
        $RgEmpfaenger = $PersonInfo.PersonUid;
    }

    $RechnungssplitStatus = Invoke-Weedu -Uri "rest/Rechnungssplits/{0}" -UriParams $RechnungssplitId -Method GET -StatusOnly;

    if ($RechnungssplitStatus -eq 200) {
        Set-RechnungsSplit -RechnungsSplitUid $RechnungssplitId -RechnungsadresseUid $Rechnungssplit.RechnungsadresseUid -Anteil $Anteil -Bezeichnung $Rechnungssplit.Bezeichnung -Bemerkung $Rechnungssplit.Bemerkung -SortierPrioritaet $Rechnungssplit.Sortierprioritaet -PlatzhalterProdukte $Kontierungen;
    }
    else {
        $Personenmapping = Get-PersonenMapping -PersonUid $PersonUid -MandantenNummer $PersonenmappingSplit.MandantenNummer;
        New-RechnungsSplit -RechnungsSplitUid $RechnungssplitId -PersonMappingUid $Personenmapping.uid -RechnungsempfaengerUid $RgEmpfaenger -RechnungsadresseUid $Rechnungssplit.RechnungsadresseUid -Anteil $Anteil -Bezeichnung $Rechnungssplit.Bezeichnung -Bemerkung $Rechnungssplit.Bemerkung -SortierPrioritaet $Rechnungssplit.Sortierprioritaet -PlatzhalterProdukte $Kontierungen;
    }
  }
}


function Invoke-BuildRechnungssplitUid {
param (
    [Parameter(Mandatory)]
    $PersonenmappingId,
    [Parameter(Mandatory)]
    $RechnungssplitId
)
process {
    if (Test-IsGuid($RechnungssplitId)) {
        return $RechnungssplitId;
    }
    else {
        return $script:PersonenInfo.PersonUid + "!Rechnungssplit!" + $PersonenmappingId + "!" + $RechnungssplitId;
    }
  }
}


Export-ModuleMember -function Invoke-PersonenImport