Merge branch '24.2.5+' of https://github.com/DevExpress-Examples/devextreme-datagrid-context-menu-for-crud-operations into 24.2.5+

Author: charlescordialDevExpress

ASP.NET Core/ASP.NET Core.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
   <Target Name="DebugEnsureNodeEnv" BeforeTargets="BeforeBuild" Condition=" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') ">
     <!-- Ensure Node.js is installed -->

test-example.ps1

@@ -1,60 +1,82 @@
-# For local testing, you can pass branchName and/or buildVersion.
-# If both parameters are specified, only buildVersion will be used.
+# For local testing, you can pass buildVersion.
 # Example usage:
-# ./test-example.ps1 -branchName 23.1.3+
 # ./test-example.ps1 -buildVersion 23.1.13
 param (
-    [string]$branchName = [Environment]::GetEnvironmentVariable("BRANCH_NAME", [EnvironmentVariableTarget]::Machine),
-    [string]$buildVersion = [Environment]::GetEnvironmentVariable("BUILD_VERSION", [EnvironmentVariableTarget]::Machine)
+    [string]$buildVersion = $Env:CodeCentralBuildVersion
 )
 
-# Repository's branch name, e.g. 24.1.3+
-$global:BRANCH_NAME = $branchName
-# Masstest-specific parameter. Specifies the minor version (example: '21.1.5') !or daily build (example: '21.2.2005')
+# Masstest-specific parameter. Specifies the minor version (example: '21.1.5')
 $global:BUILD_VERSION = $buildVersion
 
 $global:ERROR_CODE = 0
 $global:FAILED_PROJECTS = @()
 
