Catch more errors in your Business Central apps adding steps to your CI/CD pipelines!

Install-Module XliffSync

Test-BcAppXliffTranslations -translationRulesEnableAll -AzureDevOps 'error' -printProblems

<#
 .Synopsis
  Synchronizes and checks translations for a workspace folder with Microsoft Dynamics 365 Business Central apps.
 .Description
  Iterates through the translation units of a base XLIFF file and synchronizes them with a target XLIFF file.
 .Parameter buildProjectFolder
  Specifies the path to the workspace folder containing the projects.
 .Parameter appFolders
  Specifies the names of the app folders in the workspace folder. If empty, all subfolders will be processed.
 .Parameter translationRules
  Specifies which technical validation rules should be used.
 .Parameter translationRulesEnableAll
  Specifies whether to apply all technical validation rules.
 .Parameter restrictErrorsToLanguages
  Specifies languages to restrict errors to. For languages not in the list only warnings will be raised. If empty, then the setting of AzureDevOps applies to all languages.
  .Parameter AzureDevOps
  Specifies whether to generate Azure DevOps Pipeline compatible output. This setting determines the severity of errors.
 .Parameter reportProgress
  Specifies whether the command should report progress.
 .Parameter printProblems
  Specifies whether the command should print all detected problems.
 .Parameter printUnitsWithErrors
  Specifies whether the command should print the units with errors.
#>
function Test-BcAppXliffTranslations {
    Param(
        [Parameter(Mandatory=$false)]
        [string] $buildProjectFolder = $ENV:BUILD_REPOSITORY_LOCALPATH,
        [Parameter(Mandatory=$false)]
        [string[]] $appFolders = @(),
        [Parameter(Mandatory=$false)]
        [ValidateSet("ConsecutiveSpacesConsistent", "ConsecutiveSpacesExist", "OptionMemberCount", "OptionLeadingSpaces", "Placeholders", "PlaceholdersDevNote")]
        [string[]] $translationRules = @("ConsecutiveSpacesConsistent", "OptionMemberCount", "OptionLeadingSpaces", "Placeholders"),
        [switch] $translationRulesEnableAll,
        [Parameter(Mandatory=$false)]
        [string[]] $restrictErrorsToLanguages = @(),
        [Parameter(Mandatory=$false)]
        [ValidateSet('no','error','warning')]
        [string] $AzureDevOps = 'warning',
        [switch] $reportProgress,
        [switch] $printProblems,
        [switch] $printUnitsWithErrors
    )

    if ((-not $appFolders) -or ($appFolders.Length -eq 0)) {
        $appFolders = (Get-ChildItem $buildProjectFolder -Directory).Name
        Write-Host "-appFolders not explicitly set, using subfolders of $($buildProjectFolder): $appFolders"
    }

    Sort-AppFoldersByDependencies -appFolders $appFolders -baseFolder $buildProjectFolder -WarningAction SilentlyContinue | ForEach-Object {
        Write-Host "Checking translations for $_"
        $appProjectFolder = Join-Path $buildProjectFolder $_
        $appTranslationsFolder = Join-Path $appProjectFolder "Translations"
        Write-Host "Retrieving translation files from $appTranslationsFolder"
        $baseXliffFile = Get-ChildItem -Path $appTranslationsFolder -Filter '*.g.xlf'
        Write-Host "Base translation file $($baseXliffFile.FullName)"
        $targetXliffFiles = Get-ChildItem -Path $appTranslationsFolder -Filter '*.xlf' | Where-Object { -not $_.FullName.EndsWith('.g.xlf') }
        $allUnitsWithIssues = @()

        foreach ($targetXliffFile in $targetXliffFiles) {
            [string]$AzureDevOpsSeverityForFile = $AzureDevOps
            if (($AzureDevOps -eq 'error') -and ($restrictErrorsToLanguages.Length -gt 0)) {
                if ($null -eq ($restrictErrorsToLanguages | Where-Object { $targetXliffFile.Name -match $_ })) {
                    $AzureDevOpsSeverityForFile = 'warning'
                }
                Write-Host "Translation error severity is '$AzureDevOpsSeverityForFile' for file $($targetXliffFile.FullName)"
            }

            Write-Host "Syncing to file $($targetXliffFile.FullName)"
            Sync-XliffTranslations -sourcePath $baseXliffFile.FullName -targetPath $targetXliffFile.FullName -AzureDevOps $AzureDevOpsSeverityForFile -reportProgress:$reportProgress -printProblems:$printProblems
            Write-Host "Checking translations in file $($targetXliffFile.FullName)"
            $unitsWithIssues = Test-XliffTranslations -targetPath $targetXliffFile.FullName -checkForMissing -checkForProblems -translationRules $translationRules -translationRulesEnableAll:$translationRulesEnableAll -AzureDevOps $AzureDevOpsSeverityForFile -reportProgress:$reportProgress -printProblems:$printProblems

            if ($unitsWithIssues.Count -gt 0) {
                Write-Host "Issues detected in file $($targetXliffFile.FullName)."
                if ($printUnitsWithErrors) {
                    Write-Host "Units with issues:"
                    Write-Host $unitsWithIssues
                }

                if ($AzureDevOpsSeverityForFile -eq 'error') {
                    $allUnitsWithIssues += $unitsWithIssues
                }
            }
        }

        if ($targetXliffFiles.Count -eq 0) {
            Write-Host "##vso[task.logissue type=warning]There are no target translation files for $($baseXliffFile.Name)"
        }

        if (($AzureDevOps -eq 'error') -and ($allUnitsWithIssues.Count -gt 0)) {
            throw "Issues detected in translation files!"
        }
    }
}

