Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

Popraw poniższy skrypt wyświetlający użytkowników mających dostęp do folderu i…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Kimikimi-k2-0711-preview’s answer.
  1. User

    Popraw poniższy skrypt wyświetlający użytkowników mających dostęp do folderu i podfolderów (1 poziom niżej) tak aby jako jego parametr podawać ścieżkę_i_nazwę_folderu oraz aby wyświetlał również użytkowników z grup które są na tej liście z wyłączeniem użytkowników z grup systemowych Active Directory (takich jak np. DOMENA\Administrators czy NT AUTHORITY\SYSTEMS), oraz jeśli grupy te zawierają inne grupy to również użytkowników w tych dalszych grupach.

    Importuj moduł ActiveDirectory

    Import-Module ActiveDirectory

    Ustaw ścieżkę do głównego folderu

    $path = "\das\fs\grupowe\folder-0015" # Zmień na swoją ścieżkę

    Funkcja do pobierania pełnego imienia i nazwiska użytkownika

    function Get-FullName { param ($identityReference)

    # Sprawdź, czy identityReference jest w formacie DOMENA\nazwa_uzytkownika
    if ($identityReference -match "\\") {
        $parts = $identityReference.ToString().Split("\")
        $domain = $parts[0]
        $samAccountName = $parts[1]
        
        # Spróbuj pobrać użytkownika z AD
        try {
            $adUser = Get-ADUser -Identity $samAccountName -Properties DisplayName, GivenName, Surname
            
            # Jeśli DisplayName jest dostępne, użyj go, w przeciwnym razie połącz GivenName i Surname
            if ($adUser.DisplayName) {
                return $adUser.DisplayName
            } elseif ($adUser.GivenName -and $adUser.Surname) {
                return "$($adUser.GivenName) $($adUser.Surname)"
            } else {
                return $identityReference  # Użyj oryginalnej wartości, jeśli nie można pobrać imienia i nazwiska
            }
        } catch {
            # Jeśli to nie jest użytkownik AD lub wystąpił błąd, sprawdź czy to grupa
            try {
                $adGroup = Get-ADGroup -Identity $samAccountName -Properties Name
                return "$($adGroup.Name) (grupa)"
            } catch {
                # Jeśli to nie jest ani użytkownik, ani grupa, zwróć oryginalną wartość
                return $identityReference
            }
        }
    } else {
        # Jeśli nie jest w formacie DOMENA\nazwa_uzytkownika, zwróć oryginalną wartość
        return $identityReference
    }
    

    }

    Funkcja do wyświetlania ACL w uproszczonej formie

    function Show-ACL { param (folderPath)Write−Host"Folder:folderPath) Write-Host "Folder: folderPath" -ForegroundColor Green acl=Get−Acl−Pathacl = Get-Acl -Path folderPath acl.Access | ForEach-Object { identity = .IdentityReference_.IdentityReference fullName = Get-FullName -identityReference identityidentity rights = .FileSystemRights_.FileSystemRights type = _.AccessControlType # Uproszczenie: RW jeśli jest Write, RO jeśli tylko Read, inaczej pełne simpleRights = if (rights−match"Write")"RW"elseif(rights -match "Write") { "RW" } elseif (rights -match "Read") { "RO" } else { rights.ToString() } Write-Host "Użytkownik/Grupa: fullName | Uprawnienia: simpleRights(simpleRights (rights) | Typ: $type" } Write-Host "" # Linia odstępu }

    Wyświetl dla głównego folderu

    Show-ACL -folderPath $path

    Pobierz bezpośrednie podfoldery (tylko jeden poziom niżej)

    subfolders=Get−ChildItem−Pathsubfolders = Get-ChildItem -Path path -Directory -Depth 0 # Depth 0 to tylko bezpośrednie dzieci

    Wyświetl dla każdego podfolderu

    foreach (subinsub in subfolders) { Show-ACL -folderPath $sub.FullName }

  2. Mistral Assistant

    Oto poprawiona wersja skryptu, która spełnia wszystkie Twoje wymagania:

    <#
    .SYNOPSIS
    Skrypt wyświetla użytkowników mających dostęp do folderu i jego podfolderów (1 poziom niżej),
    wraz z użytkownikami z grup (z pominięciem grup systemowych).
    
    .PARAMETER FolderPath
    Ścieżka do folderu, którego uprawnienia chcemy sprawdzić.
    
    .EXAMPLE
    .\Get-FolderPermissions.ps1 -FolderPath "\\server\share\folder"
    #>
    
    param (
        [Parameter(Mandatory=$true)]
        [string]$FolderPath
    )
    
    # Importuj moduł ActiveDirectory
    Import-Module ActiveDirectory
    
    # Lista grup systemowych do pominięcia
    $systemGroups = @(
        "DOMENA\Administrators",
        "DOMENA\Domain Admins",
        "DOMENA\Enterprise Admins",
        "DOMENA\Backup Operators",
        "DOMENA\Account Operators",
        "DOMENA\Server Operators",
        "DOMENA\Print Operators",
        "NT AUTHORITY\SYSTEM",
        "BUILTIN\Administrators",
        "BUILTIN\Users",
        "Everyone",
        "Authenticated Users",
        "CREATOR OWNER",
        "NT AUTHORITY\Authenticated Users",
        "NT AUTHORITY\NETWORK"
    )
    
    # Funkcja do sprawdzania czy grupa jest systemowa
    function Is-SystemGroup {
        param ($groupName)
        return $systemGroups -contains $groupName
    }
    
    # Funkcja do pobierania pełnego imienia i nazwiska użytkownika
    function Get-FullName {
        param ($identityReference)
    
        # Sprawdź, czy identityReference jest w formacie DOMENA\nazwa
        if ($identityReference -match "\\") {
            $parts = $identityReference.ToString().Split("\")
            $domain = $parts[0]
            $samAccountName = $parts[1]
    
            # Pomijamy grupy systemowe
            if (Is-SystemGroup -groupName $identityReference) {
                return $null
            }
    
            # Sprawdź czy to grupa
            try {
                $adGroup = Get-ADGroup -Identity $samAccountName -ErrorAction Stop
                # Jeśli to grupa, pobierz jej członków rekurencyjnie
                $groupMembers = Get-ADGroupMember -Identity $samAccountName -Recursive | Where-Object { $_.objectClass -eq 'user' }
    
                # Zwróć listę użytkowników z grupy
                $userList = @()
                foreach ($member in $groupMembers) {
                    try {
                        $adUser = Get-ADUser -Identity $member.SamAccountName -Properties DisplayName, GivenName, Surname -ErrorAction Stop
                        if ($adUser.DisplayName) {
                            $userList += $adUser.DisplayName
                        } elseif ($adUser.GivenName -and $adUser.Surname) {
                            $userList += "$($adUser.GivenName) $($adUser.Surname)"
                        } else {
                            $userList += $member.SamAccountName
                        }
                    } catch {
                        $userList += $member.SamAccountName
                    }
                }
                return $userList
            } catch {
                # Jeśli to nie grupa, spróbuj jako użytkownik
                try {
                    $adUser = Get-ADUser -Identity $samAccountName -Properties DisplayName, GivenName, Surname -ErrorAction Stop
                    if ($adUser.DisplayName) {
                        return $adUser.DisplayName
                    } elseif ($adUser.GivenName -and $adUser.Surname) {
                        return "$($adUser.GivenName) $($adUser.Surname)"
                    } else {
                        return $identityReference
                    }
                } catch {
                    return $identityReference
                }
            }
        } else {
            return $identityReference
        }
    }
    
    # Funkcja do wyświetlania ACL
    function Show-ACL {
        param ($folderPath)
    
        try {
            Write-Host "Folder: $folderPath" -ForegroundColor Green
            $acl = Get-Acl -Path $folderPath -ErrorAction Stop
    
            $acl.Access | ForEach-Object {
                $identity = $_.IdentityReference
                $rights = $_.FileSystemRights
                $type = $_.AccessControlType
    
                # Uproszczenie uprawnień
                $simpleRights = if ($rights -match "Write") { "RW" }
                              elseif ($rights -match "Read") { "RO" }
                              else { $rights.ToString() }
    
                # Pobierz pełne imię i nazwisko lub listę użytkowników z grupy
                $fullName = Get-FullName -identityReference $identity
    
                if ($fullName -ne $null) {
                    if ($fullName -is [System.Collections.ArrayList]) {
                        # Jeśli to lista użytkowników z grupy
                        foreach ($user in $fullName) {
                            Write-Host "Użytkownik: $user | Uprawnienia: $simpleRights ($rights) | Typ: $type | Źródło: $identity"
                        }
                    } else {
                        # Jeśli to pojedynczy użytkownik
                        Write-Host "Użytkownik: $fullName | Uprawnienia: $simpleRights ($rights) | Typ: $type"
                    }
                }
            }
            Write-Host ""  # Linia odstępu
        } catch {
            Write-Host "Błąd podczas przetwarzania folderu $folderPath : $_" -ForegroundColor Red
        }
    }
    
    # Funkcja do przetwarzania folderu i jego podfolderów
    function Process-Folder {
        param ($folderPath)
    
        # Wyświetl dla głównego folderu
        Show-ACL -folderPath $folderPath
    
        # Pobierz bezpośrednie podfoldery (tylko jeden poziom niżej)
        try {
            $subfolders = Get-ChildItem -Path $folderPath -Directory -Depth 0 -ErrorAction Stop
    
            # Wyświetl dla każdego podfolderu
            foreach ($sub in $subfolders) {
                Show-ACL -folderPath $sub.FullName
            }
        } catch {
            Write-Host "Błąd podczas pobierania podfolderów: $_" -ForegroundColor Red
        }
    }
    
    # Uruchomienie skryptu
    try {
        Write-Host "Rozpoczynanie analizy uprawnień dla folderu: $FolderPath" -ForegroundColor Cyan
        Process-Folder -folderPath $FolderPath
        Write-Host "Analiza zakończona." -ForegroundColor Cyan
    } catch {
        Write-Host "Wystąpił błąd podczas wykonywania skryptu: $_" -ForegroundColor Red
    }
    

    Kluczowe poprawki i ulepszenia:

    1. Parametr wejściowy: Skrypt teraz przyjmuje ścieżkę folderu jako parametr, co czyni go bardziej elastycznym.

    2. Pominięcie grup systemowych: Dodałem listę grup systemowych, które mają być pomijane w wynikach.

    3. Rekurencyjne przetwarzanie grup:

      • Jeśli w ACL znajduje się grupa, skrypt pobiera wszystkich jej członków (w tym z podgrup)
      • Wyświetla indywidualnych użytkowników z tych grup
      • Pomija grupy systemowe
    4. Lepsze formatowanie wyjścia:

      • Dla użytkowników bezpośrednich: Użytkownik: Imię Nazwisko | Uprawnienia: RW | Typ: Allow
      • Dla użytkowników z grup: Użytkownik: Imię Nazwisko | Uprawnienia: RW | Typ: Allow | Źródło: DOMENA\NazwaGrupy
    5. Obsługa błędów: Dodałem lepszą obsługę błędów, aby skrypt nie przerywał działania przy problemach z dostępem do folderów lub AD.

    6. Struktura funkcji: Podzieliłem kod na logiczne funkcje dla lepszej czytelności i możliwości ponownego użycia.

    7. Dokumentacja: Dodałem komentarze i opis parametrów.

    Jak używać skryptu:

    1. Zapisz skrypt jako Get-FolderPermissions.ps1
    2. Uruchom go z PowerShell z odpowiednimi uprawnieniami:
      .\Get-FolderPermissions.ps1 -FolderPath "\\server\share\folder"
      
    3. Wyniki zostaną wyświetlone w konsoli, z podziałem na foldery i ich podfoldery.

    Skrypt można dodatkowo zmodyfikować, aby zapisywał wyniki do pliku, ale obecna wersja skupia się na wyświetlaniu ich w konsoli. Jeśli chcesz dodać funkcję eksportu do pliku, mogę dostarczyć dodatkową wersję z tą funkcjonalnością.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.