El Blog de Gualtrysoft

Windows 2000/2003/2008, Active Directory, VBScript, Hyper-V, PowerShell y todo aquello interesante a la hora de usar, configurar y administrar Windows Server. También tenemos longanizas…

PowerShell: Cmdlet para mostrar la información de una clase de Active directory

Posted by urpiano en Martes 21 \21\UTC febrero \21\UTC 2012

Al hilo de mi entrada anterior PowerShell Tip: Cómo Enumerar Todas las Propiedades de una Clase de Active Directory, he desarrollado este Cmdlet que nos permite pasarle uno o varios nombres de clases de Active Directory y obtener la información respecto a ellas que hay en el esquema.

Con esta información sabremos los identificadores, propiedades requeridas y opcionales y las clases derivadas, así como las propiedades que están incluídas en los catálogos globales de nuestro bosque. El Cmdlet debe ser lanzado desde un equipo perteneciente al bosque del cuál se quiere obtener la información.

El Cmdlet incluye ayuda, pego a continuación la ayuda con modificador -Detailed (esta ayuda se basa en la prestación de ayuda basada en comentarios de PowerShell 2.0 ¿Qué todavía tienes la versión 1.0 y no la 2.0? ¿A qué esperas para instalarla si es mucho mejor?¿También echas de menos los tiempos en que para viajar se iba en calesa?):

NOMBRE
    Get-AdSchemaClass
    
SINOPSIS
    Muestra la información de una o varias clases en el esquema de Active
    Directorty.
    
SINTAXIS
    Get-AdSchemaClass [[-Class] <String[]>] [[-User] <String>] [[-Password] <String>] [<CommonParamet
    ers>]
    
DESCRIPCIÓN
    Este Cmdlet permite obtener la información de una o varias clases en el
    esquema de Active Directory (posibles antecesores y sucesores, propiedades,
    clases auxiliares, etc.). La función recibe como parámetro uno o más nombres de
    clases; también puede recibir los nombres de las clases a mostrar por
    canalización. Permite, a su vez, conectar al esquema con unas credenciales
    alternativas).

PARÁMETROS
    -Class <String[]>
        Nombre de la clase de la que se obtendrá la información. Puede ser un
        array de nombres o ser pasado por canalización. Este parámetro admite el alias
        "C".
        
    -User <String>
        Nombre de usuario con el que se conectará al esquema. En caso de
        omitirse, se conectará con las credenciales del usuario que lanza el Cmdlet.
        Este parámetro admite el alias "U".
        
    -Password <String>
        Contraseña del usuario con el que se conectará al esquema. En caso de
        omitirse el usuario, se conectará con las credenciales del usuario que lanza el
        Cmdlet. Este parámetro admite el alias "P".
        
    <CommonParameters>
        Este cmdlet admite los parámetros comunes Verbose, Debug,
        ErrorAction, ErrorVariable, WarningAction, WarningVariable,
        OutBuffer y OutVariable. Para obtener más información, escriba:
        "get-help about_commonparameters".
    
    -------------------------- EJEMPLO 1 --------------------------
    
    PS C:\>Get-AdSchemaClass -Class user
    
    Muestra la información de la clase user.
    
    -------------------------- EJEMPLO 2 --------------------------
    
    PS C:\>Get-AdSchemaClass -C InetOrgPerson,contact -U Bacterio -P "Ofelia Foca"
    
    Muestra la información de las clases InetOrgPerson y contact conectando
    al esquema con el usuario "Bacterio" cuya contraseña es "Ofelia Foca".
    
    -------------------------- EJEMPLO 3 --------------------------
    
    PS C:\>"user","top","OrganizationalUnit" | Get-AdSchemaClass
    
    Muestra la información de las clases user, top y OrganizationalUnit,
    recibiendo los nombres de estas tres clases por canalización.
    
NOTAS
    Para ver los ejemplos, escriba: "get-help Get-AdSchemaClass -examples".
    Para obtener más información, escriba: "get-help Get-AdSchemaClass -detailed".
    Para obtener información técnica, escriba: "get-help Get-AdSchemaClass -full".

Este es el código del Cmdlet:

Function Get-AdSchemaClass(
                            [parameter(ValueFromPipeLine=$true)]
                            [Alias("C")]
                            [String[]]$Class,
                            [Alias("U")]
                            [String]$User,
                            [Alias("P")]
                            [String]$Password
                          )
{
    Begin
    {
        # Iniciamos el contador de clases procesadas
        $NClases = 0
        
        # Obtenemos el bosque en el que nos encontramos
        $Bosque = `
           [System.DirectoryServices.ActiveDirectory.Forest]::GetCurrentForest()

        # Creamos una variable con el tipo de contexto de directorio como bosque
        $TipoContexto = `
         [System.DirectoryServices.ActiveDirectory.DirectoryContextType]::Forest

        # Si no hay que pasar credenciales alternativas
        If([System.String]::IsNullOrEmpty($User))
        {
            # Creamos el contexto sin pasr credenciales
            $Contexto = New-Object `
                    System.DirectoryServices.ActiveDirectory.DirectoryContext( `
                                                          $TipoContexto,$Bosque)
        }
        # Hay que pasar credenciales alternaticas
        Else
        {
            # Creamos el contexto con las credenciales suministradas
            $Contexto = New-Object `
                    System.DirectoryServices.ActiveDirectory.DirectoryContext( `
                              $TipoContexto,$Bosque,"admin05251804f","Perico69")
        }
        
        # Accedemos al esquema
        $Esquema = `
  [System.DirectoryServices.ActiveDirectory.ActiveDirectorySchema]::GetSchema( `
                                                                      $Contexto)
    }
    Process
    {
        # Recorremos las clases recibidas; como el parámetro Class es un array
        # de cadenas en el que se pueden pasar varios nombres de clases de AD,
        # es necesario recorrer este parámetro con este bucle. Si se reciben
        # varias clases por encaminamiento este bucle tan sólo dará una vuelta
        # pero ejecutará todo el bloque Process completo por cada una de los
        # nombres de clases pasados
        ForEach($Cls In $Class)
        {
            # Recorremos una a una todas las clases definidas en el esquema
            $Clase = $Esquema.FindClass($Cls)
            # Incrementamos el contador de clases
            $NClases++
            # Mostramos las propiedades de la definición de la clase
            ""
            "*" * (10 + $Clase.Name.Length)
            "* Clase " + "$($Clase.Name)".ToUpper() + " *"
            "*" * (10 + $Clase.Name.Length)
            "CommonName        `: $($Clase.CommonName)"
            "Description       `: $($Clase.Description)"
            "IsDefunct         `: $($Clase.IsDefunct)"
            "Name              `: $($Clase.Name)"
            "Oid               `: $($Clase.Oid)"
            # Tanto PossibleInferiors como PossibleSuperiors son arrays; para
            # que se muestren los elementos como una lista hacemos join de los
            # arrays y como elemento de unión ponemos salto de línea y los
            # espacios a los que quedan los datos del margen izquierdo (son 20)
            "PossibleInferiors `: " `
                     + "$($Clase.PossibleInferiors -join ("`r`n" + (" " * 20)))"
            "PossibleSuperiors `: " `
                     + "$($Clase.PossibleSuperiors -join ("`r`n" + (" " * 20)))"
            "SchemaGuid        `: $($Clase.SchemaGuid)"
            "SubClassOf        `: $($Clase.SubClassOf)"
            "Type              `: $($Clase.Type)"
            ""
            # Vamos a mostrar las propiedades de la clase, y las mostraremos en
            # forma de tabla con los campos que se ven a continuación
            $Propiedades = "Syntax","IsSingleValued","IsIndexed", `
                           "IsInGlobalCatalog","Name"
            # Primero mosraremos las propiedades requeridas
            "Propiedades Requeridas"
            "======================"
            $Clase.MandatoryProperties | Format-Table $Propiedades `
                                                                 -AutoSize -Wrap
            ""
            # Ahora mostraremos las propiedades opcionales
            "Propiedades Opcionales"
            "======================"
            $Clase.OptionalProperties | Format-Table $Propiedades   `
                                                                 -AutoSize -Wrap
            ""
            # Por último, mostraremos las clases auxiliares en formato tabla con
            # los campos definidos a continuación
            $Propiedades = "Name","IsDeFunct","Type","SchemaGuid"
            "Clases Auxiliares"
            "================="
            $Clase.AuxiliaryClasses | Format-Table $Propiedades -AutoSize -Wrap

            # Optenemos el total de propiedades de la clase (requeridas más
            # opcionales).
            $TotalPropiedades = $Clase.MandatoryProperties.Count + `
                                $Clase.OptionalProperties.Count

            # Obtenemos cuántos caracteres ocupa el total de propiedades una vez
            # ha sido aplicado el formato de número con separadores de miles y
            # sin decimales.
            $NDigitosProp = "$("{0:N0}" -f $TotalPropiedades)".Length
            # Obtenemos cuántos caracteres ocupa el total de propiedades
            # requeridas una vez ha sido aplicado el formato de número con
            # separadores de miles y sin decimales.
            $NDigitosMand = `
                        "$("{0:N0}" -f $Clase.MandatoryProperties.Count)".Length
            # Obtenemos cuántos caracteres ocupa el total de propiedades
            # opcionales una vez ha sido aplicado el formato de número con
            # separadores de miles y sin decimales.
            $NDigitosOpc = `
                         "$("{0:N0}" -f $Clase.OptionalProperties.Count)".Length
            # Obtenemos cuántos caracteres ocupa el total de clases auxiliares
            # una vez ha sido aplicado el formato de número con separadores de
            # miles y sin decimales.
            $NDigitosAux = "$("{0:N0}" -f $Clase.AuxiliaryClasses.Count)".Length
            
            # Los anteriores recuentos de número de caracteres de las cifras una
            # vez formateadas los usaremos para poder alinear estas cifras a la
            # derecha. Es necesario que sepamos cuál de estos recuentos es el
            # que implica el mayor número de caracters. Obviamente, sólo puede
            # estar entre el total de propiedades y el de número de clases
            # auxiliares.
            # Cuando es superior el número de caracteres del total de clases
            # auxiliares, este será el número máximo de caracteres.
            If($NDigitosProp -lt $NDigitosAux)
            {
                $NDigitos = $NDigitosAux
            }
            # En caso contrario, el número máximo de caracteres será el del
            # total de propiedades
            Else
            {
                $NDigitos = $NDigitosProp
            }
            
            # Obtenemos la longitud total de la línea que se mostrará en el
            # cuadro donde están los recuentos. Éste es la longitud de los
            # encabezados más el número de caracteres máximo de los recuentos
            # más 7, que son los caracteres propios del marco y su margen.
            $Longitud = "Total Propiedades de $($Clase.Name)      `:".Length `
                             + "$(" " * ($NDigitos - $NDigitosProp))" `
                             + "$("{0:N0}" -f $TotalPropiedades)".Length + 7
            # Ponemos el marco superior
            "%" * $Longitud
            # Vamos a mostrar un recuento del número de clases auxiliares, de
            # propiedades requeridas, opcionales y del total de propiedades
            "% Clases auxiliares de `"$($Clase.Name)`"      `: " `
                             + "$(" " * ($NDigitos - $NDigitosAux))" `
                             + "$("{0:N0}" -f $Clase.AuxiliaryClasses.Count) %"
            "% Propiedades Requeridas de `"$($Clase.Name)`" `: " `
                             + "$(" " * ($NDigitos - $NDigitosMand))" `
                             + "$("{0:N0}" -f $Clase.MandatoryProperties.Count) %"
            "% Propiedades opcionales de `"$($Clase.Name)`" `: " `
                             + "$(" " * ($NDigitos - $NDigitosOpc))" `
                             + "$("{0:N0}" -f $Clase.OptionalProperties.Count) %"
            "% Total Propiedades de `"$($Clase.Name)`"      `: " `
                             + "$(" " * ($NDigitos - $NDigitosProp))" `
                             + "$("{0:N0}" -f $TotalPropiedades) %"
            # Ponemos el marco inferior
            "%" * $Longitud
            # Ponemos un salto de línea que separe una clase de otra
            ""
        }
    }
    End
    {
        # Mostramos el total de clases encontradas
        "`r`nTotal Clases enumeradas `: $NClases"
    }

<#
    .SYNOPSIS
        Muestra la información de una o varias clases en el esquema de Active
Directorty.

    .DESCRIPTION
        Este Cmdlet permite obtener la información de una o varias clases en el
esquema de Active Directory (posibles antecesores y sucesores, propiedades,
clases auxiliares, etc.). La función recibe como parámetro uno o más nombres de
clases; también puede recibir los nombres de las clases a mostrar por
canalización. Permite, a su vez, conectar al esquema con unas credenciales
alternativas).

    .PARAMETER  Class
        Nombre de la clase de la que se obtendrá la información. Puede ser un