Param(
    [Parameter(Mandatory=$false)]
    [string] $buildProjectFolder = $ENV:BUILD_REPOSITORY_LOCALPATH,
    [Parameter(Mandatory=$false)]
    [string[]] $appFolders,
    [switch] $allAppFolders,
    [Parameter(Mandatory=$false)]
    [ValidateSet('no','error','warning')]
    [string] $AzureDevOps = 'error'
)

if ($AzureDevOps -eq 'no') {
    return
}

if ((-not $appFolders) -or ($appFolders.Length -eq 0)) {
    Write-Host "-appFolders not explicitly set, using subfolders of $buildProjectFolder"
    $appFolders = (Get-ChildItem $buildProjectFolder -Directory).Name | Where-Object { Test-Path (Join-Path $buildProjectFolder "$_\app.json") }
    if (-not $allAppFolders) {
        $appFolders = $appFolders | Where-Object { $("Test", "RuntimePackages") -notcontains $_ }
    }
    Write-Host "App Folders: $appFolders"
}

Sort-AppFoldersByDependencies -appFolders $appFolders -baseFolder $buildProjectFolder -WarningAction SilentlyContinue | ForEach-Object {
    Write-Host "Checking permission sets for $_"
    $appProjectFolder = Join-Path $buildProjectFolder $_

    $objectTypeHash = @{
        "table" = 1
        "report" = 3
        "codeunit" = 5
        "xmlport" = 6
        "page" = 8
        "query" = 9
    }

    $xmlPermissionSetFileNames = $null
    $permissionSetALDeclarations = $null

    $permissionSetALFiles = Get-ChildItem -Recurse "$appProjectFolder" *.PermissionSet*.al
    $xmlPermissionSetFileNames = (Get-ChildItem $appProjectFolder -Filter "*PermissionSet*.xml").FullName

    if ($permissionSetALFiles -ne $null) {
        if ($xmlPermissionSetFileNames -ne $null) {
            Write-Host "##vso[task.logissue type=warning]Both XML and AL permission sets were found. Please switch to AL permission sets!"
        }

        Write-Host "##[section]Found the following permission set object(s)"
        Write-Host $permissionSetALFiles
        $permissionSetALDeclarations = [ordered]@{}
        foreach ($permissionSetALFile in $permissionSetALFiles) {
            Write-Verbose "Permission set $permissionSetALFile covers the following objects:"
            $permissionSetALFileContent = Get-Content -Path $permissionSetALFile.FullName
            $alObjectsCovered = $permissionSetALFileContent | Select-String "($([string]::Join("|", ($objectTypeHash.GetEnumerator() | ForEach-Object { $_.Key })))) +`"?([A-Za-z0-9_ *]+)`"? =" -AllMatches | ForEach-Object {$_.Matches.Value.Trim(" =")}
            foreach ($alCoveredObject in $alObjectsCovered) {
                Write-Verbose "  [$alCoveredObject]"
                $permissionSetALDeclarations[$alCoveredObject] = $true;
            }
        }
        Write-Host "##[section]The permission set object(s) declare(s) permissions for the following objects"
        Write-Host ($permissionSetALDeclarations.Keys | Format-List | Out-String)
    }
    else {
        if ($xmlPermissionSetFileNames -eq $null) {
            throw "Missing permission set for extension!"
        }
    }

    $alFiles = Get-ChildItem -Recurse "$appProjectFolder" *.al | Where-Object { -not $_.PSIsContainer } | Select-Object Name, FullName, Length
    $missingPermissions = 0

    Write-Host "##[section]Checking coverage for each AL file..."
    foreach ($alFile in $alFiles) {
        Write-Verbose "Searching for objects in $($alFile.Name) that require permissions"
        $alFileContent = Get-Content -Path $alFile.FullName

        # Check if file contains ObsoleteState = Removed;
        if (($alFileContent -match "ObsoleteState = Removed;").Length -gt 0) {
            Write-Verbose "Skipping $($alFile.Name) due to ObsoleteState = Removed"
            continue
        }

        $alObjectDeclarations = $alFileContent -cmatch "^($([string]::Join("|", ($objectTypeHash.GetEnumerator() | ForEach-Object { $_.Key })))) +([0-9]+) +.*$"
        Write-Verbose "$($alObjectDeclarations.Length) object(s) found in $($alFile.Name)"

        foreach ($alObjectDeclaration in $alObjectDeclarations) {
            $hasMatches = $alObjectDeclaration -match "([A-Za-z]+) +([0-9]+) +((`"[A-Za-z0-9_ *]+`")|([A-Za-z0-9_*]+))"
            if (-not $hasMatches) {
                continue
            }
            $objectType = $Matches[1]
            $objectId = $Matches[2]
            $objectName = $Matches[3]
            Write-Verbose "Object Type: [$objectType]; Object ID: [$objectId]; Object name: [$objectName]"

            $foundObjectInPermissionSet = $false
            if ($permissionSetALDeclarations -ne $null) {
                $foundObjectInPermissionSet = ($permissionSetALDeclarations.Contains("$objectType $objectName")) -or
                                              (($permissionSetALDeclarations.Contains(("$objectType $objectName" -replace '"',''))) -or
                                               ($permissionSetALDeclarations.Contains("$objectType *")))
            }
            else {
                foreach ($xmlPermissionSetFileName in $xmlPermissionSetFileNames) {
                    $foundObjectInPermissionSet = Select-Xml -Path "$xmlPermissionSetFileName" -XPath "/PermissionSets/PermissionSet/Permission" | Select-Object -ExpandProperty Node | Where-Object { $_.ObjectType -eq $objectTypeHash.$objectType } | Where-Object { $_.ObjectID -eq $objectId }
                    if ($foundObjectInPermissionSet) {
                        break;
                    }
                }
            }

            if (-not $foundObjectInPermissionSet) {
                Write-Host "##vso[task.logissue type=$AzureDevOps]$objectType $objectId $objectName found in file $($alFile.Name) is missing in permission set(s)."
                $missingPermissions += 1
            }
        }
    }

    Write-Host "##[section]Coverage results:"

    if ($missingPermissions -gt 0) {
        $message = "Missing $missingPermissions objects in permission set(s)!"
        if ($AzureDevOps -eq 'error') {
            throw $message
        }
        else {
            Write-Host $message
        }
    }

    if ($missingPermissions -eq 0) {
        Write-Host "No problems found."
    }

    Write-Host "Done"
}