-$global:ALL_VERSIONS = @(
-    "14.1", "14.2",
-    "15.1", "15.2",
-    "16.1", "16.2",
-    "17.1", "17.2",
-    "18.1", "18.2",
-    "19.1", "19.2",
-    "20.1", "20.2",
-    "21.1", "21.2",
-    "22.1", "22.2",
-    "23.1", "23.2",
-    "24.1", "24.2",
-    "25.1", "25.2" 
-)
+function Test-NpmVersionExists {
+    param ([string]$Pkg, [string]$Ver)
+    npm view "$Pkg@$Ver" > $null 2>&1
+    return ($LASTEXITCODE -eq 0)
+}
+
+function Get-ValidNpmVersion {
+    param (
+        [string]$PackageName,
+        [string]$Version
+    )
+
+    Write-Host "Checking $PackageName@$Version..."
+    if (Test-NpmVersionExists -Pkg $PackageName -Ver $Version) {
+        Write-Host "$PackageName@$Version exists."
+        return $Version
+    }
+
+    try {
+        $v = [version]$Version
+        $fallback = "$($v.Major).$($v.Minor)-stable"
+    } catch {
+        Write-Host "Invalid version format: $Version"
+        return $null
+    }
+
+    Write-Host "$PackageName@$Version not found. Trying fallback: $PackageName@$fallback..."
+    if (Test-NpmVersionExists -Pkg $PackageName -Ver $fallback) {
+        Write-Host "$PackageName@$fallback exists (fallback)."
+        return $fallback
+    }
+
+    Write-Host "Neither $PackageName@$Version nor @$fallback exist."
+    return $null
+}
 
 function Install-Packages {
     param (
         [string]$folderName,
         [string[]]$packages,
         [string]$buildVersion
     )
+
     Write-Output "`nInstalling packages in folder: $folderName"
-    
-    $packageList = $packages | ForEach-Object { "$_@$buildVersion" }
-    Write-Output "`nPackages to install: $($packageList -join ", ")"
-    # TODO: Uninstall DevExtreme packages to avoid potential peer-dependency issues
-    npm install @($packageList) --save --save-exact --no-fund
-    if (-not $?) {
-        Write-Error "`nERROR: Failed to install DevExtreme packages in $folderName"
-        throw "Installation failed in $folderName"
+
+    foreach ($package in $packages) {
+        $packageVersion = Get-ValidNpmVersion -PackageName $package -Version $buildVersion
+        $packageWithVersion = "$package@$packageVersion"
+        Write-Output "Installing $packageWithVersion..."
+
+        npm install --save --save-exact --no-fund --loglevel=error --force $packageWithVersion
+        if (-not $?) {
+            Write-Error "`nERROR: Failed to install $packageWithVersion in $folderName"
+            throw "Installation failed for $packageWithVersion in $folderName"
+        }
     }
+
+    Write-Output "`nAll packages installed successfully in $folderName"
 }
 
 function Build-Project {
     param (
         [string]$folderName
     )
     Write-Output "`nBuilding the project in folder: $folderName"
-    
+
     npm run build
     if (-not $?) {
         Write-Error "`nERROR: Failed to build the project in $folderName"
@@ -76,7 +98,7 @@ function Process-JavaScriptProjects {
 
     $jQueryEntry = @{
         Name = "jQuery";
-        Packages = if ([version]$buildVersion -ge [version]23.1) { # `devextreme-dist` appeared in 23.1
+        Packages = if ([version]$buildVersion -ge [version]23.1) {
             @("devextreme", "devextreme-dist")
         } else {
             @("devextreme")
@@ -98,6 +120,9 @@ function Process-JavaScriptProjects {
         Push-Location $folderName
 
         try {
+            Write-Output "`nRemoving node_modules & package-lock.json: $pwd"
+            Remove-Item -Recurse -Force node_modules -ErrorAction SilentlyContinue
+            Remove-Item -Force package-lock.json -ErrorAction SilentlyContinue
             Install-Packages -folderName $folderName -packages $packages -buildVersion $buildVersion
             Write-Output "`nInstalling remaining packages in $folderName"
             npm install --save --save-exact --no-fund --loglevel=error
@@ -118,110 +143,140 @@ function Process-JavaScriptProjects {
     Write-Output "`n--== JavaScript Projects Processing Completed ==--"
 }
 
-function Process-DotNetProjects {
+function Resolve-NuGetVersionWithFallback {
     param (
-        [string]$RootDirectory = "."
+        [string]$PackageName,
+        [string]$RequestedVersion
     )
 
-    Write-Output "`n--== Starting .NET project processing in directory: $RootDirectory ==--"
-
-    $slnFiles = Get-ChildItem -Path $RootDirectory -Filter *.sln -Recurse -Depth 1
+    function Test-PackageAvailable {
+        param ([string]$name, [string]$ver)
+        dotnet add package $name --version $ver > $null 2>&1
+        return ($LASTEXITCODE -eq 0)
+    }
 
-    if ($slnFiles.Count -eq 0) {
-        Write-Output "`nNo solution files (.sln) found in the specified directory at level 1."
-        return
+    if (Test-PackageAvailable -name $PackageName -ver $RequestedVersion) {
+        Write-Host "$PackageName@$RequestedVersion is available."
+        return $RequestedVersion
     }
 
-    foreach ($slnFile in $slnFiles) {
-        Write-Output "`nFound solution file: $($slnFile.FullName)"
-        
-        try {
-            Write-Output "`nBuilding solution: $($slnFile.FullName)"
-            dotnet build $slnFile.FullName -c Release
+    Write-Host "$PackageName@$RequestedVersion not found. Checking for -beta and -alpha versions..."
 
-            if ($?) {
-                Write-Output "`nBuild succeeded for $($slnFile.FullName)."
-            } else {
-                throw "Build failed for $($slnFile.FullName)."
-            }
-        } catch {
-            Write-Error "`nERROR: $_"
-            $global:LASTEXITCODE = 1
-            $global:ERROR_CODE = 1
-            $global:FAILED_PROJECTS += "ASP.NET"
+    $suffixes = @("beta", "alpha")
+    foreach ($suffix in $suffixes) {
+        $fallbackVersion = "$RequestedVersion-$suffix"
+        if (Test-PackageAvailable -name $PackageName -ver $fallbackVersion) {
+            Write-Host "Found $PackageName@$fallbackVersion"
+            return $fallbackVersion
         }
     }
 
-    Write-Output "`nCompleted .NET project processing."
+    Write-Warning "No matching versions found for $PackageName@$RequestedVersion"
+    return $null
 }
 
-function Set-BuildVersion {
-    Write-Output "`n--== Starting Set-BuildVersion process. ==--"
+function Process-AspNetCoreProject {
+    param (
+        [Parameter(Mandatory = $true)]
+        [string]$buildVersion
+    )
+
+    $folderPath = Get-ChildItem -Directory |
+        Where-Object { $_.Name -match '(?i)^ASP\.NET\s*Core$' } |
+        Select-Object -First 1 -ExpandProperty FullName
 
-    $BUILD_VERSION = $global:BUILD_VERSION
-    if ($BUILD_VERSION) {
-        Write-Output "BUILD_VERSION is already set: $BUILD_VERSION"
+    if (-not $folderPath) {
+        Write-Error "Directory matching 'ASP.NET Core' not found."
         return
     }
 
-    $BUILD_VERSIONS_LIST = "BUILD_VERSIONS_LIST"
-
-    $inputMajorMinor = $global:BRANCH_NAME -replace "\.\d+\+$", ""
-    Write-Output "Extracted major.minor version from branch name: $inputMajorMinor"
+    Write-Host "Found project directory: $folderPath"
+    Push-Location $folderPath
 
-    $filteredList = $global:ALL_VERSIONS | Where-Object {
-        ($_ -replace "\." -as [double]) -ge ($inputMajorMinor -replace "\." -as [double])
-    }
-    Write-Output "Filtered versions list: $filteredList"
+    try {
+        $resolvedNugetVersion = Resolve-NuGetVersionWithFallback -PackageName "DevExtreme.AspNet.Core" -RequestedVersion $buildVersion
+        if (-not $resolvedNugetVersion) {
+            throw "No valid version found for DevExtreme.AspNet.Core"
+        }
 
-    $currentValue = [Environment]::GetEnvironmentVariable($BUILD_VERSIONS_LIST, [EnvironmentVariableTarget]::Machine)
-    $currentList = if ($currentValue) {
-        $currentValue -split ";"
-    } else {
-        $filteredList
-    }
-    Write-Output "Current versions list: $currentList"
+        Write-Host "Installing DevExtreme.AspNet.Core@$resolvedNugetVersion..."
+        dotnet add package DevExtreme.AspNet.Core --version $resolvedNugetVersion
+
+        $packageJsonPath = Get-ChildItem -Path $folderPath -Filter "package.json" -Recurse -File -ErrorAction SilentlyContinue |
+            Select-Object -First 1 -ExpandProperty FullName
+
+        if ($packageJsonPath) {
+            Write-Host "Found package.json: $packageJsonPath"
+
+            try {
+                $packageJson = Get-Content -Path $packageJsonPath -Raw | ConvertFrom-Json
+                $updated = $false
+
+                if ($packageJson.dependencies.devextreme) {
+                    $validDevextremeVersion = Get-ValidNpmVersion -PackageName "devextreme" -Version $buildVersion
+                    if ($validDevextremeVersion) {
+                        $packageJson.dependencies.devextreme = $validDevextremeVersion
+                        $updated = $true
+                    }
+                }
+
+                if ($packageJson.dependencies.'devextreme-dist') {
+                    $validDevextremeDistVersion = Get-ValidNpmVersion -PackageName "devextreme-dist" -Version $buildVersion
+                    if ($validDevextremeDistVersion) {
+                        $packageJson.dependencies.'devextreme-dist' = $validDevextremeDistVersion
+                        $updated = $true
+                    }
+                }
+
+                if ($updated) {
+                    $packageJson | ConvertTo-Json -Depth 10 | Set-Content -Path $packageJsonPath -Encoding UTF8
+                    Write-Host "Updated package.json with valid versions."
+                } else {
+                    Write-Host "No matching dependencies found in package.json to update."
+                }
+
+                Write-Host "Installing NPM dependencies..."
+                npm install --save --save-exact --no-fund --loglevel=error
+                if (-not $?) {
+                    throw "Failed to install npm dependencies"
+                }
+            } catch {
+                Write-Error "Failed to update package.json: $_"
+            }
+        } else {
+            Write-Warning "No package.json file found in '$folderPath'."
+        }
 
-    if ($currentList.Count -gt 1) {
-        $inputMajorMinor = $currentList[0]
-        $updatedList = $currentList[1..($currentList.Count - 1)]
-    } else {
-        Write-Output "The list in the environment variable has only one item."
-        $inputMajorMinor = $currentList[0]
-        $updatedList = @()
+        Write-Host "Running dotnet build..."
+        dotnet build
+        if ($LASTEXITCODE -eq 0) {
+            Write-Host "Build succeeded."
+        } else {
+            throw
+        }
+    } catch {
+        Write-Error "An error occurred: $_"
+        $global:LASTEXITCODE = 1
+        $global:ERROR_CODE = 1
+        $global:FAILED_PROJECTS += "ASP.NET Core"
+    } finally {
+        Pop-Location
     }
-
-    $global:BUILD_VERSION = $inputMajorMinor
-    Write-Output "BUILD_VERSION set to: $global:BUILD_VERSION"
-
-    $newValue = $updatedList -join ";"
-    [Environment]::SetEnvironmentVariable($BUILD_VERSIONS_LIST, $newValue, [EnvironmentVariableTarget]::Machine)
-
-    Write-Output "Environment variable '$BUILD_VERSIONS_LIST' updated."
-    Write-Output "New list: $updatedList"
 }
 
 function Write-BuildInfo {
-    $BRANCH_NAME = if ($global:BRANCH_NAME -ne $null -and $global:BRANCH_NAME -ne "") { 
-        $global:BRANCH_NAME 
-    } else { 
-        "(empty)" 
-    }
-
-    $BUILD_VERSION = if ($global:BUILD_VERSION -ne $null -and $global:BUILD_VERSION -ne "") { 
-        $global:BUILD_VERSION 
-    } else { 
-        "(empty)" 
+    $BUILD_VERSION = if ($global:BUILD_VERSION -ne $null -and $global:BUILD_VERSION -ne "") {
+        $global:BUILD_VERSION
+    } else {
+        "(empty)"
     }
 
-    Write-Output "`nBranch Name: $BRANCH_NAME"
     Write-Output "Build Version: $BUILD_VERSION"
 }
 
 Write-BuildInfo
-Set-BuildVersion
 Process-JavaScriptProjects -buildVersion $global:BUILD_VERSION
-Process-DotNetProjects
+Process-AspNetCoreProject -buildVersion $global:BUILD_VERSION
 
 Write-Output "`nFinished testing version: $global:BUILD_VERSION. Error code: $global:ERROR_CODE"
 if ($global:ERROR_CODE -ne 0 -and $global:FAILED_PROJECTS.Count -gt 0) {