ci-pipeline/dotnet-pipeline.yml

skip_clone: true
when:
  event: pull_request
  action:
    - merge
  branch: master
steps:
  debug-location:
    image: alpine
    commands:
      - pwd
      - ls -la
      - find /woodpecker -maxdepth 4 -type d 2>/dev/null
  clone-manual:
    image: woodpeckerci/plugin-git
    settings:
      remote: http://gitea:3000/${CI_REPO}.git
      branch: ${CI_COMMIT_BRANCH}
      depth: 1
  restore:
    image: mcr.microsoft.com/dotnet/sdk:latest
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        echo "Aktualna ścieżka do pliku: $(pwd)"
        echo "=== Restore wszystkich projektów ==="
        find . -name "*.csproj" -type f -exec dotnet restore "{}" \;
  test:
    image: mcr.microsoft.com/dotnet/sdk:latest
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        echo "=== Uruchamianie testów ==="
        dotnet test --no-restore --configuration Release --logger "trx"
    depends_on: [restore]
  pack-datamodels:
    image: mcr.microsoft.com/dotnet/sdk:latest
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        echo "=== Instalacja MinVer CLI ==="
        dotnet tool install --tool-path /tmp/minver minver-cli
        echo "=== Obliczona wersja przez MinVer ==="
        MINVER_VERSION=$(/tmp/minver/minver \
          --auto-increment patch \
          --minimum-major-minor 2.0 \
          --default-pre-release-identifiers alpha.0 \
          --verbosity info)
        echo "Wersja: $MINVER_VERSION"
        mkdir -p nupkg
        echo "=== Pełniejsze fetch git (unshallow + tags) ==="
        git fetch --prune --unshallow || echo "Już full clone – OK"
        git fetch --tags
        echo "=== Dostępne tagi ==="
        git tag -l
        echo "=== Aktualny commit i opis ==="
        git describe --tags --always --dirty
        echo "=== Diagnostyka projektów ==="
        find . -name "*.csproj" -type f | sort
        mkdir -p nupkg
        echo "=== Pakowanie projektów DataModel (wykrywane po obecności <PackageId>) ==="
        find . -name "*.csproj" -type f | while read csproj; do
          if grep -q '<PackageId>' "$csproj"; then
            PROJECT_NAME=$(basename "$csproj" .csproj)
            echo "→ Pakuję $PROJECT_NAME ($csproj)"
            dotnet pack "$csproj" \
              --configuration Release \
              -o "./nupkg" \
              /p:PackageVersion=$MINVER_VERSION
          else
            PROJECT_NAME=$(basename "$csproj" .csproj)
            echo "→ Pomijam $PROJECT_NAME – brak <PackageId>"
          fi
        done
        echo "=== Spakowane pakiety ==="
        ls -la nupkg/ || echo "Brak spakowanych pakietów!"
    depends_on: [test]
  
  publish-linux-local:
    image: mcr.microsoft.com/dotnet/sdk:latest
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        mkdir -p linux-apps

        echo "=== Konfiguracja NuGet sources ==="
        cat <<EOF > NuGet.Config
        <?xml version="1.0" encoding="utf-8"?>
        <configuration>
          <packageSources>
            <clear />
            <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
            <add key="BaGet" value="http://baget:80/v3/index.json" allowInsecureConnections="true" />
          </packageSources>
        </configuration>
        EOF
        
        echo "=== Publikacja aplikacji LinuxLocal ==="
        find . -name "*.csproj" -type f | while read csproj; do
          PROJECT_TYPE=$(dotnet msbuild "$csproj" -getProperty:ProjectType -noLogo 2>/dev/null || echo "Unknown")
        
          if [ "$PROJECT_TYPE" = "LinuxLocal" ]; then
            PROJECT_NAME=$(basename "$csproj" .csproj)
            echo "→ Publishing $PROJECT_NAME"
        
            dotnet publish "$csproj" \
              --configuration Release \
              --output "./linux-apps/$PROJECT_NAME" \
              --runtime linux-x64 \
              --self-contained false
          fi
        done
        
        echo ""
        if [ -d "./linux-apps" ] && [ "$(ls -A ./linux-apps)" ]; then
          echo "Opublikowane aplikacje:"
          ls -la linux-apps/
        else
          echo "Brak aplikacji LinuxLocal do publikacji"
        fi
    depends_on: [restore]
  
  publish-datamodels-to-baget:
    image: mcr.microsoft.com/dotnet/sdk:latest
    environment:
      BAGETTER_API_KEY:
        from_secret: baget_api_key
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        echo "=== Test połączenia z BaGetter ==="
        curl -f http://baget:80/v3/index.json || echo "Nie można połączyć się z BaGetter!"
        cat <<EOF > NuGet.Config
        <?xml version="1.0" encoding="utf-8"?>
        <configuration>
          <packageSources>
            <clear />
            <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
            <add key="BaGet" value="http://baget:80/v3/index.json" allowInsecureConnections="true" />
          </packageSources>
        </configuration>
        EOF
        echo "=== Publikacja pakietów do BaGetter ==="
        find ./nupkg -name "*.nupkg" -type f | while read pkg; do
          echo "→ Push $(basename "$pkg")"
          dotnet nuget push "$pkg" \
            --source "BaGet" \
            --api-key "$BAGETTER_API_KEY" \
            --skip-duplicate
        done
    depends_on: [pack-datamodels]
  
  select-projects-for-container:
    image: mcr.microsoft.com/dotnet/sdk:latest
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        > projects-to-build.txt
        
        echo "=== Selekcja projektów do konteneryzacji ==="
        find . -name "*.csproj" -type f | while read csproj; do
          PROJECT_NAME=$(basename "$csproj" .csproj)
          PROJECT_TYPE=$(dotnet msbuild "$csproj" -getProperty:ProjectType -noLogo 2>/dev/null || echo "Unknown")
        
          if [ "$PROJECT_TYPE" = "Linux" ] || [ "$PROJECT_TYPE" = "Api" ] || [ "$PROJECT_TYPE" = "ServerProcess" ] || [ "$PROJECT_TYPE" = "Blazor" ] || [ "$PROJECT_TYPE" = "LinuxLocal" ]; then
            PROJECT_DIR=$(dirname "$csproj")
            echo "→ Dodaję $PROJECT_NAME (typ: $PROJECT_TYPE)"
            echo "$PROJECT_DIR|$PROJECT_NAME" >> projects-to-build.txt
          else
            echo "→ Pomijam $PROJECT_NAME (typ: $PROJECT_TYPE)"
          fi
        done
        
        echo ""
        if [ -s projects-to-build.txt ]; then
          echo "Znalezione projekty:"
          cat projects-to-build.txt
          echo "Łącznie: $(wc -l < projects-to-build.txt)"
        else
          echo "BRAK PROJEKTÓW DO BUDOWY!"
        fi
    depends_on: [publish-datamodels-to-baget]
  
  containerize-apps:
    image: docker:27-cli
    environment:
      GITEA_USER:
        from_secret: gitea_registry_user
      GITEA_TOKEN:
        from_secret: gitea_registry_token
    commands:
      - |
        set -euf
        cd "${CI_WORKSPACE}"
        
        REGISTRY_ORG="fa"
        
        echo "=== DEBUG: Zawartość projects-to-build.txt ==="
        cat projects-to-build.txt || echo "Plik nie istnieje!"
        echo "=== DEBUG: REGISTRY_ORG = '$REGISTRY_ORG' ==="
        
        echo "$GITEA_TOKEN" | docker login git.modwad.pl -u "$GITEA_USER" --password-stdin
        
        if [ ! -s projects-to-build.txt ]; then
          echo "Brak projektow"
          exit 0
        fi
        
        rm -f NuGet.Config
        
        cat > NuGet.Config <<EOF
        <?xml version="1.0" encoding="utf-8"?>
        <configuration>
          <packageSources>
            <clear />
            <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
            <add key="BaGet" value="http://127.0.0.1:8080/v3/index.json" />
          </packageSources>
        </configuration>
        EOF
        
        cat projects-to-build.txt | while IFS='|' read -r PDIR PNAME; do
          PDIR=$(echo "$PDIR" | xargs)
          PNAME=$(echo "$PNAME" | xargs)
        
          echo "=== DEBUG: PDIR='$PDIR' PNAME='$PNAME' ==="
        
          test -z "$PNAME" && continue
          test ! -d "$PDIR" && continue
        
          echo -n "git.modwad.pl/fa/" > /tmp/tag.txt
          echo "$PNAME" | tr 'A-Z' 'a-z' | tr -d '\n' >> /tmp/tag.txt
        
          echo "=== DEBUG: Generated tag: $(cat /tmp/tag.txt) ==="
        
          echo "$PNAME" > /tmp/pname.txt
          echo "$PDIR" | sed 's|^\./||' > /tmp/pdir.txt
        
          cat > "Dockerfile.temp" <<'ENDOFDOCKERFILE'
        FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
        WORKDIR /app
        EXPOSE 8080
        FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
        WORKDIR /src
        COPY . .
        RUN dotnet restore "%%PROJECTDIR%%/%%PROJECTNAME%%.csproj"
        RUN dotnet publish "%%PROJECTDIR%%/%%PROJECTNAME%%.csproj" -c Release -o /app/publish /p:UseAppHost=false --no-restore
        FROM base AS final
        WORKDIR /app
        COPY --from=build /app/publish .
        ENV ASPNETCORE_URLS=http://+:8080
        ENTRYPOINT ["dotnet", "%%PROJECTNAME%%.dll"]
        ENDOFDOCKERFILE
        
          REAL_PNAME=$(cat /tmp/pname.txt)
          REAL_PDIR=$(cat /tmp/pdir.txt)
          sed "s|%%PROJECTNAME%%|$REAL_PNAME|g; s|%%PROJECTDIR%%|$REAL_PDIR|g" "Dockerfile.temp" > "Dockerfile.final"
        
          echo "=== Budowanie obrazu ==="
          DOCKER_BUILDKIT=0 docker build \
            --network=host \
            -t "$(cat /tmp/tag.txt):${CI_COMMIT_SHA}" \
            -t "$(cat /tmp/tag.txt):latest" \
            -f "Dockerfile.final" \
            .
        
          echo "=== Pushing SHA tag ==="
          docker push "$(cat /tmp/tag.txt):${CI_COMMIT_SHA}"
        
          echo "=== Pushing latest tag ==="
          docker push "$(cat /tmp/tag.txt):latest"
        
          echo "=== SUCCESS: $(cat /tmp/tag.txt) ==="
        
          rm -f "Dockerfile.temp" "Dockerfile.final"
        done
        
        echo "=== WSZYSTKIE PROJEKTY ZAKONCZONE ==="
    depends_on: [select-projects-for-container]
  
  deploy-linux-local:
    image: alpine:latest
    commands:
      - |
        cd "${CI_WORKSPACE}"
        
        echo "=== Sprawdzanie aplikacji LinuxLocal ==="
        if [ ! -d "./linux-apps" ]; then
          echo "Folder ./linux-apps nie istnieje"
          exit 0
        fi
        
        echo "=== DEBUG: Zawartość ./linux-apps/ ==="
        ls -la ./linux-apps/
        
        echo "=== Wdrażanie aplikacji LinuxLocal do /opt/fa-apps/ ==="
        mkdir -p /opt/fa-apps
        
        cd ./linux-apps
        
        for app in *; do
          echo "→ DEBUG: Sprawdzam $app"
          
          if [ ! -d "$app" ]; then
            echo "  → $app nie jest folderem, pomijam"
            continue
          fi
          
          echo "  → Kopiuję $app"
          echo "  → Zawartość:"
          ls -la "$app/"
          
          rm -rf "/opt/fa-apps/$app"
          cp -r "$app" "/opt/fa-apps/$app"
          
          find "/opt/fa-apps/$app" -type f -executable -exec chmod +x {} \;
          
          echo "  → Skopiowano!"
        done
        
        cd "${CI_WORKSPACE}"
        
        echo ""
        echo "=== Wdrożone aplikacje ==="
        ls -laR /opt/fa-apps/
    depends_on: [publish-linux-local, containerize-apps]
  
  cleanup-docker:
    image: docker:27-cli
    commands:
      - |
        echo "=== Status przed czyszczeniem ==="
        docker system df
        
        echo ""
        echo "=== Usuwanie dangling images ==="
        docker image prune -f
        
        echo ""
        echo "=== Usuwanie starych wersji aplikacji ==="
        docker images --format "{{.Repository}}:{{.Tag}}" | grep "git.modwad.pl/" | grep -v ":latest" | grep -v ":${CI_COMMIT_SHA}" | while read img; do
          echo "Usuwam: $img"
          docker rmi "$img" || true
        done
        
        echo ""
        echo "=== Usuwanie kontenerów ==="
        docker container prune -f
        
        echo ""
        echo "=== Usuwanie build cache ==="
        docker builder prune -af
        
        echo ""
        echo "=== Status po czyszczeniu ==="
        docker system df
    depends_on: [deploy-linux-local]
    when:
      status: [success, failure]