Today i’m going to show you how to script Sharepoint through the GUI. Whilst in this example we’ll be running the code on server the same concepts and approach can be used to Script it from any machine that can hit the relevant website…
Our example might seem to be a little forced but it’s based on a real world experience. We had a client who had a fairly complicated Content Type scenario, over 150 Content Types spread over 8 levels of inheritance with untold columns. Then we discovered an issue and needed to publish every single one of those content types. This is the classic example of where PowerShell should be used but awkwardly they’d been burnt with PowerShell publishing before.
As such we had a flat edict, no PowerShell publishing of content types. It must go through the GUI.
A post i’d seen recently by Dr James McCaffrey popped into my head. It was about using PowerShell to automate testing of web applications using PowerShell.
Why not use the same process to automate the publishing of the content types?
The first thing to do is to get ourselves an IE window:
$ie = New-Object -com "Internet Explorer" #This starts by default in a hidden mode so let's show it $ie.Visible = $true
This isn’t much use on its’ own so let’s send it to a page. In our case we want to go to the page to publish one of our content types. We know that the publish page itself is an application page that is referenced from a site collection root web with the following URL syntax:
siteCollectionRoot/_layouts/managectpublishing.aspx?ctype=ContentTypeID
Glossing over how to get the ContentTypeID for now we have this:
$pageUrl= "http://sharepoint/sites/cthub/_layouts/managectpublishing.aspx?ctype=0x0100A4CF347707AC054EA9C3735EBDAC1A7C" $ie.Naviagte($pageUrl)
Now PowerShell moves fast, so we’ll need to wait for Javascript to catch up.
While ($ie.ReadyState -ne 4)
{
Sleep -Milliseconds 100
}
Now we’re there, let’s get the publish button. Thankfully this button has a consistent ID that we can get using the trusty F12 button in IE.
Identifying an element’s ID uwing F12
The catchily titled “ctl00_PlaceHolderMain_ctl00_RptControls_okButton” button? Depressingly i think i’m starting to see the naming convention behind these ids…
$textBoxID = "ctl00_PlaceHolderMain_ctl00_RptControls_okButton"; #You have to pass the Document into it's own object otherwise it will fail $document = $ie.Document $button= $document.getElementByID($buttonID)
And now all we need to do is to click that button:
$button.Click()
Now you might think that we’ve done all we need to do here and slap it into a foreach loop and be done with it. Of course you can’t do that as you need to give IE time to send that request using our good old friend Javascript.
So we wait for the page to re-direct us:
While ($ie.locationurl -eq $url)
{
start-sleep -Milliseconds 100
}
Now we can slap it into a foreach loop and with a little bit of work we can come up with something like the code below:
Add-PSSnapin Microsoft.SharePoint.PowerShell -ea SilentlyContinue
#URL for the content type hub to use
$CTHubURL= "https://sharepoint/sites/cthub"
#Get the Content Type hub
$site = Get-SPSite $CTHubURL
#Content Types to publish
$ContentAndColumns = @(
("Document Type 1"),
("Document Type 2"),
("Document Type 3")
)
#Open a new IE window
$ie = New-Object -com "InternetExplorer.Application"
#Make the window visible
$ie.visible = $true
#Loop through the content types and publish them
foreach ($contentTypeName in $ContentTypes)
{
Write-Verbose "Processing $ContentTypeName"
#Content types live at the root web
$web = $site.rootWeb
#Get the content type using it's name
$ct = $web.ContentTypes[$ContentTypeName]
#Get the GUID for the CT
$GUID = $ct.ID.ToString()
#Get the URL for the page based on the content type hub url, the application page that does publishing and the GUID
$url = $CTHubURL+ "/_layouts/managectpublishing.aspx?ctype=" + $GUID
#Go to the page
$ie.navigate($url)
#Wait for the page to finish loading
while ($ie.ReadyState -ne 4)
{
start-sleep -Milliseconds 100
}
#The ID of the button to press
$buttonID = "ctl00_PlaceHolderMain_ctl00_RptControls_okButton"
$document = $ie.Document
$btn = $document.getElementByID($buttonID)
#Push the button
$btn.click()
#Wait for the page to be re-directed
while ($ie.locationurl -eq $url)
{
start-sleep -Milliseconds 100
}
Write-Verbose "Content Type $contentTypeName published"
}
I don’t know about you but there is something deeply neat about sitting at your desk watching IE do the dull task that you were convinced was going to bring your RSI back with a vengance, and in half the time you could do it.
This example might not be useful for that many people but the concept is intriguing. There’s no reason most of this can’t be done without any code on the server at all, the only time we use it is to get the GUIDs and those can be pre-fetched if needs be. Nor does it need any significant rights, as long as the account you use has permision to get into that site collection and publish content types then that’s all they need.
The logical destination of this is Office 365, the scripts and rules for running them on there are limited and limiting, they have to be. But the beauty of Scripting is that we don’t have to be limited by the detail of code, we can use higher level components and tools to worry about that for us. In this case, the GUI that microsoft were kind enough to provide us for when it’s too awkward to find the PowerShell console.