Sharepoint on Janik von Rotz

Alternative download for SharePoint ULS viewer by Microsoft

Mon, 19 May 2014 13:32:37 +0000

You might already knew it, the link http://code.msdn.microsoft.com/ULSViewer for the most popular ULS viewer doesn’t work anymore.

Luckily I’ve found a copy on my SharePoint server, you can get it below.

Download UlsViewer 2.0.3530.27850

If you have a newer copy of the file it would be nice if you share it with me.

Summary of SharePoint 2013 archiving features

Mon, 19 May 2014 09:25:35 +0000

SharePoint 2013 provides the below types of Archiving

List-based retention and Auditing (List and Libraries)
Records management (Records Archive, In-Place Record)
Site based retention (Applied to Sites and Exchange Server 2013 Team Mail boxes)

List based Retention Policy Features:

Moving the item to the Recycle Bin
Permanently deleting the item
Transferring the item to another location
Starting a workflow
Skipping to the next stage
Declaring the item to be a record
Deleting all previous drafts of the item
Deleting all previous versions of the item

Site based Retention Policy Features:

New feature introduced in SharePoint 2013
Site Policies used for keeping the growth of sites in control
Sites, Sub-sites and Exchange mailbox associated with a site can be closed or deleted
Closed sites does not appear in places were sites are aggregated – for example, outlook, Outlook Web App, or Project Server 2013 — but users can still modify a closed site and its content by using the URL to reach the site

Site based Retention - Site Policy Options:

Do not close or delete the site automatically (If a policy that has this option is applied to a site, the site owner must delete the site manually)
Delete the site automatically (If a policy that has this option is applied to a site, the site owner may close the site manually, but the site will be deleted automatically)
Close the site automatically and delete the site automatically (This option gives the same choices for how to delete the site automatically, and also requires you to specify how long after its creation
time the site will be closed) Run a workflow to close the site, and delete the site automatically (This option gives the same choices for how to delete the site automatically, and also requires you to specify a workflow to run)

Source

Plan for information management policy in SharePoint Server 2013 Overview of site policies in SharePoint 2013

Configure hybrid search results from SharePoint Online in SharePoint on-premise

Wed, 14 May 2014 07:03:29 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project. Get the latest version of this article here: https://gist.github.com/10871110

Introduction

In this post I’ll show you how to get search results from your SharePoint Online in your SharePoint 2013 on-premise search center.

Requirements

User synchronisation ActiveDirectory to Office 365 with DirSync
DirSync password sync or ADFS SSO
SharePoint Online
SharePoint 2013 on-premise
- Enterprise Search service
- SharePoint Online Management Shell

Instructions

All configuration will be done either in the Search Administration of the Central Administration or in the PowerShell console of your on-premise SharePoint 2013 server.

Set up Sever to Server Trust

Export certificates

To create a server to server trust we need two certificates.

[certificate name].pfx: In order to replace the STS certificate, the certificate is needed in Personal Information Exchange (PFX) format including the private key.

[certificate name].cer: In order to set up a trust with Office 365 and Windows Azure ACS, the certificate is needed in CER Base64 format.

First launch the Internet Information Services (IIS) Manager
Select your SharePoint web server and double-click Server Certificates
In the Actions pane, click Create Self-Signed Certificate
Enter a name for the certificate and save it with OK
To export the new certificate in the Pfx format select it and click Export in the Actions pane
Fill the fields and click OK Export to: C:\[certificate name].pfx Password: [password]
Also we need to export the certificate in the CER Base64 format. For that purpose make a right-click on the certificate and click on View…
Click the Details tab and then click Copy to File
On the Welcome to the Certificate Export Wizard page, click Next
On the Export Private Key page, click Next
On the Export File Format page, click Base-64 encoded X.509 (.CER), and then click Next.
As file name enter C:\[certificate name].cer and then click Next
Finish the export

Import the new STS (SharePoint Token Service) certificate

Let’s update the certificate on the STS. Configure and run the PowerShell script below on your SharePoint server.

if(-not (Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue)){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}

# set the cerficates paths and password
$PfxCertPath = "c:\[certificate name].pfx"
$PfxCertPassword = "[password]"
$X64CertPath = "c:\[certificate name].cer"

# get the encrypted pfx certificate object
$PfxCert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 $PfxCertPath, $PfxCertPassword, 20

# import it
Set-SPSecurityTokenServiceConfig -ImportSigningCertificate $PfxCert

Type Yes when prompted with the following message.

You are about to change the signing certificate for the Security Token Service. Changing the certificate to an invalid, inaccessible or non-existent certificate will cause your SharePoint installation to stop functioning. Refer to the following article for instructions on how to change this certificate: http://go.microsoft.com/fwlink/?LinkID=178475. Are you sure, you want to continue?

Restart IIS so STS picks up the new certificate.

& iisreset
& net stop SPTimerV4
& net start SPTimerV4

Now validate the certificate replacement by running several PowerShell commands and compare their outputs.

# set the cerficates paths and password
$PfxCertPath = "c:\[certificate name].pfx"
$PfxCertPassword = "[password]"

# get the encrypted pfx certificate object
New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 $PfxCertPath, $PfxCertPassword, 20

# compare the output above with this output
(Get-SPSecurityTokenServiceConfig).LocalLoginProvider.SigningCertificate

Establish the server to server trust

if(-not (Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue)){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}
Import-Module MSOnline 
Import-Module MSOnlineExtended

# set the cerficates paths and password
$PfxCertPath = "c:\[certificate name].pfx"
$PfxCertPassword = "[password]"
$X64CertPath = "c:\[certificate name].cer"

# set the onpremise domain that you added to Office 365
$SPCN = "sharepoint.domain.com" 

# your onpremise SharePoint site url
$SPSite="http://sharepoint"

# don't change this value
$SPOAppID="00000003-0000-0ff1-ce00-000000000000"

# get the encrypted pfx certificate object
$PfxCert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 $PfxCertPath, $PfxCertPassword, 20

# get the raw data
$PfxCertBin = $PfxCert.GetRawCertData()

# create a new certificate object
$X64Cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2

# import the base 64 encoded certificate
$X64Cert.Import($X64CertPath)

# get the raw data
$X64CertBin = $X64Cert.GetRawCertData()

# save base 64 string in variable
$CredValue = [System.Convert]::ToBase64String($X64CertBin)

# connect to office 3656
Connect-MsolService

# register the on-premise STS as service principal in Office 365

# add a new service principal
New-MsolServicePrincipalCredential -AppPrincipalId $SPOAppID -Type asymmetric -Usage Verify -Value $CredValue
$MsolServicePrincipal = Get-MsolServicePrincipal -AppPrincipalId $SPOAppID
$SPServicePrincipalNames = $MsolServicePrincipal.ServicePrincipalNames
$SPServicePrincipalNames.Add("$SPOAppID/$SPCN")
Set-MsolServicePrincipal -AppPrincipalId $SPOAppID -ServicePrincipalNames $SPServicePrincipalNames

# get the online name identifier
$MsolCompanyInformationID = (Get-MsolCompanyInformation).ObjectID
$MsolServicePrincipalID = (Get-MsolServicePrincipal -ServicePrincipalName $SPOAppID).ObjectID
$MsolNameIdentifier = "$MsolServicePrincipalID@$MsolCompanyInformationID"

# establish the trust from on-premise with ACS (Azure Control Service)

# add a new authenticatio realm
$SPSite = Get-SPSite $SPSite
$SPAppPrincipal = Register-SPAppPrincipal -site $SPSite.rootweb -nameIdentifier $MsolNameIdentifier -displayName "SharePoint Online"
Set-SPAuthenticationRealm -realm $MsolServicePrincipalID

# register the ACS application proxy and token issuer
New-SPAzureAccessControlServiceApplicationProxy -Name "ACS" -MetadataServiceEndpointUri "https://accounts.accesscontrol.windows.net/metadata/json/1/" -DefaultProxyGroup
New-SPTrustedSecurityTokenIssuer -MetadataEndpoint "https://accounts.accesscontrol.windows.net/metadata/json/1/" -IsTrustBroker -Name "ACS"

Add a new result source

To get search results from SharePoint Online we have to add a new result source. Run the following script in a PowerShell ISE session on your SharePoint 2013 on-premise server. Don’t forget to update the settings region

if(-not (Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue)){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}

# region settings 
$RemoteSharePointUrl = "http://[example].sharepoint.com"
$ResultSourceName = "SharePoint Online"
$QueryTransform = "{searchTerms}"
$Provier = "SharePoint-Remoteanbieter"
# region settings end

$SPEnterpriseSearchServiceApplication = Get-SPEnterpriseSearchServiceApplication
$FederationManager = New-Object Microsoft.Office.Server.Search.Administration.Query.FederationManager($SPEnterpriseSearchServiceApplication)
$SPEnterpriseSearchOwner = Get-SPEnterpriseSearchOwner -Level Ssa  

$ResultSource = $FederationManager.GetSourceByName($ResultSourceName, $SPEnterpriseSearchOwner)
if(!$ResultSource){
    Write-Host "Result source does not exist. Creating..."
    $ResultSource = $FederationManager.CreateSource($SPEnterpriseSearchOwner)
}

$ResultSource.Name = $ResultSourceName
$ResultSource.ProviderId = $FederationManager.ListProviders()[$Provier].Id
$ResultSource.ConnectionUrlTemplate = $RemoteSharePointUrl
$ResultSource.CreateQueryTransform($QueryTransform)
$ResultSource.Commit()

Add a new query rule

In the Search Administration click on Query Rules
Select Local SharePoint as Result Source
Click New Query Rule
Enter a Rule name f.g. Search results from SharePoint Online
Expand the Context section
Under Query is performed on these sources click on Add Source
Select your SharePoint Online result source
In the Query Conditions section click on Remove Condition
In the Actions section click on Add Result Block
As title enter Results for “{subjectTerms}” from SharePoint Online
In the Search this Source dropdown select your SharePoint Online result source
Select 3 in the Items dropdown
Expand the Settings section and select “More” link goes to the following URL
In the box below enter this Url https://[example].sharepoint.com/search/pages/results.aspx?k={subjectTerms}
Select This block is always shown above core results and click the OK button
Save the new query rule

Source

Display hybrid search results in SharePoint Server 2013
Office 365-Configure Hybrid Search with Directory Synchronization –Password Sync
Office 365-Configure Hybrid Search with Directory Synchronization –Password Sync –Part2

Replicate term set changes for managed metadata navigations

Fri, 09 May 2014 08:24:47 +0000

This post is a supplement to Limitations and workarounds for managed metadata navigation for multiple site collections.

According to my last post I’ve updated the navigation for all my site collections to use a term set with pinned terms from the global navigation term set. What I didn’t was the fact that changes in the global navigation term set won’t be applied to pinned terms in other sets.

To apply this changes I’ve written a simple PowerShell function that repins the global navigation terms on the allocated navigation term set.

<#
$Metadata = @{
	Title = "Update SharePoint Web Term Navigation"
	Filename = "Update-SPWebTermNavigation.ps1"
	Description = ""
	Tags = "sharepoint, managed, metadata, navigation"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2014-05-09"
	LastEditDate = "2014-05-09"
	Url = ""
	Version = "0.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ch/ or 
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

function Update-SPWebTermNavigation{

<#
.SYNOPSIS
    Update the term based navigation for a speific SharePoint website.

.DESCRIPTION
    Update the term based navigation for a speific SharePoint website.

.PARAMETER Identity
	Url of the website.

.PARAMETER MMSSite
	Managed metadata site.

.PARAMETER TermStoreName
	Name of the term store that holds the navigation term groups.

.PARAMETER TermGroupName
	Name of the term group that holds the navigation term sets.

.PARAMETER TermSetName
	Name of the term set that hold the navigation terms for this website.

.PARAMETER GlobalNavigationTermGroupName
	Name of the term group that holds the global navigation term set. Only required if this is different from the term group name.

.PARAMETER GlobalNavigationTermSetName
	Name of the global term set where the terms should be pinned from.

.EXAMPLE
	PS C:\> Update-SPWebTermNavigation -Identity "http://SiteXY.example.org" -MMSSite "http://sharepoint.example.org" -TermStoreName "Store1" -TermGroupName "Navigation" -TermSetName "SiteXY" -GlobalNavigationTermSetName "GlobalNavigation"

.EXAMPLE
	PS C:\> Update-SPWebTermNavigation -Identity "http://SiteXY.example.org" -MMSSite "http://sharepoint.example.org" -TermStoreName "Store1" -TermGroupName "Navigation" -TermSetName "SiteXY" -GlobalNavigationTermGroupName "AnotherNavigation" -GlobalNavigationTermSetName "GlobalNavigation"

#>

    [CmdletBinding()]
    param(

        [Parameter(Mandatory=$true)]
        [String]$Identity,

        [Parameter(Mandatory=$true)]
        [String]$MMSSite,
        
        [Parameter(Mandatory=$true)]
        [String]$TermStoreName,
        
        [Parameter(Mandatory=$true)]
        [String]$TermGroupName,
        
        [Parameter(Mandatory=$true)]
        [String]$TermSetName,
        
        [Parameter(Mandatory=$false)]
        [String]$GlobalNavigationTermGroupName,

        [Parameter(Mandatory=$true)]
        [String]$GlobalNavigationTermSetName
    )

    #--------------------------------------------------#
    # modules
    #--------------------------------------------------#

    if(-not (Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue)){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}
      
    #--------------------------------------------------#
    # main
    #--------------------------------------------------#

    Write-Host "Update term navigation settings for: $Identity"

    # get website and site collection
    $SPWeb = Get-SPWeb $Identity
    $SPSite = $SPWeb.Site

    # get the navigation settings
    $WebNavigationSettings = New-Object Microsoft.SharePoint.Publishing.Navigation.WebNavigationSettings($SPWeb)

    # get the navigation term set
    $SPTaxonomySession = Get-SPTaxonomySession -Site $MMSSite
    $TermStore = $SPTaxonomySession.TermStores[$TermStoreName]
    $TermGroup = $TermStore.Groups[$TermGroupName]
    $TermSet = $TermGroup.TermSets[$TermSetName]

    # get the global navigation term set
    if($GlobalNavigationTermGroupName){
        $GlobalNavigationTermGroup = $TermStore.Groups[$GlobalNavigationTermGroupName]
        $GlobalNavigationTermSet = $GlobalNavigationTermGroup.TermSets[$GlobalNavigationTermSetName]
    }else{
        $GlobalNavigationTermSet = $TermGroup.TermSets[$GlobalNavigationTermSetName]
    }

    # remove all the existing terms
    $TermSet.Terms | ForEach-Object{$_.delete()}
    $TermStore.CommitAll()

     # pin the terms from the master term set
     $GlobalNavigationTermSet.Terms | ForEach-Object{$TermSet.ReuseTermWithPinning($_) | Out-Null}

     # copy the sort order
     $TermSet.CustomSortOrder = $GlobalNavigationTermSet.CustomSortOrder 
     $TermStore.CommitAll()

     # update the navigation settings
     $WebNavigationSettings.GlobalNavigation.Source = 2
     $WebNavigationSettings.GlobalNavigation.TermStoreId = $TermStore.Id
     $WebNavigationSettings.GlobalNavigation.TermSetId = $TermSet.Id

     $WebNavigationSettings.AddNewPagesToNavigation = $false
     $WebNavigationSettings.CreateFriendlyUrlsForNewPages = $false
     $WebNavigationSettings.Update()
}

This function is part of my PowerShell PowerUp framework.

Credits

http://johnlearnt.blogspot.ch/2013/07/sharepoint-2013-cross-site-managed.html

SharePoint PowerShell remoting double hop scenario

Wed, 30 Apr 2014 08:34:14 +0000

PowerShell remoting can be difficult to understand. There are many things to configure and unknown limitations. With multiple server to access from one remoting session it gets even more difficult.

For example my latest issue with a three tier SharePoint environment. I thought I configured everything correctly:

The user of the remote machine is administrator of the SharePoint machines.
The user of the remote machine is farm administrator.
The user of the remote machine is db_owner and shell_access on the SharePoint config database.
Both environments with remote PowerShell enabled.
The user of the remote machine is allowed to login on the remote machine.

However I still received an error when I’ve executed a SharePoint cmdlet via remoting session.

$Session = New-PSSession -ComputerName <ComputerName> -Credential (Get-Credential)
Invoke-Command -Session $Session -ScriptBlock {param ($Name) Add-PSSnapin -Name $Name} -ArgumentList "Microsoft.SharePoint.PowerShell"
Invoke-Command -Session $Session -ScriptBlock {Get-SPSite}

Cannot access the local farm. Verify that the local farm is properly configured, currently available, and that you
have the appropriate permissions to access the database before trying again.
    + CategoryInfo          : InvalidData: (Microsoft.Share...SPCmdletGetSite:SPCmdletGetSite) [Get-SPSite], SPCmdletE
   xception
    + FullyQualifiedErrorId : Microsoft.SharePoint.PowerShell.SPCmdletGetSite

I’ve figuered that’s about the PowerShell remoting double hop issue. The remote SharePoint server can’t authenticate against the SQL server with the credentials I’m providing from the remoting shell.

This is only possible with the CredSSP authentication type. Here are the steps to configure CredSSP for a remote session.

On the server run:

Enable-WSManCredSSP -Role Server

On the client run:

Enable-WSManCredSSP -Role Client -DelegateComputer <server FQDN>

Now you should be able to run the SharePoint cmdlets on the client. Don’t forget to provide the new authentication type for the New-PSSession command.

$Session = New-PSSession -ComputerName <ComputerName> -Credential (Get-Credential) -Authentication Credssp
Invoke-Command -Session $Session -ScriptBlock {param ($Name) Add-PSSnapin -Name $Name} -ArgumentList "Microsoft.SharePoint.PowerShell"
Invoke-Command -Session $Session -ScriptBlock {Get-SPSite}

Limitations and workarounds for managed metadata navigation for multiple site collections

Wed, 23 Apr 2014 09:53:45 +0000

With SharePoint 2013 you can create a managed metadata navigation and share it across web applications and site collections.

But there’s an ugly limitation for site collections.

It seems that’s not possible to share a term set navigation with more than one site collection.

When trying to do so you’ll might get error messages as:

“The selected term set is already used by another site…”

Or:

“Error loading navigation: The Managed Navigation term set is improperly attached to the site.”

However the workaround is simple and depending on the use case it could even be an improvement for a more flexible navigation.

For each site collection where you want to use a custom metadata navigation you have to create a term set in the term store.

Within these term sets you’ll pin the navigation terms from the global navigation. Instead of sharing the global navigation which’s not working, you’re going to share specific term trees by pinning in term sets.

In my case I’ve got two site collections and I’m going to add the project site to the navigation:

Monitoring a SharePoint Environment with Zabbix

Mon, 14 Apr 2014 15:16:08 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

Zabbix is an OpenSource monitoring tool. And offers everything from simple storage availabilty reporting up to end to end web service calls. It’s extensible with plugins and shell scripts. There isn’t a thing you can’t monitor with Zabbix.

In our company we use Zabbix to monitor the SharePoint infrastructure. One of the great features for this case is the web monitor. Zabbix can request specific websites and authenticate against the webserver. That’s why I don’t need an IIS warm up script for our SharePoint infrastructure. Zabbix always makes a request against the SharePoint website after an IIS recycle.

In case you already have a running Zabbix server you can monitor your SharePoint web application with this web rule:

Install SharePoint 2013 Three-tier Farm - Migrate SharePoint 2010 Data

Mon, 14 Apr 2014 09:36:40 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

This time I’ll show you my approach for a SharePoint 2010 to 2013 migration.

Preparation

Remove third party solutions as they might won’t be necessary or compatible in SharePoint 2013.
Report your existing DB security (a migration will remove existing DB login permission roles).

Migration

Migrate content databases in their specific dependency order. For example if you haven an site collection with site columns that make use of the Managed Metadata service you have to migrate the Managed Metadata service database first.

Migrate Managed Metadata service

Backup the existing database
Remove the service application in SharePoint 2013
Copy the existing database export to the SharePoint 2013 server
Restore the database
Rename the database according to the new naming concept (only necessary if the it has changed)
Update the permissions of the database according to the permission report
Create a new Managed Metadata service application and select the imported database
Update the term store administrators

Migrate site collection

Backup the existing content database
Detach the site collection database in SharePoint 2013
Delete the detached content database in SharePoint 2013
Copy the existing database export to the SharePoint 2013 server
Restore the database
Rename the database according to the new naming concept (only necessary if the it has changed)
Update the permissions of the database according to the permission report
Test the restored database with the SharePoint PowerShell command line Test-SPContentDatabase -Name DatabaseName -WebApplication http://example.sharepoint.com
This test will output some compatibility issues, take action according to the error messages
Attach the database to the farm with PowerShell Mount-SPContentDatabase -Name DatabaseName -DatabaseServer SQLServer -WebApplication http://example.sharepoint.com -AssignNewDatabaseId
Upate site collection administrators on the site collection
Disable locks of the collection
Delete Office Web Apps site collection
Run Get-SPsite and look after the CompatibilityLevel attribute. Everything less than 15 needs an visual upgrade
Update the visual design for all SharePoint site Get-SPSite http://example.sharepoint.com | Upgrade-SPSite -VersionUpgrade
Update to username to claims by entering these commands in PowerShell:

$SPWebApplication = Get-SPWebApplication http://sharepoint.vbl.ch
$SPWebApplication.MigrateUsers($true)
$SPWebApplication.ProvisionGlobally()

Installing and Configuring SharePoint 2013 Farm

Mon, 14 Apr 2014 09:29:48 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

This is a shortened version of my best practice for installing a SharePoint server.

Local user rights

Group Local Administrators members:

User: Administrator (Built-In)
Group: Domain\Domain Admins
User: Domain\SP_Admin
User: Domain\SP_Farm

System configuraton

Installed PowerShell PowerUp
Installed English Language Paket
Disabled UAC
Disabled Internet Explorer Enhanced Security
Turn off Windows Firewall for Domain
Update zone settings

SQL alias

sp1sql: sp1sql.domain.com

Install prerequisites

To Install the prerquisisites you should use a PowerShell script from Technet http://gallery.technet.microsoft.com/DownloadInstall-SharePoint-e6df9eb8

Installation

Install Microsoft Office Servers on a additional drive.

Don’t configure the SharePoint Farm with the built-in wizard.

I recommend to install the SharePoint Farm with PowerShell only.

The most popular PowerShell install solution for SharePoint is https://autospinstaller.codeplex.com/

AutoSPInstallation offers a lot features and takes a lot of time to configure it. If it’s too much I’ve got another install solution for you https://gist.github.com/8862266

Update

You can get the latest SharePoint 2013 Updates from this Microsoft site http://technet.microsoft.com/en-us/sharepoint/jj891062.aspx

Install SharePoint 2013 Three-tier Farm - Configuring User Profiles

Mon, 14 Apr 2014 09:24:12 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

Filter settings

By default SharePoint won’t user profiles of disabled accounts. To change that update the connection filter on the User Profile Sync service.

As you can see I’ve added a rule for the userAccountControl. Only activated user accounts get a MySite profile.

Enable page lock

This is another SQL database best practice to enable page locks on the User Profile Sync database indexes.

First run this SQL statement:

USE "SP_AS_UPS_Sync"
GO
SELECT 'ALTER INDEX ' + I.Name + ' ON ' + T.Name + ' SET (ALLOW_PAGE_LOCKS = ON)' As Command
FROM sys.indexes I
LEFT OUTER JOIN sys.tables T ON I.object_id = t.object_id
WHERE I.allow_page_locks = 0 AND T.name IS NOT NULL

This statement will output the alter statement foreach index. Run this output as well.

ALTER INDEX IX_RequestOutput_ObjectKey ON RequestOutput SET (ALLOW_PAGE_LOCKS = ON)
ALTER INDEX IX_RequestOutput_RequestIdentifier_ObjectID_AttributeKey_ValueReference ON RequestOutput SET (ALLOW_PAGE_LOCKS = ON)
...

Add a new file type in SharePoint - KeePass example

Mon, 14 Apr 2014 08:15:07 +0000

In this post I’ll show you how to enable a new file type in SharePoint.

The goal is simple, for the KeePass database file it should be possible to open them the same way as it works for office documents in SharePoint.

Icon

The KeePass database file has the extension .kdbx. For this file type we are going to add an icon.

Open the folder C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\TEMPLATE\IMAGES on your SharePoint server.

Now add this KeePass icon image file to the IMAGES folder:

To associate the icon image the file extension we need to add an entry to the DOCICON file.

Edit the file C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\TEMPLATE\XML\DOCICON.XML and add this line to the <ByExtension> node:

<Mapping Key="kdbx" Value="KeePass_Icon.png" EditText="Keepass Password Manager"/>

Open file

To enable file opening for the database file with the KeePass program run this PowerShell script on the SharePoint server:

# get all webapplications
$SPWebApps = Get-SPWebApplication

# set browser mime type
$mimeType = "application/vnd.keepass"
$SPWebApps | foreach-object { 

    # If the MIME Type is not already on the allowed list for the Web Application 
    if(!$_.AllowedInlineDownloadedMimeTypes.Contains($mimeType)){ 

        # Add the MIME type to the allowed list and update the Web Application 
        $_.AllowedInlineDownloadedMimeTypes.Add($mimeType) 
        $_.Update() 
        Write-Host Added $mimeType to the allowed list for Web Application $_.Name 

    }else{ 

        # The MIME type was already allowed - can't add. Inform user 
        Write-Host Skipped Web Application $_.Name - $mimeType was already allowed 
    } 
}

This script adds the KeePass mime type on every SharePoint web application.

Make sure that the SharePoint web application containing the KeePass database file has set the browser file handling permissive.

In case you want to change that with PowerShell run this script on your SharePoint server:

# get all webapplications
$SPWebApps = Get-SPWebApplication

# set global file handling
$SPWebApps | foreach-object {
 if($_.BrowserFileHandling -ne "permissive" ){
      $_.BrowserFileHandling = "permissive" 
      $_.Update()
  }
}

Last thing we need to do is to restart the IIS webserver, run the command iisreset.

Hide the Open in Explorer option in the SharePoint command ribbon

Tue, 08 Apr 2014 08:27:02 +0000

Since it’s possible to upload documents to SharePoint via Drag and Drop, the “Open in Explorer” option in SharePoint can be removed.

I recommend to remove this option unregarded of it’s possible to upload via Drag and Drop as the user can’t update document metadata in the windows explorer.

Here’s an example of what we want:

And the solution to achieve this, is available on GitHub: https://codeberg.org/janikvonrotz/SharePoint-Hide-Open-With-Explorer

SharePoint Class Registration Form

Mon, 07 Apr 2014 12:25:53 +0000

Introduction

This walkthrough shows how to build an automated registration form that closes down registration if the seats in the class fill up.

Here’s an example of what the result will look like:

Create Lists

This solution requires two lists, one containing the classes and another one containing the registrations.

Class Calendar

The class calendar list holds the classes and informations such as the remaining seats.

Type: Calendar

Fields:

Seats
- Type: Number
FilledSeats
- Type: Number
RemainingSeats
- Type: Calculated
- Formula: =Seats-FilledSeats
- Data type returned: Number
SeatsIncrement
- Type: Calculated
- Formula: =FilledSeats+1
- Data type returned: Number
Closed
- Type: Yes/No
- Default value: No
StaticID
- Type: Number
- Note: This is a Hack we have to put in because we can’t use the real ID field in a calculated column. We will use a workflow to fill it in correctly later. I am open to suggestions on a better way to do this.
Register
- Type: Calculated
- Formula: =IF(Closed=TRUE;"Closed for registration";IF(RemainingSeats>0;CONCATENATE("<a href='#' onclick='OpenRegistrationForm(";StaticID;")'>Register</a>");"Class is Full"))
- Data type returned: Number
- Note: You might have to replace the semicolons with commas as this seperater depends on the SharePoint localized installation.

Class Calendar view

In order to register for an class we need a custom view.

Type: Default view

Option: Make this the default view

Columns:

Title
Location
Description
Start Time
End Time
Seats
RemainingSeats
Register

Class Attendees

This list contains the registration every entry shows the attendee and the chosen class ID.

Type: Custom List

Fields:

Username
- Type: Single line of text
- Option: Required
Meeting
- Type: Lookup
- List: Class Calendar
- Field: Title
MeetingID
- Type: Single line of text

Create Workflows

SetStaticClassID Workflow

The SetStaticClassID Workflow is really a hack because SharePoint won’t let you use the ID field in the calculated columns. All we are doing is setting a number field with the ID field every time the calendar item is created or modified.

Open the Class Calendar in SharePoint Designer
Add a list workflow
Name it: SetStaticClassID
Update Start Options: Start Workflow automatically when an item is created and Start workflow automatically when an item is changed
Add an action: Set Field in Current Item
For field link choose: StaticID
For value link click on the fx button
Data source: Current Item
Field from source: ID
Save and publish

Registration Workflow

The Registration Workflow is one of the main parts of this solution. This is the Workflow that will update the remaining seats in the calendar list when an Attendee register for the course.

Open the Class Attendees list in SharePoint Designer
Add a list workflow
Name it: Registration
Update Start Options: Start Workflow automatically when an item is created
Add an action: Update List Item
Click the “this list” link in the action
Change the list ot the Class Calendar list created earlier
Click the “Add” button
Choose “FilledSeats”
Click the fx button
Data source: Class Calendar
Field from source: SeatIncrement
Field: ID
Click the fx button
Data source: Current Item
Field from source: MeetingID
Close all dialogs until you get back to the “Update list Item” dialog by clicking on ok
In the same dialog in the Find the list item section choose for Field: ID
Click on the fx button
Data source: Current Item
Field from source: MeetingID
Click ok
Save and publish

Create InfoPath Form

The end user will eventually register through the InfoPath form on the Class Attendees list.

Open the Class Attendees list InfoPath form
Right-click on the Title entry field and select Text Box Properites
Click the fx button on the default value filed
Add this for the formula concat(Username, " registration for event number ", Meeting)
Add a fomratting rule to the Title and MeetingID field
Check “Hide this control” foreach formatting rule
Move the filed Title and MeetingID to the bottom of the form as the will be invisible.
Add a formatting rule to the Username and Meeting field
Check “Disable this control” foreach formatting rule
Right-click on the Username entry field and select Text Box Properites
Click on the fx button for the default value
Add this formula username()
Select the Meeting entry field
In the Properties tab click the “Default Value” button
Click the fx button on the default value field
Insert the MeetingID field
Delte the Attachments field
Publish the form

Querystring

In order to automatically set the the meeting in the InfoPath form, we will use a query string to the MeetingID field.

Open the Class Attendees list
Select the List tab > Form Web Parts > (Item) New Form
Add a Query String (URL) Filter webpart
Updat the “Query String Parameter Name” with meeting_id in the webpart properties
In the webpart options select Connection > Send Filter Values To > InfoPath Form Web Part
Select the MeetingID field as Consumer Field Name
Save the changes

Add JavaScript

The javascript creates the dialog box javascript to open our new form. The call to this javascript method is in the calculated field on the attendees list to register.

Open the SharePoint site were you are going to display the Class Calendar list webpart
Edit the page and select Embed Code on the Insert tab
Paste the following javascript and save the page

<script type="text/javascript" src="//cdn.jsdelivr.net/jquery/2.1.0/jquery.min.js">
// visit http://www.jsdelivr.com/#!jquery to update the cdn url
</script>
<script type="text/javascript">
function OpenRegistrationForm(meeting_id){
    var options = {
    // to geht following make a right click on the new item link in the Class Attendees list and select open in new tab.
    // Now copy the url in the browser from the beginning to the of the &RootFolder= part
    // Inser the link below and replace [RootFolder] with meeting_id
    url:"http://sharepoint.vbl.ch/Personal/Lists/Class%20Attendees/Item/newifs.aspx?List=21803ee2-66ab-4df2-9116-b02853ca7e1a&meeting_id="  + meeting_id,
    width: 750,
    height: 600,
    dialogReturnValueCallback: DialogCallback
  };
  SP.UI.ModalDialog.showModalDialog(options);
}
function DialogCallback(dialogResult, returnValue){}
</script>

Finally

Now we got everything required to set up our Class Registration Form.

Open the SharePoint site were you are going to display the Class Calendar list webpart
Add the Class Calendar list webpart
Edit the webpart and select the Registration view
Add a class example
Now you should be able to register for classes by click on the registration link.

Source

SharePoint Calculated Columns By Andy Wessendorf SharePoint 2010 Class Registration Form Enable clickable urls in calculated fiels)