array de nombres o ser pasado por canalización. Este parámetro admite el alias
"C".

    .PARAMETER  User
        Nombre de usuario con el que se conectará al esquema. En caso de
omitirse, se conectará con las credenciales del usuario que lanza el Cmdlet.
Este parámetro admite el alias "U".

    .PARAMETER  Password
        Contraseña del usuario con el que se conectará al esquema. En caso de
omitirse el usuario, se conectará con las credenciales del usuario que lanza el
Cmdlet. Este parámetro admite el alias "P".

    .EXAMPLE
        PS C:\> Get-AdSchemaClass -Class user
        Muestra la información de la clase user.

    .EXAMPLE
        PS C:\> Get-AdSchemaClass -C InetOrgPerson,contact -U Bacterio -P "Ofelia Foca"
        Muestra la información de las clases InetOrgPerson y contact conectando
al esquema con el usuario "Bacterio" cuya contraseña es "Ofelia Foca".

    .EXAMPLE
        PS C:\> "user","top","OrganizationalUnit" | Get-AdSchemaClass
        Muestra la información de las clases user, top y OrganizationalUnit,
recibiendo los nombres de estas tres clases por canalización.

    .INPUTS
        System.String[],System.String

    .OUTPUTS
        System.String

    .NOTES
        Fernando Reyes López © 02/2012

    .LINK
        http://freyes.svetlian.com

    .LINK
        https://urpiano.wordpress.com

#>
}

Una respuesta to “PowerShell: Cmdlet para mostrar la información de una clase de Active directory”

  1. rafael lopez said

    en una traduccion de ingles, -en los escritos- de algunas palabras quedan muy separadas unas de otra No puedo unirlas

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: