Dienstag, 6. November 2018

IEnumerable-ToList() - alternative in PowerShell

Jeder weiß (oder lernt schnell), dass ein IEnumerable nicht verändert werden darf, während es durchlaufen wird.
Speziell im SharePoint-Bereich gilt also, wenn man das folgende in PowerShell versucht:

(Get-SPSite http://mein.sharepoint).AllWebs `
  | select -ExpandProperty Lists `
  | select -ExpandProperty Fields `
  | %{ $_.Update() }

Führt dies zu einer Menge von Fehlern die wie folgt aussehen:
An error occurred while enumerating through a collection: Collection was modified; enumeration operation may not execute.....

In C# würde ich einfach ToList() einstreuen. Dies würde dazu führen, dass eine flache Kopie des IEnumerable erstellt wird und in weiteren Verarbeitungen der Liste dieser Fehler nicht auftritt.
(Es führt natürlich auch dazu, dass der Enumerator an dieser Stelle vollständig durchlaufen wird, und man all die schönen Vorteile des IEnumerables (d.h. "Lazy Evaluation") verliert)

Eine schöne PowerShell-alternative zu ToList() ist im PowerShell Team Blog verfügbar:

function ToArray {
  begin {
    $output = @(); 
  }
  process {
    $output += $_; 
  }
  end {
    return ,$output; 
  }
}

Dadurch sieht der Aufruf dann wie folgt aus:

(Get-SPSite http://mein.sharepoint).AllWebs `
  | select -ExpandProperty Lists `
  | select -ExpandProperty Fields `
  | ToArray `
  | %{ $_.Update() }

und Funktioniert fehlerfrei.


Mittwoch, 15. August 2018

Papierkörbe einer WebApplication Auflisten & Löschen

​Zur "Bereinigung" einer WebApplication kann man dann- und wann mal die Paprierkörbe ansehen und-/oder löschen.

Ich habe da mal ein keines Skript dazu Vorbereitet:
<# 
.SYNOPSIS  
    List or Remove elements from RecycleBin(s) of a WebApplication 
.DESCRIPTION  
    This script lists- and optionally removes all items from all RecycleBins 
    of a WebApplication, including the End-Users (1st Stage) and 
    Administrators (2nd Stage) RecycleBins.
.NOTES  
    File Name  : Delete-Site-Recycle-Bin.ps1  
    Author     : Nils Andresen - nils.andresen@adesso.de    
.Example
    .\Empty-SPRecycleBin.ps1 -WebApp http://sp.dev/ -FirstStageCleanup RemovePermanent -SecondStageCleanup RemovePermanent
    Removes all deleted items (1st and 2nd stage) from all Sites/Webs of the WebApplication
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory=$True, HelpMessage = "Url to the WebApp")]
    [string]$WebApp,
 
    [Parameter(HelpMessage = "What to do with the 1st-stage Recycle Bins")]
    [ValidateSet("ListOnly", "MoveTo2nd", "RemovePermanent")]
    [string]$FirstStageCleanup = "ListOnly",
 
    [Parameter(HelpMessage = "What to do with the 2nd-stage Recycle Bins")]
    [ValidateSet("ListOnly", "RemovePermanent")]
    [string]$SecondStageCleanup = "ListOnly"
)
 
if((Get-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue) -eq $null) {
    Add-PSSnapin Microsoft.SharePoint.PowerShell
}
 
$Global:TotalRemovedSize = 0;
 
function Format-ForPc {
[CmdletBinding()]
param(
    [Parameter(Position=0, 
        Mandatory=$true, 
        ValueFromPipeline=$true,
        ValueFromPipelineByPropertyName=$true)]
    [int]$size
)
    if($size -lt 1MB) {
        return "{0:0.0#}KB" -f ($size / 1KB);
    } 
    if($size -lt 1GB) {
        return "{0:0.0#}MB" -f ($size / 1MB);
    } 
    if($size -lt 1TB) {
        return "{0:0.0#}GB" -f ($size / 1GB);
    } 
    return "{0:0.0#}TB" -f ($size / 1TB);
}
 
function Process-Web {
[CmdletBinding()]
param(
    [Parameter(Position=0, 
        Mandatory=$true, 
        ValueFromPipeline=$true,
        ValueFromPipelineByPropertyName=$true)]
    [Microsoft.SharePoint.SPWeb[]]$web
)
Process {
    Write-Verbose "Accessing Web: $($web.Url)";
 
    if((-not $web.RecycleBinEnabled) -or ($web.RecycleBin.Count -lt 1)) {
        return;
    }
    $size = 0;
    $web.RecycleBin | %{ $size += $_.Size }
 
    Write-Output "Web $($web.Title) has $($web.RecycleBin.Count) items ($($size | Format-ForPc)) in Users-RecycleBin";          
         
    switch ($FirstStageCleanup) {
        "ListOnly" {
            $web.RecycleBin | %{ Write-Output "- $($_.ItemType):$($_.Title) ($($_.Size | Format-ForPc), Deleted by $($_.DeletedByName))" }
        }
        "RemovePermanent" {
            $web.RecycleBin.DeleteAll();
            $Global:TotalRemovedSize += $size;
            Write-Output "- Deleted permanently";
        }
        "MoveTo2nd" {
            $web.RecycleBin.MoveAllToSecondStage();
            Write-Output "- Moved to second stage";
        }
    }
}
}
 
function Process-Site {
[CmdletBinding()]
param(
    [Parameter(Position=0,
        Mandatory=$true, 
        ValueFromPipeline=$true,
        ValueFromPipelineByPropertyName=$true)]
    [Microsoft.SharePoint.SPSite[]]$site
)
Process {
    Write-Verbose "Accessing Site: $($site.Url)";
 
    $secondStage = $site.RecycleBin | ? { $_.ItemState -eq [Microsoft.SharePoint.SPRecycleBinItemState]::SecondStageRecycleBin }
 
    $site.AllWebs | Process-Web
 
    if($secondStage.length -lt 1) {
        return;
    }
    $size = 0;
    $secondStage | %{ $size += $_.Size }
 
    Write-Output "Site $($site.Title) ($($site.Url)) has $($secondStage.Length) items ($($size | Format-ForPc)) in Admin-RecycleBin";          
 
    switch ($SecondStageCleanup) {
        "ListOnly" {
            $secondStage | %{ Write-Output "- $($_.ItemType):$($_.Title) ($($_.Size | Format-ForPc), Deleted by $($_.DeletedByName))" }
        }
        "RemovePermanent" {
            $secondStage | %{ $_.Delete(); }
            $Global:TotalRemovedSize += $size;
            Write-Output "- Deleted permanently";
        }
    }
}
}
 
 
$sa = Start-SPAssignment
$w = Get-SPWebApplication $WebApp -AssignmentCollection $sa;
$w.Sites | Process-Site;
Stop-SPAssignment $sa
if($SecondStageCleanup -eq "RemovePermanent" -and $FirstStageCleanup -eq "MoveTo2nd") {
    Write-Warning "The selected combination of removing from second stage and moving from first to second possibly leaves items undeleted."
}
if($Global:TotalRemovedSize -gt 0) {
    Write-Output "$($Global:TotalRemovedSize | Format-ForPc) were removed permanently.";
}

SharePoint: Auflisten aller Obejkte mit eigener Berechtigungszuweisung

​Die Frage meines Kunden letztens: "Wie kann ich alle Elemente (Listen, Items, etc.) auflisten, bei denen eigene berechtigungszuweisungen erfolgt sind?"

Meine schnelle Antwort: "Nicht möglich, OOTB!".

Mittlerweile weiß ich: In 2007 ging das - aber nur mit dem SharePoint Administrator Toolkit.

Ich habe - mit Inspiration von Mike Smith - ein Skript erstellt​, dass eben dies macht.

<#    
    .SYNOPSIS 
    List all items with broken inheritance
 
    .DESCRIPTION
    Lists all Webs, Lists, Folders and Items with broken inheritance.
    This script was heavily inspired by http://techtrainingnotes.blogspot.de/2014/07/sharepoint-powershellfind-all-broken.html
 
    .PARAMETER SiteCollectionUrl
    Url to SiteCollection
 
    .PARAMETER Site
    Site. Can be Piped in.
 
    .PARAMETER StopAtWeb
    Stop the search at Web-Level. Do not search Lists/Folders/Items.
 
    .PARAMETER StopAtList
    Stop the search at List-Level. Do not search Folders/Items.
 
    .PARAMETER StopAtFolder
    Stop the search at Folder-Level. Do not search Items.
 
    .INPUTS
    Site
 
    .OUTPUTS
    Grid of Securable | Item | Url | Parent
    where
     Securable is one of "Web", "List", "Folder" or "Item"
     Item is the Name or Title
     Url is the url to the item
     Parent is the url to the parent-item
 
 
    .EXAMPLE
    .\Get-SpBrokenInheritances.ps1 -SiteCollectionUrl http://my.lovely.site/
#>
[CmdletBinding()]
param (
    [Parameter(ParameterSetName='SiteByUrl')]
    [string]$SiteCollectionUrl,
     
    [Parameter(ParameterSetName='SiteByObject', ValueFromPipeline=$true)]
    [Microsoft.SharePoint.SPSite]$Site,
 
    [Parameter()]
    [switch]$StopAtWeb = $false,
 
    [Parameter()]
    [switch]$StopAtList = $false,
 
    [Parameter()]
    [switch]$StopAtFolder = $false
)
 
Set-StrictMode -Version Latest
$script:ErrorActionPreference = "Stop";
 
function Get-ParentUrl {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPListItem]$Item
    )
    $List = $Item.ParentList;
     
    if ($List.BaseType -eq [Microsoft.SharePoint.SPBaseType]::DocumentLibrary) {
        return "$($_.ParentList.ParentWeb.ServerRelativeUrl)/$($_.File.ParentFolder.Url)";
    } else {
        # SPListItem.Url looks like ////_.000 - I have no idea how to get the folder Url "correctly"
        $FolderUrl = $Item.Url.Substring(0, $Item.Url.LastIndexOf("/"));
        return "$($List.ParentWeb.ServerRelativeUrl)/$FolderUrl";
    }
}
 
function Get-Url {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPListItem]$Item
    )
    $List = $Item.ParentList;
    if ($List.BaseType -eq [Microsoft.SharePoint.SPBaseType]::DocumentLibrary) {
        return "$($List.ParentWeb.ServerRelativeUrl)/$($Item.Url)";
    } else {
        # e.g. /blubb/Lists/Test12/DispForm.aspx?ID=1
        return "$($Item.ParentList.DefaultDisplayFormUrl)?ID=$($Item.Id)";
    }
}
 
function Process-Lists {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPList[]]$Lists
    )
    $Folders = $Lists | Select -ExpandProperty Folders;
    $Folders | ? { $_.HasUniqueRoleAssignments } | 
        Select @{Label="Securable"; Expression={"Folder"}}, 
            @{Label="Item"; Expression={$_.Title}}, 
            @{Label="Url"; Expression={"$($_.ParentList.ParentWeb.ServerRelativeUrl)/$($_.Url)"}},
            @{Label="Parent"; Expression={"$($_.ParentList.ParentWeb.ServerRelativeUrl)/$($_.ParentList.RootFolder.Url)"}} | Write-Output
 
    if($StopAtFolder) {
        return;
    }
    $Items = $Lists | Select -ExpandProperty Items;
    $Items | ? { $_.HasUniqueRoleAssignments } | 
        Select @{Label="Securable"; Expression={"Item"}}, 
            @{Label="Item"; Expression={$_.Name}}, 
            @{Label="Url"; Expression={Get-Url -Item $_ }},
            @{Label="Parent"; Expression={Get-ParentUrl -Item $_ }} | Write-Output
}
 
function Process-Webs {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        $Webs
    )
    $Lists = $Webs | Select -ExpandProperty Lists | ? { $_.EntityTypeName -ne "PublishedFeedList" -and -not $_.Hidden }
    $Lists | ?{ $_.HasUniqueRoleAssignments } | 
        Select @{Label="Securable"; Expression={"List"}}, 
            @{Label="Item"; Expression={$_.Title}}, 
            @{Label="Url"; Expression={"$($_.ParentWeb.ServerRelativeUrl)/$($_.RootFolder.Url)"}},
            @{Label="Parent"; Expression={$_.ParentWebUrl}} | Write-Output
   
    if($StopAtList) {
        return;
    }
    Process-Lists -Lists $Lists
}
 
function Process-Site {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPSite]$Site
    )
    Write-Verbose "Process-Site $($Site.RootWeb.Title)";
    $WebGc = Start-SPAssignment;
    try {
        $Webs = $Site | Get-SPWeb -AssignmentCollection $WebGc -Limit All;
        $Webs | ?{ $_.HasUniquePerm -and $_.ParentWeb -ne $Null } | 
            Select @{Label="Securable"; Expression={"Web"}}, 
                @{Label="Item"; Expression={$_.Title}}, 
                @{Label="Url"; Expression={$_.ServerRelativeUrl}}, 
                @{Label="Parent"; Expression={$_.ParentWeb.ServerRelativeUrl}} | Write-Output
   
        if($StopAtWeb) {
            return;
        }
        Process-Webs -Webs $Webs
    } finally {
        Stop-SPAssignment $WebGc;
    }
}
 
Add-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction Inquire
 
$gc = Start-SPAssignment;
try{
    if(!$Site) {
        Write-Verbose "Site was neither given, nor in Pipe. Fetching Site from Url:$SiteCollectionUrl";
        if(!$SiteCollectionUrl) {
            Write-Error "Neither -Site, nor -SiteCollectionUrl was given.";
            Exit -1;
        }
        $Site = Get-SpSite -Identity $SiteCollectionUrl -AssignmentCollection $gc -ErrorAction SilentlyContinue;
        if ($Site -eq $null)
        {
            Write-Error "No SiteCollection with Identity '$SiteCollectionUrl' found. Exiting...";
            Exit -1;
        }
    }
    Process-Site -Site $Site;
} finally {
    Stop-SPAssignment $gc;
}

Freitag, 10. August 2018

Termstoremanagement mit gegebenen Term öffnen

Die Frage heute beim Kunden: Kann ich das "Term Store Management Tool" an einer bestimmten Stelle im TermStore öffnen - quasi den zu bearbeitenden Term gleich mitgeben? Die Antwort ist "ja" und findet sich in der Datei TermStoreManager.js.

Es kann mit dem query-Parameter termPath ein Pfad zu einem bestimmten Term übergeben werden. Dafür müssen alle IDs aller Eltern-Elemente (TermGroup, -Sets) hintereinander gestellt werden - mit "|"-Getrennt.

Das Ergebnis ist nicht schön, läuft aber. Aus einer beliebigen SP-Seite heraus also einfach den href setzen​:

function getManagementUrl(idPathsArray) {
    return _spPageContextInfo.webAbsoluteUrl + '/' + _spPageContextInfo.layoutsUrl + '/termstoremanager.aspx?termPath=' + idPathsArray.join('|')
}

Credentials in der PowerShell überprüfen lassen

Hintergrund:

Mitten in einem PowerShell-Skript beim Kunden steht "Get-Credentials" - wenn bei der Erfassung der credentials ein Fehler unterläuft, bricht das S​kript ab und man kann von vorne beginnen...

Die Anforderung:

Nach erfassen der Credentials sollen diese auf Gültigkeit überprüft werden.
Es gibt die eine oder andere Frage und auch eine Lösung in der TechNet-Gallery​...

Mir war das leider  nicht "generell" genug. Hier ist meine Lösung:

function Test-Credential { 
<#
    .SYNOPSIS
       checks some credentials.
    
      .PARAMETER Credential
        The Credentials to check
 
      .PARAMETER Retry
        retry on fail.
     
      .EXAMPLE
        Get-Credential dev\developer | Test-Credential -Verbose -Retry
         
#> 
    [OutputType([System.Management.Automation.PSCredential])] 
    [CmdletBinding()]
    Param ( 
        [Parameter( 
            Mandatory = $true, 
            ValueFromPipeLine = $true, 
            ValueFromPipelineByPropertyName = $true
        )] 
        [Alias( 'PSCredential' )] 
        [ValidateNotNull()] 
        [System.Management.Automation.PSCredential] 
        [System.Management.Automation.Credential()] 
        $Credential = [System.Management.Automation.PSCredential]::Empty,
        [switch]$Retry=$false
     ) 
    $processing = $true;
    while($processing) {
        
        $UserName = $Credential.username
        $networkCred = $Credential.GetNetworkCredential();
        $password = $networkCred.Password
        $domain = $networkCred.Domain
        Write-Verbose "Credentials supplied for user: $UserName"
        if(!$domain) {
            if($UserName -match "@") {
                # user was foo@bar.baz...
                Write-Verbose "User in UPN-Form. No domain-parsing will be done.."
            } else {
                # current domain
                $domain = "LDAP://" + ([ADSI]"").DistinguishedName
                Write-Verbose "No domain given. DistinguishedName of current domain: $domain"
            }
        } else {
            Write-Verbose "domain given as $domain in old NT-syntax."
            $test = Get-Command Get-ADDomain -ErrorAction SilentlyContinue
            if($test -eq $null) {
                $guess =  "$($UserName.Substring($domain.length+1))@$domain";
                Write-Verbose "CMDLet Get-ADDomain is not available. Guessing UPN-form for user as $guess";
                $UserName = $guess;
                $domain = "";
            } else {
                Write-Verbose "CMDLet Get-ADDomain is available. Fetching DistinguishedName..";
                $domain = Get-ADDomain $domain -ErrorAction Stop;
                $domain = "LDAP://" + $domain.DistinguishedName;
                Write-Verbose "DistinguishedName of domain is: $domain";
            }        
        }
        
 
        # now re-fetch the current domain using the supplied credentials.
        Write-Verbose "Validating credentials"
        $entry = New-Object System.DirectoryServices.DirectoryEntry($domain,$UserName,$Password)
 
        if ($entry.name -eq $null)
        {
            Write-Verbose "Authentication failed."
            $abort = $false;
            if($Retry) {
                $Credential = Get-Credential -UserName $user -Message "Failed. Please rety..." -ErrorAction SilentlyContinue
                if($Credential -eq $null) {
                    $abort = $true;
                }
            }
            if(!$Retry -or $abort) {
                throw "Validation failed..."
                return $null;
            }
        }
        else
        {
            Write-Verbose "Authentication succeeded."
            $processing = $false;
            return $Credential;
        } 
    }
}

Montag, 6. August 2018

Größe eines Web berechnen

Hat schon einmal jemand versucht die größe eines Web zu berechnen? Für Sites kann man ja einfach das folgende Statement verwenden:

Get-SPSite | select url, @{label="Size in MB";Expression={$_.usage.storage/1MB}}

Bei Webs scheint das ganze etwas komplizierter.
Ich habe mal das folgende Skript verwendet um eine Näherung zu erreichen - ich hoffe ich habe nichts großes "vergessen":

function Get-SPWebSize {
   <#
      .SYNOPSIS
        Measures the size of an SPWeb - be warned that this is only an estimate, 
        as SharePoint has no OOTB function to measure the size of an web.
   
      .PARAMETER Web
        the web to measure
 
      .PARAMETER HumanReadable
        whether the output should be human-readable (KB, MB, GB, TB)
   
      .EXAMPLE
        Get-SPWeb path/to/web | Get-SPWebSize -HumanReadable GB
   #>
   [CmdletBinding()]
   param (
      [Parameter(Mandatory=$true, ValueFromPipeline=$True, HelpMessage = "the SPWeb to measure")]
      [Microsoft.SharePoint.SPWeb]$Web,
      [Parameter(Mandatory=$false, HelpMessage = "set to a size to measure in (e.g. KB or GB)")]
      [ValidateSet("None", "KB", "MB", "GB", "TB")]
      [string]$HumanReadable = "None",
      [Parameter(Mandatory=$false, HelpMessage = "Suppress the startup-warning")]
      [Switch]$SuppressWarn = $false
 
   )
   if(-not $SuppressWarn) {
      Write-Warning "Be aware, that the calculated size is only an estimate!";
   }
   if((Get-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue) -eq $null) {
      Add-PSSnapin Microsoft.SharePoint.PowerShell
   }
   function Get-FolderSize {
      [CmdletBinding()]
      param (
         [Parameter(Mandatory=$true, ValueFromPipeline=$True)]
         [Microsoft.SharePoint.SPFolder]$Folder
      )
      [long]$size = 0;
      $Folder.Files | %{
         $size += $_.Length;
      }
      $Folder.SubFolders | %{
         $size += $_ | Get-FolderSize
      }
      Write-Verbose "Folder $($Folder.ParentWeb.Url +"/"+ $Folder.Url) has size of $size";
      $size
   }
   function Get-SubWebSize {
      [CmdletBinding()]
      param (
         [Parameter(Mandatory=$true, ValueFromPipeline=$True)]
         [Microsoft.SharePoint.SPWeb]$Web
      )
      [long]$size = 0;
      $Web.Folders | %{
         $size += $_ | Get-FolderSize
      }
      $Web.Webs | %{
         $size += $_ | Get-SubWebSize
      }
      Write-Verbose "Web $($Web.Url) has size of $size";
      $size
   }
    
   $size = $Web | Get-SubWebSize
   if ($HumanReadable -ne "None") {
      $size = Invoke-Expression "$size / 1$HumanReadable";
   } 
   $size
}

PowerShell CmdLet reflecten

Meistens muss ich alles ganz genau wissen: Z.B. wie ein spezielles PowerShell-CmdLet implementiert ist.
Mittels des folgenden kleinen Skriptes​ kann man ganz schnell die implementierende DLL zu einem CmdLet finden und notfalls auch schon mal einen decompiler starten.​
Die Inspiration kommt von OISIN GREHAN​.

<#  
.SYNOPSIS  
    Run reflection on a given commandlet
.DESCRIPTION  
    Run reflection on any CmdLet
.NOTES  
    This code was heavily inspired from OISIN GREHAN, see http://www.nivot.org/post/2008/10/30/ATrickToJumpDirectlyToACmdletsImplementationInReflector
.Example
    Get-Command Get-ChildItem | Reflect-Cmdlet -Reflect ShowDllOnly
.Example
    Reflect-Cmdlet -CmdLet (Get-Command Get-ChildItem) -Reflect ShowDllOnly
#>
[CmdletBinding()]
param(
    [Parameter(Position=0, 
        Mandatory=$true, 
        ValueFromPipeline=$true,
        ValueFromPipelineByPropertyName=$true,
        HelpMessage = "The CmdLet to reflect")]
    [Management.Automation.CommandInfo]$CmdLet,
 
    [Parameter(HelpMessage = "Which reflector to use.. ")]
    [ValidateSet("ShowDllOnly", "Reflector", "JustDecompile", "ILSpy")]
    [string]$Reflect = "ShowDllOnly"
)
      
# resolve to command if this is an alias  
while ($CmdLet.CommandType -eq "Alias") {  
    $def = $CmdLet.definition;
    Write-Verbose "$CmdLet is an alias. Using Definition: $def";
    $CmdLet = Get-Command $def
}  
Write-Verbose "Reflecting $CmdLet.";
       
$name = $CmdLet.ImplementingType      
$DLL = $CmdLet.DLL  
if($DLL -eq $null) {
    Write-Warning "$CmdLet is not implemented in any DLL. Possibly a script?";
    if($CmdLet.Path -ne $null) {
         Write-Warning "Have a look at: $($CmdLet.Path)"
    }
    #$CmdLet | gm
    Exit;
}
 
Write-Verbose "Type:$name, DLL:$DLL";
switch ($Reflect) {
    "ShowDllOnly" {
        Write-Output "$CmdLet is implemented in $name in the dll:$DLL";
    }
    "Reflector" {
        if (-not (Get-Command reflector.exe -ErrorAction SilentlyContinue)) {  
            throw "Reflector.exe is not in your path."
        }  
        Write-Verbose "Starting Reflector.";
        reflector /select:$name $DLL
    }
    "JustDecompile" {
        $regKey = Get-Item HKCU:\Software\Telerik\JustDecompile -ErrorAction SilentlyContinue
        if($regKey -eq $null) {
            throw "It seems JustDecompile is not installed."
        }
        $exe = $regKey.GetValue("ExecutablePath") ;
        Write-Verbose "invoking $exe";
        &$exe """$DLL""" ; #TODO: select the right type...
    }
    "ILSpy" {
      if (-not (Get-Command ilspy.exe -ErrorAction SilentlyContinue)) {  
            throw "ilspy.exe is not in your path."
        }  
      Write-Verbose "Starting ILSpy.";
      ilspy $DLL /navigateTo:T:$name
    }
}

Mittwoch, 25. Juli 2018

ExecuteOrDelayUntilScriptLoaded oder doch lieber ExecuteFunc?

Ich falle immer wieder über den Unterschied zwischen ExecuteOrDelayUntilScriptLoaded und ExecuteFunc.
ExecuteOrDelayUntilScriptLoaded führt einen callback aus, sobald eine abhängige Datei geladen ist. Allerdings führt dies nicht dazu, dass die abhängige Datei geladen wird.

Der code:

SP.SOD.executeOrDelayUntilScriptLoaded(function(){
    alert('Hallo, Welt.');
}, 'sp.js');

öffnet also den alert nur, wenn die sp.js benötigt und geladen wurde. Wenn die sp.js nie geladen wird, wird der alert nie erscheinen.

ExecuteFunc hingegen führt einen callback aus, nachdem eine abhängige Datei geladen ist. Die abhängige Datei wird dabei geladen, wenn sie nicht schon geladen war. Dies führt dazu, dass der callback nicht ausgeführt wenn die Datei vorher schon geladen war.

Der code:

SP.SOD.executeFunc('sp.js', null, function() {
    alert('Hallo, Welt!');
});

öffnet also den alert nur, wenn die sp.js vorher noch nicht geladen war..

Es bleibt die Frage: Wie stelle ich jetzt also sicher, dass mein code "nach" der sp.js aufgerufen wird und gleichzeitig, dass die sp.js auf jeden Fall geladen wird?

ExecuteOrDelayUntilSciptLoaded liefert einen bool zurück, der angibt ob die abhängige Datei schon angefordert war. D.h. falls ExecuteOrDelayUntilScriptLoaded false liefert sind wir im "delay"-Teil  der Funktion gelandet und warten darauf, dass die abhängige Datei geladen wird...

Der Code:

if(!SP.SOD.executeOrDelayUntilScriptLoaded(function(){
    alert('Hallo, Welt.');
}, 'sp.js')) {
    // sp.js war nocht nicht angefordert...
    SP.SOD.executeFunc('sp.js', null, function(){});
}

wird den alert öffnen, wenn die sp.js geladen ist und gleichzeitig die sp.js anfordern, falls diese bisher noch nicht angefordert war.

Donnerstag, 19. Juli 2018

SharePoint "nativehr"-Fehler erklärt

Jeder SharePoint-Entwickler kennt Fehler in der Form:
0x80070718  Your changes could not be saved because this SharePoint Web site has exceeded the storage quota limit.
You must save your work to another location.  Contact your administrator to change the quota limits for the Web site.
Ein Kunde frage neulich: "Woher kommt eigentlich die Zahl (0x80070718) und was bedeutet die?"

Die Frage ist schnell erläutert: Es handelt sich um die hex-Darstellung des HRESULT, welcher der Auslöser des Fehlers war.
Über HRESULT gibt es reichlich Informationen. Am besten ist aber, finde ich, diese (generelle Erläuterung für HRESULT und Facilities) in Kombination mit dieser (liste der Fehler-Codes).

Kurz erläutert besteht ein HRESULT aus 32 Bit, wobei die hohen 5 Bit wie folgt bezeichnet sind:
  • S (1 bit): Severity. If set, indicates a failure result. If clear, indicates a success result.
  • R (1 bit): Reserved. If the N bit is clear, this bit MUST be set to 0. If the N bit is set, this bit is defined by the NTSTATUS numbering space (as specified in section 2.3).
  • C (1 bit): Customer. This bit specifies if the value is customer-defined or Microsoft-defined. The bit is set for customer-defined values and clear for Microsoft-defined values.
  • N (1 bit): If set, indicates that the error code is an NTSTATUS value (as specified in section 2.3), except that this bit is set. 
  • X (1 bit): Reserved. SHOULD be set to 0.
Es folgen 11 Bit "Facility" und anschließend 16 Bit für den eigentlichen Code.

Der Wichtige Punkt daran ist, dass Customer-Bit: Wenn dieses 0 ist, kommt die Meldung von Microsoft und kann in der o.a. Doku "nachgeschlagen" werden. (Ob das dann hilft, oder nicht...)

Für den angegebenen Fall (0x80070718): In Binär-Darstellung ist die Zahl 10000000000001110000011100010101 - und kann daraus einfach "abgezählt" werden:

SRCNXFacilityCode
10000000000001110000011100010101
Ein Fehler von Microsoft0x7 (7)0x715 (1813)

Wobei die Facility wie in [MS-ERREF] beschrieben einen den Fehler als FACILITY_WIN32 ("This region is reserved to map undecorated error codes into HRESULTs.") Fehler beschreibt und der Code, wie bei den SystemErrorCodes beschrieben einen ERROR_NOT_ENOUGH_QUOTA Fehler beschreibt.

Es handelt sich also um einen "generellen" Win32-Fehler, bei dem nicht genügend Quota vorhanden ist. Hat das geholfen? Nicht wirklich, denn das stand auch schon in der Meldung von SharePoint... Aber es ist erklärt...

Da "Abzählen" von Bits nicht immer einfach oder schnell ist, habe ich ein kleines PowerShell Skript geschrieben, dass die "Analyse" erstellen kann:

<#
  .SYNOPSIS
   Decode HResult (hr) codes.. or die trying...
 
  .EXAMPLE
   Decode-HResult 0x80070718
   Shows info about "Quota Exceeded"...
#>

[CmdletBinding()]
param(
    [Parameter(Position=0)]
    [int]$hr
)

function bitshift {
 # https://stackoverflow.com/questions/35116636/bit-shifting-in-powershell-2-0
    param(
        [Parameter(Position=0)]
        [int]$x,

        [Parameter(ParameterSetName='Left')]
        [int]$Left,

        [Parameter(ParameterSetName='Right')]
        [int]$Right
    ) 

    $shift = if($PSCmdlet.ParameterSetName -eq 'Left')
    { 
        $Left
    }
    else
    {
        -$Right
    }

    return [math]::Floor($x * [math]::Pow(2,$shift))
}

$i = [int]$hr
$hex = "0x$([Convert]::ToString($i, 16))"
$bin = [Convert]::ToString($i, 2)

write-verbose "code as int: $i"
write-verbose "code as hex: $hex"
write-verbose "code as bin: $bin"
write-verbose ""
write-verbose "decoding:"
write-verbose $bin.PadLeft(32, " ")
write-verbose "SRCNX|- facil -||---- code ----|"

## see https://en.wikipedia.org/wiki/HRESULT
## and https://msdn.microsoft.com/en-us/library/cc231198.aspx
## and https://docs.microsoft.com/en-us/windows/desktop/com/structure-of-com-error-codes

# lowest 2 bytes for code
$code = $i -band 0xffff
# then 11 bit for facility
$fac = $i -band 0x7ff0000
if($fac -ne 0) { $fac = (bitshift $fac -Right 16)}
# 2 bit reserved, then 1 bit for customer 
$cust = $i -band 0x20000000
if($cust -ne 0x0) { $cust = (bitshift $cust -Right 29)}
# 1 bit reserved (severe?) then 1 bit success (probably always 1?)
$nok = $i -band 0x80000000
if($nok -ne 0) { $nok = 1 }

write-host "hr = $hex"
write-host "Severity: $( if($nok -ne 0){"Fail"} else {"Success"} )"
write-host "code: 0x$([Convert]::ToString($code, 16))"
write-host "facility: 0x$([Convert]::ToString($fac, 16))"
if($cust -eq 0) {
 write-host "the code was Microsoft-defined. "
 Write-host "  So you can lookup facility ($fac) under https://msdn.microsoft.com/en-us/library/cc231198.aspx"
 write-host "  and the code ($code) under https://docs.microsoft.com/en-us/windows/desktop/debug/system-error-codes"
} else {
 write-host "the code was Cutomer-defined"
}


Mittwoch, 18. Juli 2018

Hat einer 'TokenReplacementFileExtensions' überschrieben?

In einer existierenden SharePoint-Solution habe ich heute eine neue Layouts-Page angelegt und mich anschließend mit dem folgenden Fehler herumgeschlagen:

Error CS0234 The type or namespace name 'Expressions' does not exist in the namespace 'System.Web.UI.WebControls' (are you missing an assembly reference?)

Meine Verwirrung war recht umfassend, da ich das Wort "Expressions" nicht finden konnte, das Problem aber offensichtlich an der von mir neu hinzugefügten aspx-Seite lag.

Um meine längliche Suche abzukürzen: Die Solution wurde vor langer Zeit erstellt um einen WebService im SharePoint zu hosten. Vermutlich hat sich der Ersteller an eine der vielen Anleitungen zum Thema (z.B. diese..) gehalten und den folgenden Text in der csproj erfasst:

<TokenReplacementFileExtensions>svc</TokenReplacementFileExtensions>

Dieses Vorgehen findet sich in fast allen Anleitungen... Leider wird dabei oft übersehen, dass diese Eigenschaft nicht "aus dem Nichts" kommt, sondern vorher, an anderer Stelle, schon definiert sein muss. Die Doku sagt dazu:
Although tokens can theoretically be used by any file that belongs to a SharePoint project item included in the package, by default, Visual Studio searches for tokens only in package files, manifest files, and files that have the following extensions:
  • XML
  • ASCX
  • ASPX
  • Webpart
  • DWP

Diese "Voreinstellungen" werden also überschrieben, wenn man strikt den Anleitungen folgt. Eine bessere Möglichkeit wäre es die die TokenReplacementFileExtensions zu ergänzen, statt zu überschreiben:

<TokenReplacementFileExtensions>$(TokenReplacementFileExtensions);svc</tokenreplacementfileextensions>


Dienstag, 10. Juli 2018

SharePoint redirect an ein Add-In

Aktuelle Frage: Wie erstelle ich in SharePoint einen Link auf ein Add-In?

Klar, im Webseiteninhalt taucht eine nette Kachel auf die den Link beinhaltet. Aber wie erstellt man einen generellen Link z.B. auf einer eigenen Seite?

Die Antwort ist die 'AppRedirect.aspx'. Diese bekommt die ID der add-in instanz übergeben etwa so: 'https://mein.sharepoint.de/_layouts/15/appredirect.aspx?instance_id={A3F2D157-721A-42B9-85F6-B98FBF19D40B}'.

Aber wie kommt man an die ID - wenn man vielleicht nicht gerade auf die ensprechende Inhaltsseite gucken und die ID "abschreiben" kann?

Einfach - die Lösung findet sich im SP.AppCatalog-Objekt:
function redirectToApp(appName){
  var ctx = SP.ClientContext.get_current(),
    web = ctx.get_web(),
    appInstances = SP.AppCatalog.getAppInstances(ctx, web);
  ctx.load(appInstances);

  ctx.executeQueryAsync(function(){
    var apps = appInstances.getEnumerator(),
      app;
    while(apps.moveNext()){
      app = apps.get_current();
      if(app.get_title() === appName){
        break;
      }
    }
    if(!app){
      throw "No app found:"+appName
    }
    var redirectUrl = _spPageContextInfo.webAbsoluteUrl.replace(/\/?$/, '/'+_spPageContextInfo.layoutsUrl) + 
      '/appredirect.aspx?instance_id={' +app.get_id() + '}';
    
    document.location = redirectUrl;
  }, function(){ throw 'Error loading app-instances..'; });
}

Samstag, 30. Juni 2018

Bereinigen von virtuellen maschinen

Als SharePoint-Entwickler arbeite ich häufig in Virtuellen umgebungen. Diese sollten gerne möglichst "platzsparend" gelagert werden können - das ist auch gut, wenn mal eine Maschine an einen Kollegen "abgetreten" werden soll.

Mein akutelles Vorgehen dabei ist das folgende:
  • Bereinigung des WinSxS-Ordners mittles "Dism.exe /online /Cleanup-Image"
    • Für Service-Packs mit dem Parameter "/SPSuperseded"
    • Für Komponenten mit dem Parameter "/StartComponentCleanup /ResetBase"
  • Bereinigung der Laufwerke mittels "cleangr.exe"
    • Um den cleanmgr ohne Rückfragen zu starten gibt es die Parameter "/sageset" und "/sagerun". (Entgegen der Dokumentation gibt es nur 9999 verschiedene Speicherplätze und nicht 65535). Die Einstellungen, die mit "sageset" vorgenommen werden, werden in der registry gespeichert und daher auch einfach mit Powershell angelegt werden.
  • Defragmentierung des Datenträgers mit ultradefrag
    • Für optimale Ergebnisse verwende ich die Parameter "--optimize" und "--repeat"
  • "Nullen" der nicht mehr verwendeten Blöcke des Datenträgers mit sdelete
    • Für das "einfache" "Nullen" der Blöcke verwende ich den Parameter "-z"
    • Dieser Schritt führt - zusammen mit der defragmentierung - zu einem besseren Ergebnis beim komprimieren der virtuellen Festplatte

Komplett sieht das Skript dann so aus:
Dism.exe /online /Cleanup-Image /StartComponentCleanup /ResetBase
Dism.exe /online /Cleanup-Image /SPSuperseded
Get-ChildItem HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VolumeCaches | `
              %{ $_| Set-ItemProperty -Name "StateFlags1234" -Value 2 }
cleanmgr.exe /sagerun:1234
udefrag.exe --optimize --repeat C:
sdelete.exe -q -z C:

Donnerstag, 28. Juni 2018

SharePoint Listeneinstellungen öffnen ohne Ribbon...

Aktuell bestand das Problem dass für einige SharePoint-Listen die Einstellungsseite geöffnet werden sollte, der Ribbon aber nicht verfügbar war.
Einstellungen von Listen erfolgen ja über die Seite "listedit.aspx" im layouts, stellt sich nur die Frage wie man schnell an die ID der liste kommt, da diese ja als query-parameter übergeben werden muss.


Meine Antwort ist in SharePoint ab 2010 lauffähig:

document.location = 
    document.location.href.replace(document.location.pathname, '') + 
    _spPageContextInfo.webServerRelativeUrl.replace(/\/?$/, '/' + 
    (_spPageContextInfo.layoutsUrl || '_layouts') + 
    '/listedit.aspx?List=' + 
    encodeURIComponent(_spPageContextInfo.pageListId))


Einfach in der Konsole einer Listenseite (z.B. "AllItems.aspx") ausführen.