Manage your SharePoint default settings with PowerShell

Fri, 04 Apr 2014 10:16:07 +0000

This post is part of my PowerShell PowerUp project.

The only way to deploy SharePoint default settings for site collections and sites manually is using predefined site templates or an ugly third party tool. And in case you’ll do that with site templates it’ll cost a lot of the time to update settings which were already set.

However with PowerShell it’s possible to deploy SharePoint default settings automatically and it’s a lot easier than you might think.

Today I want to show you my SharePoint default settings script. It does a lot of work for me:

Update Active Directory group display names
Set the navigation inheritance
Set a corporate site logo
Enable and disable versioning on selected lists and libraries
Add support for multilingualism globally
Enable selected installed languages on websites

There are some functions in the script which you can’t know f.g. Write-PPEventLog, these are custom functions and are part of my PowerShell PowerUp project.

<#
$Metadata = @{
	Title = "SharePoint Default Settings"
	Filename = "Set-SPDefaultSettings.ps1"
	Description = ""
	Tags = "powershell, script, sharepoint, default settings"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "http://www.janikvonrotz.ch"
	CreateDate = "2013-05-07"
	LastEditDate = "2014-04-04"
	Version = "3.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/3.0/ or
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

try{

    #--------------------------------------------------#
    # modules
    #--------------------------------------------------#
    if((Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}
    Import-Module ActiveDirectory
    
    #--------------------------------------------------#
    # settings
    #--------------------------------------------------#
    
    $Configuration = @{
        SPSite = "http://sharepoint.vbl.ch"
        SPADGroupFilter = "SP_*"
        SPADGroupContainer = "OU=SharePoint,OU=Services,OU=vblusers2,DC=vbl,DC=ch"
        SPNavigationWebExclude = "http://sharepoint.vbl.ch/Projekte"
        AllowedVersioningTypes = "Unternehmenswiki-Seite","Dokument","Wiki-Seite"
        DisabledVersioningTypes = "Survey"
        SupportedLanguages = "Deutsch", "Englisch"
    },
    @{
        SPSite = "http://sharepoint.vbl.ch/itwiki"
        SPADGroupFilter = "SP_*"
        SPADGroupContainer = "OU=SharePoint,OU=Services,OU=vblusers2,DC=vbl,DC=ch"
        AllowedVersioningTypes = "Unternehmenswiki-Seite","Dokument","Wiki-Seite"
        DisabledVersioningTypes = "Survey"
        SupportedLanguages = "Deutsch", "Englisch"
    },
    @{
        SPSite = "http://extranetvr.vbl.ch"
        SPADGroupFilter = "SP2_*"
        SPADGroupContainer = "OU=SharePoint,OU=Services,OU=vblusers2,DC=vbl,DC=ch"
        AllowedVersioningTypes = "Unternehmenswiki-Seite","Dokument","Wiki-Seite"
        DisabledVersioningBaseTypes = "Survey"
        SupportedLanguages = "Deutsch", "Englisch"
    }

    $Configuration | ForEach-Object{

        # get domain
        $ADDomain = ((Get-ADDomain).Name).ToUpper()
    
        # temp var for loops
        $Config = $_
            
            
        # update AD group names
              
        # SharePoint AD Groups 
        $ADGroups = Get-ADGroup -Filter * -SearchBase $_.SPADGroupContainer | Where-Object{$_.Name -like $Config.SPADGroupFilter}
            
        Get-SPUser -Limit All -Web $_.SPSite | Where-Object{$_.IsDomainGroup -and $_.Name -like "$($ADDomain)\$Config.SPADGroupFilter"} | ForEach-Object{
                
            $SPUser = $_
                    
            $ADGroups | Where-Object{
                
                # without claims
                (($_.SID -eq $SPUser.Sid) -or 
                                
                # claims
                ($SPUser.LoginName -like "*$($_.SID)")) -and 

                # check name
                ("$ADDomain\$(($_.Name).ToLower())" -ne $SPUser.Name.ToLower())
                
            } | ForEach-Object{
            
                Write-PPEventLog -Message "Change Displayname for SPGroup: $($SPUser.Name) to: " + "$ADDomain\$(($_.Name).ToLower())" -Source "SharePoint Default Settings" -WriteMessage        
                Set-SPUser $SPUser -DisplayName "$ADDomain\$(($_.Name).ToLower())"
            } 
        }       
         
        
        # website settings

        Get-SPSite | where{$_.Url -eq $Config.SPSite} | Get-SPWeb -Limit All  | ForEach-Object{

            # temp var for loops
            $SPWeb = $_


            # update navigation inheritance except for excluded sites

    	    if(
            ($_.Url).startsWith($Config.SPSite) -and     
            ($_.Url -ne $Config.SPSite) -and    
            ($Config.SPNavigationWebExclude -notcontains $_.Url)
            ){            
    		    $SPPublishingWeb = [Microsoft.SharePoint.Publishing.PublishingWeb]::GetPublishingWeb($_)
    		    $SPPublishingWeb.Navigation.InheritGlobal = $true
    		    $SPPublishingWeb.Navigation.GlobalIncludeSubSites = $true
    		    $SPPublishingWeb.Update()
            }
        

            # update Site Logo

            $_.SiteLogoUrl = $(Get-SPWeb $Config.SPSite).SiteLogoUrl
            $_.Update()
        

            # Enable versioning on lists

            $_.Lists | Where-Object{ $Config.DisabledVersioningBaseTypes -notcontains $_.basetype} | ForEach-Object{
            
                # get content types foreach list
                $Types = $_.ContentTypes | %{$_.Name}
            
                # enable versionging for document libraries and wiki sites
                if(($Types | where{$Config.AllowedVersioningTypes -contains $_}) -and ($_.EnableVersioning -eq $false)){
            
                    Write-PPEventLog -Message "Enable Versioning for: $($_.title) on: $($_.parentweb.title)." -Source "SharePoint Default Settings" -WriteMessage
                        
                    $_.EnableVersioning = $true
                    $_.MajorVersionLimit = 10   
                    $_.Update()   
                
                # disable versioning fore everything else
                }elseif(($_.EnableVersioning -eq $true) -and -not ($Types | where{$Config.AllowedVersioningTypes -contains $_})){
            
                    Write-PPEventLog -Message "Disable Versioning for: $($_.title) on: $($_.parentweb.title)." -Source "SharePoint Default Settings" -WriteMessage
            
                    $_.EnableVersioning = $false       
                    $_.Update()
                }
            }


            # Enable alternative languages

            # enable multilingualism globally
            $_.IsMultilingual = $true

            # get already enabled languages IDs
            $EnabledLanguageIDs = $_.SupportedUICultures | ForEach-Object{$_.LCID}

            # get regtional settings objects
            $SPRegionalSettings = New-Object Microsoft.SharePoint.SPRegionalSettings($_)

            # enable every installed and supported language as longs it's not yet enabled
            $SPRegionalSettings.InstalledLanguages | where{$Config.SupportedLanguages -contains $_.DisplayName -and $EnabledLanguageIDs -notcontains $_.LCID} | ForEach-Object{
                
                Write-PPEventLog -Message "Enable language: $($_.DisplayName) for SPWeb: $($SPWeb.Url)." -Source "SharePoint Default Settings" -WriteMessage
                $CultureInfo = New-Object System.Globalization.CultureInfo($_.LCID)
                $SPWeb.AddSupportedUICulture($CultureInfo)
            }            

            $SPWeb.Update()
        }  
    }
}catch{

    Write-PPErrorEventLog -Source "SharePoint Default Settings" -ClearErrorVariable
}

Latest version of this script: https://gist.github.com/7871902

Update SharePoint Token Lifetime to update AD permissions faster

Thu, 03 Apr 2014 09:01:03 +0000

Since SharePoint 2013 only supports claim based authentication I discovered that updates in SharePoint Active Directory groups do not take effect immediately.

Thanks to Ryan McIntyre there’s a simple fix for that issue.

By adjusting the lifetime of the claims token you can shorten the time it takes to update the Active Directory group changes.

if(-not (Get-PSSnapin "Microsoft.SharePoint.PowerShell" -ErrorAction SilentlyContinue)){Add-PSSnapin "Microsoft.SharePoint.PowerShell"}

# update SharePoint cache token lifetime

$SPContentService = [Microsoft.SharePoint.Administration.SPWebService]::ContentService
$SPContentService.TokenTimeout = (New-TimeSpan -minutes 5)
$SPContentService.Update()

# udpate SharePoint claims token lifetime

$SPSecurityTokenServiceConfig = Get-SPSecurityTokenServiceConfig
$SPSecurityTokenServiceConfig.WindowsTokenLifetime = (New-TimeSpan –minutes 5)
$SPSecurityTokenServiceConfig.FormsTokenLifetime = (New-TimeSpan -minutes 5)

# if you happen to set a lifetime that is shorter than the expiration window user will be blocked from accessing the site.
$SPSecurityTokenServiceConfig.LogonTokenCacheExpirationWindow = (New-TimeSpan -minutes 4)
$SPSecurityTokenServiceConfig.Update()

Get the latest version of this code snippet here: https://gist.github.com/9950021

SharePoint Export and Import Term Sets from Term Store

Tue, 01 Apr 2014 07:34:23 +0000

The SharePoint term store service is one of the most important parts of a SharePoint installation. It’s the best place to store an manage global metadata for your companies documents.

It’s not that hard to design a term set in Excel and import it afterwards with the built-in term store import wizard.

However there’s no tool or wizard that allows you to get a term set out of the term store.

It’s only possible with my PowerShell function (which is as always part of my PowerShell PowerUp project)

<#
$Metadata = @{
	Title = "Get SharePoint Managed Metadata Service Terms"
	Filename = "Get-SPManagedMetadataServiceTerms.ps1"
	Description = ""
	Tags = "powershell, function, sharepoint, managed, metadata, terms, export"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2014-03-31"
	LastEditDate = "2014-03-31"
	Url = ""
	Version = "1.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ch/ or 
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

function Get-SPManagedMetadataServiceTerms{

<#
.SYNOPSIS
    List all Terms from Managed Metadata service.

.DESCRIPTION
	List all Terms form a specifified term store and optionally filter them by term group.

.PARAMETER Site
	Site running a taxonomy session.

.PARAMETER TermGroup
	Optionally filter the term group.

.EXAMPLE
	PS C:\> Get-SPManagedMetadataServiceTerms -Site "http://SharePoint.domain.com"

.EXAMPLE
	PS C:\> Get-SPManagedMetadataServiceTerms -Site "http://SharePoint.domain.com" -TermGroup "Wiki"

.LINK
    http://technet.microsoft.com/en-us/library/ee424396(v=office.14).aspx

#>

    [CmdletBinding()]
    param(

		[Parameter(Mandatory=$true)]
		[String]
		$Site,

		[String]
		$TermGroup
        
	)
    
    #--------------------------------------------------#
    # functions
    #--------------------------------------------------#

    function Add-ArrayLevelIndex{

        param(
    
            $Object,        
            $AttributeName,        
            $Level = 0
        )
    
        # check the child attribute containing the same type of objects
        $Objects = iex "`$Object.$AttributeName"
    
        # output this item
        $Object | select @{L="Object";E={$_}}, @{L="Level";E={$Level}}
    
        # output the child items of this object
        if($Objects){
    
            # add level
            $Level ++
        
            # loop trough the same function
            $Objects | %{Add-ArrayLevelIndex -Object $_ -AttributeName $AttributeName -Level $Level}

        }
    }

    #--------------------------------------------------#
    # modules
    #--------------------------------------------------# 
    if((Get-PSSnapin 'Microsoft.SharePoint.PowerShell' -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin 'Microsoft.SharePoint.PowerShell'}

    #--------------------------------------------------#
    # main
    #--------------------------------------------------#
    $SPTaxonomies = @()
    $TempTerm = New-Object -TypeName Psobject @{    
        Index = ""
        Term = ""
    }

    $i = 0;
    $TempTerms = while($i -ne 7){
        $i ++
        $e = $TempTerm.PSObject.Copy()
        $e.Index = $i
        $e
    }


    # get all taxonomy objects
    $SPTaxonomies = Get-SPTaxonomySession -Site $Site | %{

        $_.TermStores | %{
    
            $TermStore = New-Object -TypeName Psobject -Property @{
        
                TermStore = $_.Name
                "Term Group" = ""
                "Term Set Name" = ""
                "Term Set Description" = ""   
                LCID = ""             
                "Available for Tagging" = ""                
                Terms = ""      
            }        
        
        
            $_.Groups | Where{$_.Name -eq $TermGroup -or -not $TermGroup} | ForEach-Object{
            
                $Group = $TermStore.PSObject.Copy()
                $Group.'Term Group' = $_.Name                       
        
                $_.TermSets | %{
            
                    $TermSet = $Group.PSObject.Copy()
                    $TermSet.'Term Set Name' = $_.Name
                    $TermSet.'Term Set Description' = $_.Description
                                    
                    $TermSet.Terms = ($_.Terms | %{Add-ArrayLevelIndex -Object $_ -AttributeName "Terms" -Level 1})
            
                    $TermSet                  
                }        
            }        
        }
    }

    # get maximum of levels a term has
    # $Levels = ($SPTaxonomies | %{$_.Terms | %{$_.Level}} | measure -Maximum).Maximum + 1
    # or comment out and use default 7

    # loop throught term stores       
    $SPTaxonomies | %{

        $SPTaxonomy = $_

        # Output Termstore definitions
        $Item = $SPTaxonomy.PSObject.Copy()  
        $Item.'Available for Tagging' = if($_.IsAvailableForTagging){"TRUE"}else{"FALSE"}        
        $i = 0;while($i -ne 7){
            $i ++
            $Item | Add-Member –MemberType NoteProperty –Name "Level $i Term" –Value ""
        }
        $Item |  Select-Object 'Term Set Name','Term Set Description', LCID, 'Available for Tagging', 'Term Description', 'Level*'

    
        # loop throught terms
        $_.Terms | where{$_} | %{
                
            $Term = $_

            # create a term export object
            $Item = $SPTaxonomy.PSObject.Copy()   
             
            $Item.'Available for Tagging' = if($_.IsAvailableForTagging){"TRUE"}else{"FALSE"}
            $Item.'Term Set Name' = ""
            $Item.'Term Set Description' = ""
            
            $_.Object.Labels | ForEach-Object{

                $Item.LCID = $_.Language

                $Index = 0;while($Index -ne 7){
                    $Index ++

                    if($Term.Level -eq $Index){                        

                        $Item | Add-Member –MemberType NoteProperty –Name "Level $Index Term" –Value $Term.Object.Name

                        $TempTerms[$Index].Term = $Term.Object.Name

                    }elseif($Index -gt $Term.Level){
                            
                        $Item | Add-Member –MemberType NoteProperty –Name "Level $Index Term" –Value $Value

                    }elseif($Term.Level -gt $Index){

                        $Item | Add-Member –MemberType NoteProperty –Name "Level $Index Term" –Value $TempTerms[$Index].Term
                        
                    }                                   
                }  
            }   
        
            # output this object
            $Item |  Select-Object 'Term Set Name','Term Set Description', LCID, 'Available for Tagging', 'Term Description', 'Level*'
        }                
    }
}

With this function you can export the a specific term set into a CSV file or show it in the grid view.

Get-SPManagedMetadataServiceTerms -Site "http://sharepoint.domain.com" -TermGroup "Wiki" | Export-Csv -Path TermSet.csv
Get-SPManagedMetadataServiceTerms -Site "http://sharepoint.domain.com" -TermGroup "Wiki" | Out-GridView

Here’s an example for an export to gridview.

Install SharePoint 2013 Three-tier Farm – Installing and Configuring Office Web Apps Server

Tue, 25 Mar 2014 09:18:05 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

With Windows Server 2012 the deployment of Offic Web Apps Server got a lot easier.

Installation

First install the prerequisites.

Add-WindowsFeature Web-Server,Web-Mgmt-Tools,Web-Mgmt-Console,Web-WebServer,Web-Common-Http,Web-Default-Doc,Web-Static-Content,Web-Performance,Web-Stat-Compression,Web-Dyn-Compression,Web-Security,Web-Filtering,Web-Windows-Auth,Web-App-Dev,Web-Net-Ext45,Web-Asp-Net45,Web-ISAPI-Ext,Web-ISAPI-Filter,Web-Includes,InkandHandwritingServices,NET-Framework-Features,NET-Framework-Core

Download the Office Web Apps Server Installer from http://go.microsoft.com/fwlink/p/?LinkId=256561

And install the Office Web Apps Server

Deploy a new Web Apps Server Farm with PowerShell.

New-OfficeWebAppsFarm -InternalUrl "http://example.org" -ExternalUrl "http://example.org" -EditingEnabled -AllowHttp:$true

Update

In order to update a Office Web Apps Server installation you have to remove the existing Office Web Apps Farm.

Remove-OfficeWebAppsMachine

Now you can install the required updates.

If the installation has been finished create the Office Web Apps Farm again according to your settings.

New-OfficeWebAppsFarm -InternalUrl "http://example.org" -ExternalUrl "http://example.org" -EditingEnabled -AllowHttp:$true

The check wether Office Web Apps are running open your browser on:

http://example.org/hosting/discovery

Source

Microsoft Technet: Deploy Office Web Apps Server Update Office Web Apps Server 2013

Enable Sign in as different user option in SharePoint 2013

Mon, 24 Mar 2014 15:49:46 +0000

By default in SharePoint 2013 there is no option for “Sign in as different user”.

To enable this option you have the update the SharePoint welcome template.

C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\TEMPLATE\CONTROLTEMPLATES\Welcome.ascx

Add the following code after the <SharePoint:MenuItemTemplate runat="server" id="ID_RequestAccess" finisher tag />.

<SharePoint:MenuItemTemplate runat="server" ID="ID_LoginAsDifferentUser"
  Text="<%$Resources:wss,personalactions_loginasdifferentuser%>"
  Description="<%$Resources:wss,personalactions_loginasdifferentuserdescription%>"
  MenuGroupId="100"
  Sequence="100"
  UseShortId="true"
/>

Source

How to enable “Sign in as different user” option in SharePoint 2013

For those who couldn’t attend SharePoint Conference 2014

Thu, 13 Mar 2014 09:23:00 +0000

For those who couldn’t attend SharePoint Conference 2014 including me, the guy from Absolute SharePoint Blog has published a script to download all slides and videos of the presentations at SPC2014.

By default the script does:

Due to the immense file size of a bit under 70GB I’ve improved the script so that you can choose whether to include the videos or slides in the download or not.

Copy this script to C:\spc14 and execute it.

# settings 
$DownloadVideos = $false
$DownloadSlides = $true


[Environment]::CurrentDirectory=(Get-Location -PSProvider FileSystem).ProviderPath 
$rss = (new-object net.webclient)

# Grab the RSS feed for the MP4 downloads

# SharePoint Conference 2014 Videos
$a = ([[xml]]$rss.downloadstring("https://channel9.msdn.com/Events/SharePoint-Conference/2014/RSS/mp4high")) 
$b = ([[xml]]$rss.downloadstring("https://channel9.msdn.com/Events/SharePoint-Conference/2014/RSS/slides")) 

#other qualities for the videos only. Choose the one you want!
# $a = ([[xml]]$rss.downloadstring("https://channel9.msdn.com/Events/SharePoint-Conference/2014/RSS/mp4")) 
# $a = ([[xml]]$rss.downloadstring("https://channel9.msdn.com/Events/SharePoint-Conference/2014/RSS/mp3")) 

#Preferably enter something not too long to not have filename problems! cut and paste them afterwards
$downloadlocation = "C:\spc14"

if (-not (Test-Path $downloadlocation)) { 
	Write-Host "Folder $fpath dosen't exist. Creating it..."  
	New-Item $downloadlocation -type directory 
}
cd $downloadlocation



#Download all the slides	
if($DownloadSlides){$b.rss.channel.item | foreach{   

	$code = $_.comments.split("/") | select -last 1	   
	
	# Grab the URL for the PPTX file
	$urlpptx = New-Object System.Uri($_.enclosure.url)  
    $filepptx = $code + "-" + $_.creator + " - " + $_.title.Replace(":", "-").Replace("?", "").Replace("/", "-").Replace("<", "").Replace("|", "").Replace('"',"").Replace("*","")
	$filepptx = $filepptx.substring(0, [System.Math]::Min(120, $filepptx.Length))
	$filepptx = $filepptx + ".pptx" 
	
	if ($code -ne ""){
	
		 $folder = $code + " - " + $_.title.Replace(":", "-").Replace("?", "").Replace("/", "-").Replace("<", "").Replace("|", "").Replace('"',"").Replace("*","")
		 $folder = $folder.substring(0, [System.Math]::Min(100, $folder.Length))
	
	}else{
	
		$folder = "NoCodeSessions"
	}
	
	if (-not (Test-Path $folder)){ 
		Write-Host "Folder $folder dosen't exist. Creating it..."  
		New-Item $folder -type directory 
	}	

	# Make sure the PowerPoint file doesn't already exist
	if (!(test-path $folder\$filepptx)){ 	
	
		# Echo out the  file that's being downloaded
		$filepptx
		$wc = (New-Object System.Net.WebClient)  

		# Download the MP4 file
		$wc.DownloadFile($urlpptx, $filepptx)
		mv $filepptx $folder 

	}
}}

#download all the mp4

# Walk through each item in the feed 
if($DownloadVideos){$a.rss.channel.item | foreach{   
	
	$code = $_.comments.split("/") | select -last 1	   
	
	# Grab the URL for the MP4 file
	$url = New-Object System.Uri($_.enclosure.url)  
	
	# Create the local file name for the MP4 download
	$file = $code + "-" + $_.creator + "-" + $_.title.Replace(":", "-").Replace("?", "").Replace("/", "-").Replace("<", "").Replace("|", "").Replace('"',"").Replace("*","")
	$file = $file.substring(0, [System.Math]::Min(120, $file.Length))
	$file = $file + ".mp4"  
	
	if ($code -ne ""){
	
		 $folder = $code + " - " + $_.title.Replace(":", "-").Replace("?", "").Replace("/", "-").Replace("<", "").Replace("|", "").Replace('"',"").Replace("*","")
		 $folder = $folder.substring(0, [System.Math]::Min(100, $folder.Length))
	}else{
	
		$folder = "NoCodeSessions"
	}
	
	if (-not (Test-Path $folder)){ 
		Write-Host "Folder $folder) dosen't exist. Creating it..."  
		New-Item $folder -type directory 
	}
		
	# Make sure the MP4 file doesn't already exist

	if (!(test-path $folder\$file)){ 	
		# Echo out the  file that's being downloaded
		$file
		$wc = (New-Object System.Net.WebClient)  

		# Download the MP4 file
		$wc.DownloadFile($url, $file)
		mv $file $folder
	}
}}

The spc14 folder should look like this after downloading all the slides and videos.

You’ll find the original script on Technet

SharePoint 2013 navigation sub menu titles cut off

Mon, 10 Mar 2014 14:35:34 +0000

By default SharePoint 2013 cuts off long sub menu titles in the navigation.

SharePoint expects only titles without spaces in between words. This is miss behaviour is simply solved by adding a custom css in the master page template.

ul.dynamic li {
    white-space: nowrap;
}

In the end it should look somehow like this.

Install SharePoint 2013 Three-tier Farm - Installing and Configuring SharePoint SQL Server

Tue, 25 Feb 2014 13:52:33 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

In this post I’ll show my best practice for an new SQL Server to run SharePoint properly.

Let’s get started with local user rights.

The Group Local Administrators members are:

Based on you standards and options I have the following system configurations for you:

And now it’s time to install the SQL server.

The SQL Server 2008 R2 as in my case requires the .Net Framework 3.5. To install it on Windows server 2012 run this command:

dism /online /enable-feature /featurename:NetFX3 /all /Source:d:sourcessxs /LimitAccess

Only after executing this command you’re able to install the .Net framework as usual with the wizard.

At this point where the SQL server installation I don’t want to provide you a step by step guide, as you might install another version or this guide gets obsolete.

I think the sql server configuration file is much more informative.

;SQLSERVER2008 Configuration File
[SQLSERVER2008]

; Specify the Instance ID for the SQL Server features you have specified. SQL Server directory structure, registry structure, and service names will reflect the instance ID of the SQL Server instance.

INSTANCEID="MSSQLSERVER"

; Specifies a Setup work flow, like INSTALL, UNINSTALL, or UPGRADE. This is a required parameter.

ACTION="Install"

; Specifies features to install, uninstall, or upgrade. The list of top-level features include SQL, AS, RS, IS, and Tools. The SQL feature will install the database engine, replication, and full-text. The Tools feature will install Management Tools, Books online, Business Intelligence Development Studio, and other shared components.

FEATURES=SQLENGINE,FULLTEXT,IS,BC,SSMS,ADV_SSMS

; Displays the command line parameters usage

HELP="False"

; Specifies that the detailed Setup log should be piped to the console.

INDICATEPROGRESS="False"

; Setup will not display any user interface.

QUIET="False"

; Setup will display progress only without any user interaction.

QUIETSIMPLE="False"

; Specifies that Setup should install into WOW64. This command line argument is not supported on an IA64 or a 32-bit system.

X86="False"

; Detailed help for command line argument ENU has not been defined yet.

ENU="True"

; Parameter that controls the user interface behavior. Valid values are Normal for the full UI, and AutoAdvance for a simplied UI.

UIMODE="Normal"

; Specify if errors can be reported to Microsoft to improve future SQL Server releases. Specify 1 or True to enable and 0 or False to disable this feature.

ERRORREPORTING="False"

; Specify the root installation directory for native shared components.

INSTALLSHAREDDIR="C:Program FilesMicrosoft SQL Server"

; Specify the root installation directory for the WOW64 shared components.

INSTALLSHAREDWOWDIR="C:Program Files (x86)Microsoft SQL Server"

; Specify the installation directory.

INSTANCEDIR="C:Program FilesMicrosoft SQL Server"

; Specify that SQL Server feature usage data can be collected and sent to Microsoft. Specify 1 or True to enable and 0 or False to disable this feature.

SQMREPORTING="False"

; Specify a default or named instance. MSSQLSERVER is the default instance for non-Express editions and SQLExpress for Express editions. This parameter is required when installing the SQL Server Database Engine (SQL), Analysis Services (AS), or Reporting Services (RS).

INSTANCENAME="MSSQLSERVER"

; Agent account name

AGTSVCACCOUNT="VBLSP1SQL_Agent"

; Auto-start service after installation.

AGTSVCSTARTUPTYPE="Automatic"

; Startup type for Integration Services.

ISSVCSTARTUPTYPE="Automatic"

; Account for Integration Services: DomainUser or system account.

ISSVCACCOUNT="NT AUTHORITYNetworkService"

; Controls the service startup type setting after the service has been created.

ASSVCSTARTUPTYPE="Automatic"

; The collation to be used by Analysis Services.

ASCOLLATION="Latin1_General_CI_AS"

; The location for the Analysis Services data files.

ASDATADIR="Data"

; The location for the Analysis Services log files.

ASLOGDIR="Log"

; The location for the Analysis Services backup files.

ASBACKUPDIR="Backup"

; The location for the Analysis Services temporary files.

ASTEMPDIR="Temp"

; The location for the Analysis Services configuration files.

ASCONFIGDIR="Config"

; Specifies whether or not the MSOLAP provider is allowed to run in process.

ASPROVIDERMSOLAP="1"

; A port number used to connect to the SharePoint Central Administration web application.

FARMADMINPORT="0"

; Startup type for the SQL Server service.

SQLSVCSTARTUPTYPE="Automatic"

; Level to enable FILESTREAM feature at (0, 1, 2 or 3).

FILESTREAMLEVEL="0"

; Set to "1" to enable RANU for SQL Server Express.

ENABLERANU="False"

; Specifies a Windows collation or an SQL collation to use for the Database Engine.

SQLCOLLATION="Latin1_General_CI_AS_KS_WS"

; Account for SQL Server service: DomainUser or system account.

SQLSVCACCOUNT="VBLSP1SQL_Engine"

; Windows account(s) to provision as SQL Server system administrators.

SQLSYSADMINACCOUNTS="VORDEFINIERTAdministratoren" "VBLSP1SQL_Admin"

; Default directory for the Database Engine backup files.

SQLBACKUPDIR="E:Microsoft SQL ServerBackup"

; Default directory for the Database Engine user databases.

SQLUSERDBDIR="E:Microsoft SQL ServerData"

; Provision current user as a Database Engine system administrator for SQL Server 2008 R2 Express.

ADDCURRENTUSERASSQLADMIN="False"

; Specify 0 to disable or 1 to enable the TCP/IP protocol.

TCPENABLED="1"

; Specify 0 to disable or 1 to enable the Named Pipes protocol.

NPENABLED="0"

; Startup type for Browser Service.

BROWSERSVCSTARTUPTYPE="Disabled"

; Specifies how the startup mode of the report server NT service.  When
; Manual - Service startup is manual mode (default).
; Automatic - Service startup is automatic mode.
; Disabled - Service is disabled

RSSVCSTARTUPTYPE="Automatic"

; Specifies which mode report server is installed in.
; Default value: “FilesOnly”

RSINSTALLMODE="FilesOnlyMode"

; Add description of input argument FTSVCACCOUNT

FTSVCACCOUNT="NT AUTHORITYLOCAL SERVICE"

The most important configurations are the data directories and the user service accounts. In the last post we created several service accounts, you can use them now as showed here:

You might have seen, the temdb is stored on the C drive and I know as s a best practice you should not have tempdb on the C drive because the OS has the paging file on C by default and you don’t want the mixed I/O affecting tempdb performance. But let’s be honest this action won’t affect our SharePoint installation in any way.

Now you should have installed the SQL server successfully. Open the management studio, log in and execute these statements:

-- Set Memory

EXEC sys.sp_configure N'show advanced options', N'1'  RECONFIGURE WITH OVERRIDE
GO
EXEC sys.sp_configure N'max server memory (MB)', N'10240'
GO
RECONFIGURE WITH OVERRIDE
GO
EXEC sys.sp_configure N'show advanced options', N'0'  RECONFIGURE WITH OVERRIDE
GO

-- Set-Permission

USE [master]
GO
CREATE LOGIN [VBLsp1_admin] FROM WINDOWS WITH DEFAULT_DATABASE=[master]
GO
EXEC master..sp_addsrvrolemember @loginame = N'domainsp1_admin', @rolename = N'dbcreator'
GO
EXEC master..sp_addsrvrolemember @loginame = N'domainsp1_admin', @rolename = N'securityadmin'
GO

-- Backup Compression

EXEC sys.sp_configure N'backup compression default', N'1'
GO
RECONFIGURE WITH OVERRIDE
GO

-- Max Parallelism

sp_configure 'show advanced options', 1;
GO
RECONFIGURE WITH OVERRIDE;
GO
sp_configure 'max degree of parallelism', 1;
GO
RECONFIGURE WITH OVERRIDE;
GO

Last but not least update the SQL server installation.

On the site https://sqlserverbuilds.blogspot.ch/ you’ll find the latest update definitions for your SQL server installation.

In case you don’t know you SQL server version run this command:

SELECT SERVERPROPERTY('productversion'), SERVERPROPERTY ('productlevel'), SERVERPROPERTY ('edition')

Introducing new SharePoint Online Cmdlets

Mon, 24 Feb 2014 11:19:56 +0000

So far Micosoft doesn’t offer the same amount of cmdlets to manage a SharePoint Online instance as they do for an on-premise installation.

As many other SharePoint administrators I can’t wait to get new cmdlets. Luckily Jeffrey Paarhuis recently published a project on Microsoft Codeplex and showed how simple it is to manage a SharePoint installation just with client-side libraries and functions.

Seconds later I’ve migrated his functions into my project: https://codeberg.org/janikvonrotz/PowerShell-PowerUp

I’ll introduce you the new:

In order to use these commands you have to install the Managed .NET Client-Side Object Model (CSOM) of SharePoint 2013. Run the command Install-PPApp "SharePoint Server 2013 Client Components SDK" to install this app.

Success Factors for a SharePoint Project

Wed, 19 Feb 2014 17:15:04 +0000

Right now I’ve led the company internal SharePoint projects for about one year.

I’ve experienced that most of the SharePoint project leaders struggle with same problems.

In order to save you from this unnecessary experience I’ve shared my most important success factors of a SharePoint project:

Install SharePoint 2013 Three-tier Farm - Deploy the SQL Server Backup Job

Fri, 07 Feb 2014 10:24:03 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

A clean SQL Server maintenance plan should include three processes, backup, integrity check and index optimize.

You could simply set up a SQL Server maintenance plan within the SQL Server management studio. But be aware that there are better solutions, E.g. Ola Hallengren’s SQL Server Maintenance Solution is my absolutely favourite.

Ola Hallengren is a Microsoft MVP who has simplified the installation of SQL Server maintenance plans. There are many other MVP’s who even recommend his solutions over the SQL Server management solution:

Brent Ozar

However the installation of the SQL ServerMaintenance Solution is very easy. A little bit more difficult is the scheduling, that’s why I create a clone repository for Ola’s SQL scripts and added and example of how to schedule these jobs.

You’ll find the repository on GitHub: https://codeberg.org/janikvonrotz/SQL-Server-Maintenance

Install SharePoint 2013 Three-tier Farm - Run the SharePoint 2013 Service Account Creator

Mon, 27 Jan 2014 13:24:53 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

As many other Windows services SharePoint and SQL Server requires different service accounts in order to run secure and reliable.

There are different concepts and strategies to create service accounts for a SharePoint installation. One of the most reliable solution I’ve found here.

In case the link is broken, these documents will do fine:

Each level of security contains a range of service accounts. Depending on you content and business requirements, you chose a suitable security level.

You can create those Service Accounts automatically with PowerShell using the SharePoint 2013 Service Account Creator project on CodePlex.

For this project I’ve chosen the highest security option including optional accounts.

https://technet.microsoft.com/en-us/library/cc263445.aspx

Install SharePoint 2013 Three-tier Farm - Designing the Logical Architecture

Mon, 27 Jan 2014 09:10:29 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

I assume that the reader of this tutorial has already defined the business requirements for this SharePoint installation.

The physical architecture depends on the requirements of the logical design. That’s why you have to define you logical architecture first.

The logical architectures unites the business requirements and the possibilities of SharePoint to set up multiple site collections with different urls, templates and databases.

The easiest way to write down these resources is a table or a note like this:

Intranet

Site collection: sharepont.domain.com Hostname: https://sharepoint.domain.com Site url: / Template: Blank Sites Database: SP_Content_Intranet

Site collection: sharepont.domain.com Hostname: https://sharepoint.domain.com Site url: /search Template: Enterprise Search Center

My Site

Site collection: mysite.domain.com Hostname: https://mysite.domain.com Site url: / Template: User Profile Database: SP_Content_MySite

IT Wiki

Site collection: sharepont.domain.com Hostname: https://sharepoint.domain.com Site url: /itwiki Template: Enterprise Wiki Database: SP_Content_ITWiki

Extranet VR

Site collection: extranetvr.domain.com Hostname: https://extranetvr.domain.com Site url: / Template: Blank Sites Database: SP_Content_ExtranetVR

Extranet VR - Search

Site collection: extranetvr.domain.com Hostname: https://extranetvr.domain.com Site url: /search Template: Enterprise Search Center

Export all Terms from Managed Metadata Service

Tue, 14 Jan 2014 16:18:44 +0000

Migrating you Managed Metadata Terms to another SharePoint installation? First thing to do: Export.

This scripts exports all terms sorted by term group, term set and its level.

Here’s a sample export:

And here’s the script:

<#
$Metadata = @{
	Title = "Export all Terms from Managed Metadata Service"
	Filename = "Export-ManagedMetadataServiceTerms.ps1"
	Description = ""
	Tags = "powershell, script, sharepoint, managed, metadata, terms, export"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2014-01-14"
	LastEditDate = "2014-01-14"
	Url = ""
	Version = "0.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit https://creativecommons.org/licenses/by-sa/3.0/ch/ or
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

if((Get-PSSnapin 'Microsoft.SharePoint.PowerShell' -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin 'Microsoft.SharePoint.PowerShell'}

function loop{

    param(

        $Object,
        $AttributeName,
        $Level = 0
    )

    # check the child attribute containing the same type of objects
    $Objects = iex "`$Object.$AttributeName"

    # output this item
    $Object | select @{L="Object";E={$_}}, @{L="Level";E={$Level}}

    # output the child items of this object
    if($Objects){

        # add level
        $Level ++

        # loop trough the same function
        $Objects | %{loop -Object $_ -AttributeName $AttributeName -Level $Level}
    }
}

# reset vars
$SPTaxonomies = @()

# get all taxonomy objects
$SPTaxonomies = Get-SPTaxonomySession -Site "https://itwiki.vbl.ch" | %{

    $_.TermStores | %{

        $TermStore = New-Object -TypeName Psobject -Property @{

            TermStore = $_.Name
            Group = ""
            TermSet = ""
            Terms = ""
        }

        $_.Groups | %{

            $Group = $TermStore.PSObject.Copy()
            $Group.Group = $_.Name

            $_.TermSets | %{

                $TermSet = $Group.PSObject.Copy()
                $TermSet.TermSet = $_.Name
                $TermSet.Terms = ($_.Terms | %{loop -Object $_ -AttributeName "Terms" -Level 1})

                $TermSet
            }
        }
    }
}

# get maximum of levels a term has
$Levels = ($SPTaxonomies | %{$_.Terms | %{$_.Level}} | measure -Maximum).Maximum + 1

# loop throught term stores
$SPTaxonomies | %{

    $SPTaxonomy = $_

    # loop throught terms
    $_.Terms | %{

        # create a term export object
        $Item = $SPTaxonomy.PSObject.Copy()
        $Index = 1;while($Index -ne $Levels){
            $Item | Add-Member –MemberType NoteProperty –Name "Term Level $Index" –Value $(if($_.Level -eq $Index){$_.Object.Name}else{""})
            $Index += 1
        }

        # output this object
        $Item |  Select-Object * -exclude Terms
    }
} | Out-GridView

Latest version of this script: https://gist.github.com/8419585

manage SharePoint list alerts for multiple users on multiple lists

Thu, 02 Jan 2014 14:38:25 +0000

In certain cases SharePoint alerts are more useful than workflows, f.e. having the possibility to let users manager their alerts is not possible with workflows.

To manager alerts for a couple of users on specific lists I’ve written a script that handles the whole cycle of alerts. It let me delete, update and create alerts based on predefined configuration.

<#
$Metadata = @{
	Title = "Update SharePoint User Alerts"
	Filename = "Update-SPUserAlerts.ps1"
	Description = ""
	Tags = "powershell, sharepoint, update, user, alerts"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2014-01-02"
	LastEditDate = "2014-01-02"
	Url = ""
	Version = "1.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ch/ or 
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

try{

    #--------------------------------------------------#
    # modules
    #--------------------------------------------------#
    if((Get-PSSnapin 'Microsoft.SharePoint.PowerShell' -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin 'Microsoft.SharePoint.PowerShell'}
    Import-Module ActiveDirectory
    
    #--------------------------------------------------#
    # settings
    #--------------------------------------------------#
    $Alerts = @(    
        @{    
            ID = 1
            ListUrl = "http://sharepoint.domain.ch/site/subsite/Lists/ListName/view.aspx"    
            SubscriberADUsersAndGroups = "ADGroup","ADUser"          
            Title = "`"Benachrichtigunggg `$Username`""
            AlertType = [Microsoft.SharePoint.SPAlertType]::List       
            DeliveryChannels = [Microsoft.SharePoint.SPAlertDeliveryChannels]::Email
            EventType = [Microsoft.SharePoint.SPEventType]::Add
            AlertFrequency = [Microsoft.SharePoint.SPAlertFrequency]::Immediate
            ListViewName = "View 2014"
            FilterIndex = 8
        }
    )
    
    #--------------------------------------------------#
    # function
    #--------------------------------------------------#
    function New-UnifiedAlertObject{
        
        param(
            $Title,
            $AlertType,
            $DeliveryChannels,
            $EventType,
            $AlertFrequency,
            $ListViewID,
            $FilterIndex
        )
        
        New-Object PSObject -Property @{
            Title = $Title
            AlertType = $AlertType
            DeliveryChannels = $DeliveryChannels
            EventType = $EventType
            AlertFrequency = $AlertFrequency
            ListViewID = $ListViewID
            AlertFilterIndex = $AlertFilterIndex
        }
    }

    #--------------------------------------------------#
    # main
    #--------------------------------------------------#
    
    $Alerts | %{
    
        # set vars
        $Message = "Update alerts with ID: $($_.ID)`n"
        $Alert = $_
    
        # get sp site
        $SPWeb = Get-SPWeb (Get-SPUrl $_.ListUrl).WebUrl

        # get name of the list
        $ListName = (Get-SPUrl $_.ListUrl).Url -replace ".*/",""

        # get the sp list object
        $SPList = $SPWeb.Lists[$ListName]
        
        $SPUsers = Get-SPUser -Web $SPWeb.Site.Url
        
        # get the id of the list view by name
        $SPListViewID = ($SPList.Views | where{$_.title -eq $SPListViewName -and $_.title -ne ""} | select -First 1).ID
        
        # get existing alerts
        $ExistingAlerts = $SPWeb.Alerts | where{$_.Properties["alertid"] -eq $Alert.ID}
        
        # cycle throught all users and  update, create or delete their alerts
        $UserWithAlerts = $_.SubscriberADUsersAndGroups | %{
        
            Get-ADObject -Filter {Name -eq $_} | %{
        
                if($_.ObjectClass -eq "user"){
                    
                    Get-ADUser $_.DistinguishedName
                    
                }elseif($_.ObjectClass -eq "group"){
                
                    Get-ADGroupMember $_.DistinguishedName -Recursive | Get-ADUser 
                }
            } | %{
                
                $ADUser = $_
            
                $SPUsers | where{$_.SID -eq $ADUser.SID} | %{$SPWeb.EnsureUser($_.Name)}
            }
        } | %{
        
            # create alert title
            $Username = $_.DisplayName
            $AlertTitle = Invoke-Command -ScriptBlock ([ScriptBlock]::Create($Alert.Title))
            
            # check if already alert exists with this id
            $AlertIS = $_.Alerts | where{$_.Properties["alertid"] -eq $Alert.ID} | select -First 1           
            
            # if exists update this alert
            if($AlertIS){
                
                # create alert objects to compare
                $AlertObjectIS = New-UnifiedAlertObject -Title $AlertIS.title `
                    -AlertType $AlertIS.AlertType `
                    -DeliveryChannels $AlertIS.DeliveryChannels `
                    -EventType $AlertIS.EventType `
                    -AlertFrequency $AlertIS.AlertFrequency `
                    -ListViewID $AlertIS.Properties["filterindex"] `
                    -FilterIndex $AlertIS.Properties["filterindex"]
                    
                $AlertObjectTo = New-UnifiedAlertObject -Title $AlertTitle `
                    -AlertType $Alert.AlertType `
                    -DeliveryChannels $Alert.DeliveryChannels `
                    -EventType $Alert.EventType `
                    -AlertFrequency $Alert.AlertFrequency `
                    -ListViewID $SPListViewID `
                    -FilterIndex $Alert.FilterIndex
                
                # only update changed attributes
                if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property Title, AlertType, DeliveryChannels, EventType, AlertFrequency, ListViewID, FilterIndex){
                    
                    $Message += "Update alert with ID: $($Alert.ID) for user: $($_.DisplayName)`n"
                    
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property Title){$AlertIS.Title = $AlertObjectTo.Title}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property AlertType){$AlertIS.AlertType = $AlertObjectTo.AlertType}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property DeliveryChannels){$AlertIS.DeliveryChannels = $AlertObjectTo.DeliveryChannels}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property EventType){$AlertIS.EventType = $AlertObjectTo.EventType}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property AlertFrequency){$AlertIS.AlertFrequency = $AlertObjectTo.AlertFrequency}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property ListViewID){$AlertIS.Properties["viewid"] = $AlertObjectTo.ListViewID}
                    if(Compare-Object -ReferenceObject $AlertObjectTo -DifferenceObject $AlertObjectIS -Property FilterIndex){$AlertIS.Properties["filterindex"] = $AlertObjectTo.FilterIndex}
                    
                    # update changes
                    $AlertIS.Update()
                }
            }else{
            
                # create a new alert object  
                $Message += "Create alert with ID: $($Alert.ID) for user: $($_.DisplayName)`n"          
                $NewAlert = $_.Alerts.Add()
                
                # add attributes
                $NewAlert.Properties.Add("alertid",$Alert.ID)
                $NewAlert.Title = $AlertTitle                  
                if($SPListViewID){                
                    $NewAlert.Properties.Add("filterindex",$Alert.FilterIndex)
                    $NewAlert.Properties.Add("viewid",$SPListViewID)              
                }
                $NewAlert.AlertType = $Alert.AlertType
                $NewAlert.List = $SPList
                $NewAlert.DeliveryChannels = $Alert.DeliveryChannels
                $NewAlert.EventType = $Alert.EventType
                $NewAlert.AlertFrequency = $Alert.AlertFrequency

                # create the alert
                $NewAlert.Update()
            }
            
            # pipe the users to check alerts to delete
            $_
            
        } 
        
        # username array
        $UserWithAlerts = $UserWithAlerts | %{"$($_.UserLogin)"}
        
        # delete alerts
        $ExistingAlerts | where{$UserWithAlerts -notcontains $_.User} | %{
        
            $Message += "Delete alert with ID: $($Alert.ID) for user: $($_.User)`n"
            $SPWeb.Alerts.Delete($_.ID)        
        }
        
        Write-PPEventLog -Message $Message -Source "Update SharePoint User Alerts" -WriteMessage
    }
}catch{

    Write-PPErrorEventLog -Source "Update SharePoint User Alerts" -ClearErrorVariable    
}

The configuration attribute ListViewName and FilterIndex allows me to change to create an alert for an specific view.

To use this script I’ll recommend you to install my project: PowerShell Profile. There are some function as f.e. Get-SPUrl which are not defined in this script but are part of this project.

You’ll find the latest version of this script here: https://gist.github.com/janikvonrotz/8218907

Do not forget to update to Microsoft Office 2013 when using Office 365 or SharePoint Online

Mon, 16 Dec 2013 18:07:01 +0000

When deploying a published SharePoint 2013 on-premise installation or a Office 365 installation or a SharePoint Online installation, it’s highly recommended to update your Microsoft Office 2013 installation.

There are some minor perks as these:

But the most important change you’ll find in the “Security changes” section.

Update SharePoint ActiveDirectory Group Displayname

Mon, 16 Dec 2013 17:00:39 +0000

When the name of an Active Directory group has been changed, this change won’t affect the display name showed in the SharePoint permission editor.

To update the the name for all Active Directory groups you can run this snippet on the SharePoint server:


if ((Get-PSSnapin 'Microsoft.SharePoint.PowerShell' -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin 'Microsoft.SharePoint.PowerShell'}

$SPSiteFilter = "https://sharepoint.domain.ch"

Get-SPSite | where{$SPSiteFilter -contains $_.Url} | %{

    $_.rootweb.siteusers | where{($_.DisplayName -ne $_.UserLogin) -and $_.IsDomainGroup} | %{

        Write-Host "Change: $($_.DisplayName) to: $($_.UserLogin)"

        $_.DisplayName = $_.UserLogin
        $_.Name = $_.UserLogin
        $_.Update()

    }
}

This snippet is part of my SharePoint default settings script: https://gist.github.com/7871902

Install SharePoint 2013 Three-tier Farm - Architecture and Licensing

Tue, 10 Dec 2013 12:35:07 +0000

This post of is part of my Install SharePoint 2013 Three-tier Farm project.

As the server architecture is already given in this case, I’m only going to show you the hardware requirements of those servers.

Each server installation provides:

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/ff512684(v=WS.10).aspx Server: Windows Server 2012 R2 Service: FIM 2010 R2, SQL Server 2010 R2 Name: w2k12fim1 CPU: 64-bit, 4cores RAM: 8 GB Disk: System 80 GB, Data 100 GB (dynamisch)

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/ff512684(v=WS.10).aspx Server: Windows Server 2012 R2 Service: FIM 2010 R2 Service Portal Name: w2k12fim2 CPU: 64-bit, 4 cores RAM: 4 GB Disk: System 80 GB

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/cc262485.aspx Server: Windows Server 2012 R2 Service: SQL Server 2010 R2 DNS (Alias): sp1sql Name: w2k12spsql1 CPU: 64-bit, 4 cores RAM: 12 GB Disk: System 80 GB, Data 100 GB (dynamic)

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/cc262485.aspx DNS: sp1app.vbl.ch Server: Windows Server 2012 R2 Service: SharePoint Server 2013 Name: w2k12spapp1 CPU: 64-bit, 4 cores RAM: 12 GB Disk: System 80 GB, Data 100 GB (dynamic)

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/cc262485.aspx Server: Windows Server 2012 R2 Service: SharePoint Server 2013 DNS: sharepoint.domain.ch, sp1web.domain.ch Name: w2k12spweb1 CPU: 64-bit, 4 cores RAM: 12GB Disk: System 80 GB, Data 100 GB (dynamic)

Hardware and Software Requirements: https://technet.microsoft.com/en-us/library/jj219435.aspx#software Server: Windows Server 2012 R2 Service: Office Web Apps Server 2013 Name: w2k12was1 DNS: was1.domain.ch CPU: 64-bit, 4 cores RAM: 12 GB Disk: System 80 GB, Data 50 GB (dynamic)

The installation and deployment of this servers won’t be part of this project.

sp1web.domain.ch CNAME w2k12spweb1.domain.ch sp1app.domain.ch CNAME w2k12spapp1.domain.ch was1.domain.ch CNAME w2k12was1.domain.ch

Install SharePoint 2013 Three-tier Farm

Tue, 10 Dec 2013 11:20:29 +0000

Based on new business requirements our intranet SharePoint needs an update from version 2010 to 2013. The new installation will be part in our existing Office 365 hybrid environment. As I’ve completed the Core Solutions of Microsoft SharePoint Server 2013 course I going to perform this project on my own. In this series of posts I would like to share my knowledge and experience in building this new intranet based on SharePoint 2013.

Add SharePoint List Print Button

Mon, 25 Nov 2013 09:32:03 +0000

You can print every SharePoint list item with the keyboard short cut Ctrl+P. But adding a real print button to the SharePoint list view isn’t that difficult too.

Choose the form type in you list options under form webparts.

Add a content editor webpart on top of the list view or right under the view.

Click to add new content.

Now edit the content as html source.

Add this snippet.

`
<input type="button" value=" Print " onclick="window.print();return false;" />
`

And you get a nice print button.

Assign Temporary Administrator Rights for ActiveDirectory Users via SharePoint list

Mon, 18 Nov 2013 16:55:32 +0000

In my company the user only have user rights on their computers. As you should know you’ll face many problems with this restriction.

Many users want to install third party software on their computers or add a printer at home. To reduce argues and make the user happy, I’ll assign administrator rights for a temporary time.

Based on a predefined GPO and based on a list showing which user has administrator rights in a specified time period, my PowerShell script creates new temporary GPO to assign local administrator rights.

After the specified time period the scripts deletes the temporary GPO in order to remove the local admin rights.

Here is the template of the predefined GPO:

User “test” is placeholder for the real user.

The list containing the users is stored on SharePoint site:

The scripts reads from the SharePoint list with predefined credentials and remote configuration file wich is part of my PowerShell Profile project (check out the requirements on the bottom).

Watch out to store the computer object in a OU instead of an container, it’s not possible to assign GPOs to an AD container!

<#
$Metadata = @{
	Title = "Assign Temporary Administrator Rights"
	Filename = "Assign-TemporaryAdministratorRights.ps1"
	Description = ""
	Tags = "powershell, script, activedirectory, assign, temporary, administrator, rights, computer"
	Project = ""
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2013-11-15"
	LastEditDate = "2013-11-18"
	Url = ""
	Version = "1.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit https://creativecommons.org/licenses/by-sa/3.0/ch/ or
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

try{
    #--------------------------------------------------#
    # modules
    #--------------------------------------------------#
    Import-Module ActiveDirectory
    Import-Module GroupPolicy

    #--------------------------------------------------#
    # settings
    #--------------------------------------------------#

    # var #Username# replaces username, var #Computername# replaces computername
    $GPOTemplate = "Windows User #Username# - #Computername# Lokaler Administrator"
    $TempFolder = "C:export"
    $SPWebUrl = (Get-SPUrl "https://sharepoint.vbl.ch/finanzen/it/Abteilungssite/SitePages/Homepage.aspx").Url
    $SPListName = "Temporäre Adminrechte"
    $RemoteConnectionKey = "sp1"

    #--------------------------------------------------#
    # main
    #--------------------------------------------------#

    $Computer = Get-RemoteConnection -Name $RemoteConnectionKey
    $Credential = Import-PSCredential -Path (Get-ChildItem $PSconfigs.Path -Filter "SharePoint.credential.config.xml" -Recurse).FullName
    $Session = New-PSSession -ComputerName $Computer.Name -Credential $Credential -ConfigurationName microsoft.powershell
    $Computer.SnapIns | %{ Invoke-Command -Session $Session -ScriptBlock {param ($Name) Add-PSSnapin -Name $Name} -ArgumentList $_}
    [ScriptBlock]$ScriptBlock = [scriptblock]::Create(@"
Get-SPWeb '$SPWebUrl' | %{
    `$_.Lists['$SPListName'].GetItems() | %{
        `$(New-Object PSObject -Property @{
            Mail = `$_["Title"].toString()
            Computer = `$_["Computer"].toString()
            From = `$_["From"].toString()
            To = `$_["To"].toString()
        })
    }
}
"@)
    $Config = Invoke-Command -Session $Session -ScriptBlock $ScriptBlock
    Remove-PSSession $Session

    <#
     $Config = @(
          $(New-Object PSObject -Property @{
              Mail = "name.surname@domain.ch"
              Computer = "tpbmar1"
              From = "18.11.2013"
              To = "25.11.2013"
          }),

          $(New-Object PSObject -Property @{
              Mail = "name.surname@vbl.ch"
              Computer = "tpfit9"
              From = "15.11.2013"
              To = "21.11.2013"
          }),
      )
    #>
    $Config | %{

        # get settings
        $ADComputer = Get-ADComputer $_.Computer
        $ADUser = Get-ADUser -Filter "mail -eq '$($_.Mail)'" | select -first 1
        $GPOName = ($GPOTemplate -replace "#Username#", $ADUser.Name -replace "#Computername#", $ADComputer.Name)
        $SourceGPO = Get-GPO $GPOTemplate
        $TargetOU = $ADComputer.DistinguishedName -replace "CN=$($ADComputer.Name),",""
        $FromDate = Get-Date $_.From
        $ToDate = Get-Date $_.To
        $Date = $(Get-Date)

        # create temp folder
        if(-not (Test-Path $TempFolder)){New-Item -Path $TempFolder -ItemType Directory}

        # get gpo
        $GPO = Get-GPO -Name $GPOName -ErrorAction SilentlyContinue

        # create if not exist
        if(-not $GPO -and $Date -gt $FromDate -and $Date -lt $ToDate){

            # create new gpo
            $GPO = New-GPO -Name $GPOName
            $GPO | New-GPLink -Target $TargetOU
            $GPO | Set-GPPermissions -Replace -PermissionLevel None -TargetName "Authentifizierte Benutzer" -TargetType Group
            $GPO | Set-GPPermissions -PermissionLevel GpoApply -TargetName $ADComputer.Name -TargetType Computer

            # backup template gpo
            $GPOBackup = $SourceGPO | Backup-GPO -Path $TempFolder
            $PathToXML = Join-Path $TempFolder ("{" + $GPOBackup.Id + "}DomainSysvolGPOMachinePreferencesGroupsGroups.xml")
            $PathToFolder = Join-Path $TempFolder ("{" + $GPOBackup.Id + "}")
            [xml]$GroupXML = Get-Content $PathToXML

            # update template gpo settings
            $GroupXML.Groups.Group.Properties.Members.Member.name = $(Get-ADDomain).NetBIOSName + "" +$ADUser.SamAccountName
            $GroupXML.Groups.Group.Properties.Members.Member.sid = "$($ADUser.SID)"
            $GroupXML.Save($PathToXML)

            # import to new gpo
            Import-GPO -BackupId $GPOBackup.Id -TargetGuid $GPO.Id -path $TempFolder

            # clean up tempfolder
            Remove-Item $PathToFolder -Force -confirm:$false -Recurse

            Write-PPEventLog -Message "Added temporary administrator rights for: $($_.Mail) on computer: $($_.Computer)" -Source "Assign Temporary Administrator Rights" -WriteMessage

        # delete gpo
        }elseif($GPO -and $Date -gt $ToDate ){

           $GPO | Remove-GPO
           Write-PPEventLog -Message "Removed temporary administrator rights for: $($_.Mail) on computer: $($_.Computer)" -Source "Assign Temporary Administrator Rights" -WriteMessage
        }
    }
}catch{

    Write-PPErrorEventLog -Source "Assign Temporary Administrator Rights"
}

Run this script as a hourly or daily scheduled task.

Latest version of this script: https://gist.github.com/7487228

Requirements to run this script:

E-Mail report of unchecked SharePoint files

Thu, 14 Nov 2013 16:05:42 +0000

Having unchecked files in the SharePoint is not a big deal as long as you aware of the those files.

Being unaware of which files are unchecked can really harm the information integrity of the SharePoint.

In one of my last posts I’ve reported the SharePoint storage space used by files and found about 1 GB of unchecked files by several people.

As they are in most cases unaware of those files or even don’t understand what the file check-in/check-out is about, it’s almost impossible to handle this files.

To handle this issue I’ve written this simple script that reports all unchecked files of a SharePoint installation, writes and sends a nice report by mail to the owner of those files.

Here’s a report example:

and here’s the script:


<#
$Metadata = @{
	Title = "Send Mail Report Of Unchecked SharePoint Files"
	Filename = "Send-MailReportOfUncheckedSharePointFiles.ps1"
	Description = ""
	Tags = ""
	Project = "powershell, script, sharepoint, report, unchecked, file"
	Author = "Janik von Rotz"
	AuthorContact = "https://janikvonrotz.ch"
	CreateDate = "2013-11-14"
	LastEditDate = "2013-11-14"
	Url = ""
	Version = "1.0.0"
	License = @'
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Switzerland License.
To view a copy of this license, visit https://creativecommons.org/licenses/by-sa/3.0/ch/ or
send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
'@
}
#>

#--------------------------------------------------#
# modules
#--------------------------------------------------#
Add-Type -AssemblyName System.Web
if ((Get-PSSnapin 'Microsoft.SharePoint.PowerShell' -ErrorAction SilentlyContinue) -eq $null){Add-PSSnapin 'Microsoft.SharePoint.PowerShell'}

#--------------------------------------------------#
# load config
#--------------------------------------------------#
$Mail = Get-PPConfiguration $PSconfigs.Mail.Filter | %{$_.Content.Mail | where{$_.Name -eq "Report Checked Out SharePoint Files"}} | select -first 1

#--------------------------------------------------#
# main
#--------------------------------------------------#
Get-SPWebApplication | Get-SPSite | Get-SPWeb -Limit All | %{
    $SPWeb = $_
    $_.lists | %{
        $_.CheckedOutFiles | %{
            $_ | select *, @{L="FileUrl";E={$SPWeb.Site.Url + "/" + $_.Url}}, @{L="SiteUrl";E={($SPWeb.Site.Url + "/" + $_.Url) -replace "[^/]+$",""}}
        }
    }
} | Group-Object CheckedOutByEmail | %{

    $Subject = "$($_.Count) nicht eingecheckte Dateien auf dem SharePoint"

    $Body = @"
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"  "https://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="https://www.w3.org/1999/xhtml"> <head> <style>
    body{
        font-size: 11pt;
        font-family: Calibri
    }
    table {
        margin: 1em;
        border-collapse: collapse;
    }
    td, th {
        margin: 0.3em;
        border: 1px #ccc solid;
    }
</style></head><body>

    <p>Guten Tag $($_.Group[0].CheckedOutByName)</p>

    <p>Sie erhalten diese E-Mail, weil Sie im Besitz von nicht eingecheckten Dateien sind,</br>
    welche als letztes vor einer Woche oder fürher bearbeitet worden sind.</p>

    <p>Wir bitten Sie diese Dateien einzuchecken oder zu löschen.</p>

    <p>Untersützung zu diesem Thema erhalten Sie <a href="https://office.microsoft.com/de-ch/sharepoint-workspace-help/auschecken-und-einchecken-von-dokumenten-in-ein-dateitool-HA010356922.aspx">hier</a>.</p>

    <h2>Übersicht ihrer nicht eingecheckten Dateien</h2>

    $($_.group | select @{L="Name";E={$_.LeafName}}, @{L="FileUrl";E={"<a href='$($_.FileUrl)'>$($_.FileUrl)</a>"}}, @{L="SiteUrl";E={"<a href='$($_.SiteUrl)'>$($_.SiteUrl)</a>"}}, TimeLastModified, @{L="Size";E={Format-FileSize $_.Length}} | where{$_.TimeLastModified -lt $(Get-Date).AddDays(-7)} | ConvertTo-Html -Fragment)

    <p>ACHTUNG! Dieses E-Mail wurde von einem unbeaufsichtigtem Konto verschickt, Antworten an den Sender dieser E-Mail werden nicht bearbeitet.</p>

</body></html>
"@

    Write-PPEventLog -Message "Send Mail to: $($_.Name) with subject: $Subject" -Source "Send Mail Report Of Unchecked SharePoint Files" -WriteMessage
    Send-MailMessage -To $_.Name -From $Mail.FromAddress -Subject $Subject -Body ([System.Web.HttpUtility]::HtmlDecode($Body)) -SmtpServer $Mail.OutSmtpServer -BodyAsHtml -Priority High -Encoding ([System.Text.Encoding]::UTF8)
    Write-PPErrorEventLog -ScriptPath $MyInvocation.InvocationName -ClearErrorVariable
}

Latest version of this script: https://gist.github.com/7467398

Requirements to run this script:

SharePoint File Reporting Done Right

Thu, 10 Oct 2013 16:33:01 +0000

To know what type of information a SharePoint Installation is holding could get more difficult as the platform grows.

To set quota templates on the site collection is a good way to keep an eye on the SharePoint storage, but it doesn’t’ show the real used storage.

In case versioning for files is enabled and/or the users don’t check in their files properly these files using space without let you know.

To get a nice report of unchecked, versioned and “normal” files I’ve coded a PowerShell script.

Most of the functions are part of my Project: PowerShell Profile, so this will be a requirement to run this script.

$SPWebs = Get-SPWebs
$SPWebs | %{

    $SPWeb = $_

    $SPSite = $_.site.url

    Get-SPLists -Url $_.Url -OnlyDocumentLibraries | %{

        $SPList = $_

        $SPListUrl = (Get-SPUrl $SPList).url

        Write-Progress -Activity &quot;Crawl list on website&quot; -status &quot;$($SPWeb.Title): $($SPList.Title)&quot; -percentComplete ([Int32](([Array]::IndexOf($SPWebs, $SPWeb)/($SPWebs.count))*100))

        Get-SPListItems $_.ParentWeb.Url -FilterListName $_.title | %{

            $ItemUrl = (Get-SPUrl $_).Url

            # files
            New-Object PSObject -Property @{
                ParentWebsite = $SPWeb.ParentWeb.title
                ParentWebsiteUrl = $SPWeb.ParentWeb.Url
                Website = $SPWeb.title
                WebsiteUrl = $SPWeb.Url
                List = $SPList.title
                ListUrl = $SPListUrl
                FileExtension = [System.IO.Path]::GetExtension($_.Url)
                IsCheckedOut = $false
                IsASubversion = $false
                Item = $_.Name
                ItemUrl = $ItemUrl
                Folder = $ItemUrl -replace &quot;[^/]+$&quot;,&quot;&quot;
                FileSize = $_.file.Length / 1000000
            }

            $SPItem = $_

            # file subversions
            $_.file.versions | %{

                $ItemUrl = (Get-SPUrl $SPItem).Url

                New-Object PSObject -Property @{
                    ParentWebsite = $SPWeb.ParentWeb.title
                    ParentWebsiteUrl = $SPWeb.ParentWeb.Url
                    Website = $SPWeb.title
                    WebsiteUrl = $SPWeb.Url
                    List = $SPList.title
                    ListUrl = $SPListUrl
                    FileExtension = [System.IO.Path]::GetExtension($_.Url)
                    IsCheckedOut = $false
                    IsASubversion = $true
                    Item = $SPItem.Name
                    ItemUrl = $ItemUrl
                    Folder = $ItemUrl -replace &quot;[^/]+$&quot;,&quot;&quot;
                    FileSize = $_.Size / 1000000
                }
            }
        }

        # checked out files
        Get-SPListItems $_.ParentWeb.Url -FilterListName $_.title -OnlyCheckedOutFiles | %{

            $ItemUrl = $SPSite + &quot;/&quot; + $_.Url

            New-Object PSObject -Property @{
                ParentWebsite = $SPWeb.ParentWeb.title
                ParentWebsiteUrl = $SPWeb.ParentWeb.Url
                Website = $SPWeb.title
                WebsiteUrl = $SPWeb.Url
                List = $SPList.title
                ListUrl = $SPListUrl
                FileExtension = [System.IO.Path]::GetExtension($_.Url)
                IsCheckedOut = $true
                IsASubversion = $false
                Item = $_.LeafName
                ItemUrl = $ItemUrl
                Folder = $ItemUrl -replace &quot;[^/]+$&quot;,&quot;&quot;
                FileSize = $_.Length / 1000000
            }

        }
    }
} | Export-Csv &quot;Report SharePoint Files.csv&quot; -Delimiter &quot;;&quot; -Encoding &quot;UTF8&quot; -NoTypeInformation

Most recent version of this snippet is avialable here: https://gist.github.com/janikvonrotz/6885934

Update: This script is now part of my PowerShell Profile project as a function: https://codeberg.org/janikvonrotz/Powershell-Profile/blob/master/functions/SharePoint/List/Get-SPListFiles.ps1

Find dead SharePoint ActiveDirectory Groups

Wed, 25 Sep 2013 15:33:07 +0000

The are three ways to handle access rights in SharePoint.

I personally recommend to use the first suggestion. Managing the access rights in one system is much easier to administrate, no switching or log off for administration work.

In our SharePoint installation I create for each securable resource and rights type a ActiveDirectory group and assign them organization groups.

A huge disadvantage of this strategy is that after a period of adding ActiveDirectory groups it’s hard to know which of those groups are really required.

I could handle this issue with a simple script which compares all SharePoint ActiveDirectory groups and the All ActiveDirectory groups from a specific OU against.

Import-Module ActiveDirectory

$Domain = "$((Get-ADDomain).Name)"

$ADGroups = Get-ADGroup -Filter "*" -SearchBase "OU=SharePoint,OU=Services,OU=vblusers2,DC=vbl,DC=ch"

$SPGroups = (
    Get-SPWebs | %{
        if($_.HasUniqueRoleAssignments){
            $Url = $_.Url
            $_.RoleAssignments | Where{$_.Member.IsDomainGroup} | %{ $_ | Select-Object @{Name = "Member"; Expression = {$_.member -replace ($Domain + "\"),""}}, @{Name = "Url"; Expression = {$Url}},@{Name = "Type"; Expression = {"Website"}}}
        }
    }
    )+(

    Get-SPLists | %{
        if($_.HasUniqueRoleAssignments){
            $Url = ([uri]$_.Parentweb.Url).Scheme + "://" + ([uri]$_.Parentweb.Url).host + $_.DefaultViewUrl
            $_.RoleAssignments | Where{$_.Member.IsDomainGroup} | %{ $_ | Select-Object @{Name = "Member"; Expression = {$_.member -replace ($Domain + "\"),""}}, @{Name = "Url"; Expression = {$Url}},@{Name = "Type"; Expression = {"List"}}}
        }
    }
)

$ADGroups | where{ -not (($SPGroups | select Member) -match $_.Name)} | select name

https://gist.github.com/6699783

Add View Folder link to search results page in SharePoint

Mon, 23 Sep 2013 11:19:09 +0000

In the default document search results in the SharePoint search center it is only possible to open the documents. It is not possible to navigate to the documents location.

in the results.aspx file (accessible with the SharePoint designer) make a replacement as showed:

https://gist.github.com/janikvonrotz/6668613

SharePoint 2010 Manage Content And Structure Is Missing

Wed, 04 Sep 2013 15:31:07 +0000

Content and structure option was present in SharePoint Server 2007, if you are not able to see this option on your SharePoint site in SharePoint 2010 then don’t be surprised, this option still exist in this version as a feature.

There are two sections on which you can see this option, if you are missing this option then lets analyze which sections we are talking about.

Not able to see ‘content and structure’ option on site actions page

Please follow the below mentioned steps to get this option on site settings page

Not able to see ‘Manage content and structure’ option in site actions

Open the SharePoint site on which you are working

Managed Metadata in SharePoint 2013/Office365

Wed, 04 Sep 2013 09:33:48 +0000

The Managed Metadata feature in SharePoint 2010/2013/Office365 enables a new way to manage your documents and other company related informations.

Yet most file systems store their files in an hierarchical structure, with SharePoint and the Managed Metadata Service you can setup a document management system.

To get into this Managed Metadata Service thing, I’ve found a great video.

Office365 SharePoint Backup und Restore Facts by IOZ AG

Mon, 12 Aug 2013 13:33:30 +0000

In diesem Blogbeitrag schildern wir Ihnen die Fakten der Datensicherung Ihrer SharePoint Online Plattform:

SiteCollection

Papierkorb

via IOZ AG Blog.

SharePoint 2013 unable to unlock site collection

Tue, 09 Jul 2013 10:22:01 +0000

In case you manage your SharePoint installation with PowerShell and your backup script failed, you might experience that the site collection is locked for any kind of access. That’s because SharePoint locks the site collection for backups until the backup process has finished.

And in another case like mine, it could happen that you’re unable to unlock the workspace, despite your logged in as administrator.

Additional to the lock state in SharePoint 2013 there’s a feature to enter the site collection in a “Maintenance Mode”. This maintenance mode will lock even the administration access to the site collection.

So how can I unlock or remove the maintenance mode? It’s easy just run this PowerShell script from your SharePoint/PowerShell CLI to remove the maintenance mode:

$SPSiteAdministration =  new-object Microsoft.SharePoint.Administration.SPSiteAdministration('https://sharepoint.url.local')
$SPSiteAdministration.ClearMaintenanceMode()