Microsoft SharePoint : Creating Various Content Types

Exclusive offer: get 50% off this eBook here
Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook

Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook — Save 50%

50 advanced recipes for administrators and IT Pros to master Microsoft SharePoint 2010 and Microsoft PowerShell 2.0 automation with this book and eBook

$23.99    $12.00
by Yaroslav Pentsarskyy | December 2011 | Microsoft

PowerShell is tightly integrated with SharePoint 2010, demonstrating an important alliance between the fastest growing collaboration and web publishing platform, and the latest task automation framework. The advantages of PowerShell and SharePoint integration help administrators and infrastructure specialists achieve everyday enterprise tasks more efficiently.

In this article by Yaroslav Pentsarskyy, author of Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook, we will cover the following topics:

  • Creating basic and complex content types
  • Creating and configuring document sets
  • Creating and editing publishing pages with PowerShell

(For more resources on Microsoft SharePoint, see here.)

SharePoint content types are used to make it simpler for site managers to standardize what content and associated metadata gets uploaded to lists and libraries on the site. In this article, we'll take a look at how you can create various content types and assign them to be used in site containers.

As a subset of more complex content types, a document set will allow your users to store related items in libraries as a set of documents sharing common metadata. This approach will allow your users to run business processes on a batch of items in the document set as well as the whole set. In this article, we'll take a look at how you can define a document set to be used on your site.

Since users mostly interact with your SharePoint site through pages and views, the ability to modify SharePoint pages to accommodate business user requirements becomes an important part of site management. In this article, we'll take a look at how you can create and modify pages and content related to them. We will also take a look at how you can provision simple out-of-the-box web parts to your SharePoint publishing pages and configure their properties.

Creating basic and complex content types

SharePoint lists and libraries can store a variety of content on the site. SharePoint also has a user interface to customize what information you can collect from users to be attached as an item metadata.

In the scenario where the entire intranet or the department site within your organization requires a standard set of metadata to be collected with list and library items, content types are the easiest approach to implement the requirement.

With content types, you can define the type of business content your users will be interacting with. Once defined, you can also add a metadata field and any applicable validation to them. Once defined, you can attach the newly created content type to the library or list of your choice so that newly uploaded or modified content can conform to the rules you defined on the site.

Getting ready

Considering you have already set up your virtual development environment, we'll get right into authoring our script.

It's assumed you are familiar with how to interact with SharePoint lists and libraries using PowerShell.

In this recipe, we'll be using PowerGUI to author the script, which means you will be required to be logged in with an administrator's role on the target Virtual Machine.

How to do it...

Let's take a look at how we can provision site content types using PowerShell as follows:

  1. Click Start | All Programs | PowerGUI | PowerGUI Script Editor.
  2. In the main script editing window of PowerGUI, add the following script:

    # Defining script variables
    $SiteUrl = "http://intranet.contoso.com"
    $ListName = "Shared Documents"
    # Loading Microsoft.SharePoint.PowerShell
    $snapin = Get-PSSnapin | Where-Object {$_.Name -eq 'Microsoft.
    SharePoint.Powershell'}
    if ($snapin -eq $null) {
    Write-Host "Loading SharePoint Powershell Snapin"
    Add-PSSnapin "Microsoft.SharePoint.Powershell"
    }
    $SPSite = Get-SPSite | Where-Object {$_.Url -eq $SiteUrl}
    if($SPSite -ne $null)
    {
    Write-Host "Connecting to the site" $SiteUrl ",list "
    $ListName
    $RootWeb = $SPSite.RootWeb
    $SPList = $RootWeb.Lists[$ListName]
    Write-Host "Creating new content type from base type"
    $DocumentContentType = $RootWeb.AvailableContentTypes["Document"
    ]
    $ContentType = New-Object Microsoft.SharePoint.SPContentType -
    ArgumentList @($DocumentContentType, $RootWeb.ContentTypes, "Org
    Document")

    Write-Host "Adding content type to site"
    $ct = $RootWeb.ContentTypes.Add($ContentType)

    Write-Host "Creating new fields"
    $OrgDocumentContentType = $RootWeb.ContentTypes[$ContentType.Id]
    $OrgFields = $RootWeb.Fields
    $choices = New-Object System.Collections.Specialized.
    StringCollection
    $choices.Add("East")
    $choices.Add("West")
    $OrgDivision = $OrgFields.Add("Division", [Microsoft.SharePoint.
    SPFieldType]::Choice, $false, $false, $choices)
    $OrgBranch = $OrgFields.Add("Branch", [Microsoft.SharePoint.
    SPFieldType]::Text, $false)
    Write-Host "Adding fields to content type"
    $OrgDivisionObject = $OrgFields.GetField($OrgDivision)
    $OrgBranchObject = $OrgFields.GetField($OrgBranch)
    $OrgDocumentContentType.FieldLinks.Add($OrgDivisionObject)
    $OrgDocumentContentType.FieldLinks.Add($OrgBranchObject)
    $OrgDocumentContentType.Update()
    Write-Host "Associating content type to list" $ListName
    $association = $SPList.ContentTypes.Add($OrgDocumentContentType)
    $SPList.ContentTypesEnabled = $true
    $SPList.Update()
    Write-Host "Content type provisioning complete"
    }
    $SPSite.Dispose()

  3. Click File | Save to save the script to your development machine's desktop. Set the filename of the script to CreateAssociateContentType.ps1.
  4. Open the PowerShell console window and call CreateAssociateContentType. ps1 using the following command:

    PS C:\Users\Administrator\Desktop> .\ CreateAssociateContentType.ps1

  5. As a result, your PowerShell script will create a site structure as shown in the following screenshot:

  6. Now, from your browser, let's switch to our SharePoint Intranet:
    http://intranet.contoso.com.
  7. From the home page's Quick launch, click the Shared Documents link.
  8. On the ribbon, click the Library tab and select Settings | Library Settings.
  9. Take note of the newly associated content type added to the Content Types area of the library settings, as shown in the following screenshot:

  10. Navigate back to the Shared Documents library from the Quick launch menu on your site and select any of the existing documents in the library.
  11. From the ribbons Documents tab, click Manage | Edit Properties.
  12. Take note of how the item now has the Content Type option available, where you can pick newly provisioned Org Document content type.
  13. Pick the Org Document content type and take note of the associated metadata showing up for the new content type, as shown in the following screenshot:

How it works...

First, we defined the script variables. In this recipe, the variables include a URL of the site where the content types are provisioned, http://intranet.contoso.com, and a document library to which the content type is associated:

$ListName = "Shared Documents"

Once a PowerShell snap-in has been loaded, we get a hold of the instance of the current site and its root web. Since we want our content type to inherit from the parent rather than just being defined from the scratch, we get a hold of the existing parent content type first, using the following command:

$DocumentContentType = $RootWeb.AvailableContentTypes["Document"]

Next, we created an instance of a new content type inheriting from our parent content type and provisioned it to the root site using the following command:

$ContentType = New-Object Microsoft.SharePoint.SPContentType -
ArgumentList @($DocumentContentType, $RootWeb.ContentTypes, "Org Document")

Here, the new object takes the following parameters: the content type representing a parent, a web to which the new content type will be provisioned to, and the display name for the content type.

Once our content type object has been created, we add it to the list of existing content types on the site:

$ct = $RootWeb.ContentTypes.Add($ContentType)

Since most content types are unique by the fields they are using, we will add some business- specific fields to our content type. First, we get a hold of the collection of all of the available fields on the site:

$OrgFields = $RootWeb.Fields

Next, we create a string collection to hold the values for the choice field we are going to add to our content type:

$choices = New-Object System.Collections.Specialized.StringCollection

The field with list of choices was called Division, representing a company division. We provision the field to the site using the following command:

$OrgDivision = $OrgFields.Add("Division", [Microsoft.SharePoint.SPFieldType]::Choice, $false, $false, $choices)

In the preceding command, the first parameter is the name of the field, followed by the type of the field, which in our case is choice field. We then specify whether the field will be a required field, followed by a parameter indicating whether the field name will be truncated to eight characters. The last parameter specifies the list of choices for the choice field.

Another field we add, representing a company branch, is simpler since it's a text field. We define the text field using the following command:

$OrgBranch = $OrgFields.Add("Branch", [Microsoft.SharePoint.SPFieldType]::Text, $false)

We add both fields to the content type using the following commands:

$OrgDocumentContentType.FieldLinks.Add($OrgDivisionObject)
$OrgDocumentContentType.FieldLinks.Add($OrgBranchObject)

The last part is to associate the newly created content type to a library, in our case Shared Documents. We use the following command to associate the content type to the library:

$association = $SPList.ContentTypes.Add($OrgDocumentContentType)

To ensure the content types on the list are enabled, we set the ContentTypesEnabled property of the list to $true.

 

Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook 50 advanced recipes for administrators and IT Pros to master Microsoft SharePoint 2010 and Microsoft PowerShell 2.0 automation with this book and eBook
Published: November 2011
eBook Price: $23.99
Book Price: $39.99
See more
Select your format and quantity:

(For more resources on Microsoft SharePoint, see here.)

Creating and configuring document sets

SharePoint document set is the new feature allowing users to group documents within their libraries in order to share common metadata value between the set of document. As an added benefit, with document sets, your users will be able to run out-of-the- box and custom workflows on the entire set and individual documents within a set.

The document set functionality in SharePoint is achieved using a concept of content types where you define your custom document set template in a form of the content type. Once your content type is defined, you can bind it to a set of desired libraries and let users work with the set.

Since document set configuration requires quite a few steps to make it available on the site, we can use PowerShell to script those configuration steps to help us quickly provision document sets to multiple environments. In the scenario where you have several document sets to be created and deployed, PowerShell will make it easier to get your site set up without incurring a significant downtime.

Getting ready

Considering you have already set up your virtual development environment , we'll get right into authoring our script.

We'll assume you are also familiar with the concept of content types and how you can use PowerShell to provision content types to your site as described in the previous recipe.

In this recipe, we'll be using PowerGUI to author the script, which means you will be required to be logged in with an administrator's role on the target Virtual Machine.

How to do it...

Let's see what's involved in creating documents sets with PowerShell:

  1. Click Start | All Programs | PowerGUI | PowerGUI Script Editor.
  2. In the main script editing window of PowerGUI, add the following script:

    # Defining script variables
    $SiteUrl = "http://intranet.contoso.com"
    $ListName = "Shared Documents"
    # Loading Microsoft.SharePoint.PowerShell
    $snapin = Get-PSSnapin | Where-Object {$_.Name -eq 'Microsoft.
    SharePoint.Powershell'}
    if ($snapin -eq $null) {
    Write-Host "Loading SharePoint Powershell Snapin"
    Add-PSSnapin "Microsoft.SharePoint.Powershell"
    }
    Write-Host "Load document management library"
    [System.Reflection.Assembly]::LoadWithPartialName("Microsoft.
    Office.DocumentManagement")
    $SPSite = Get-SPSite | Where-Object {$_.Url -eq $SiteUrl}
    if($SPSite -ne $null)
    {
    Write-Host "Connecting to the site" $SiteUrl ",list "
    $ListName
    $RootWeb = $SPSite.RootWeb
    $SPList = $RootWeb.Lists[$ListName]
    Write-Host "Creating new document set content type"
    $DocumentSetContentType = $RootWeb.AvailableContentTypes
    ["Document Set"]
    $ContentType = New-Object Microsoft.SharePoint.SPContentType
    -ArgumentList @($DocumentSetContentType, $RootWeb.ContentTypes,
    "Org Document Set")

    Write-Host "Adding content type to site"
    $ct = $RootWeb.ContentTypes.Add($ContentType)

    Write-Host "Configuring document set properties"
    $OrgDocumentSetContentType = $RootWeb.ContentTypes[$ContentType.
    Id]
    $OrgFields = $RootWeb.Fields
    $choices = New-Object System.Collections.Specialized.
    StringCollection
    $choices.Add("East")
    $choices.Add("West")
    $OrgDivision = $OrgFields.Add("Division", [Microsoft.SharePoint.
    SPFieldType]::Choice, $false, $false, $choices)
    $OrgBranch = $OrgFields.Add("Branch", [Microsoft.SharePoint.
    SPFieldType]::Text, $false)

    Write-Host "Adding fields to content type"
    $OrgDivisionObject = $OrgFields.GetField($OrgDivision)
    $OrgBranchObject = $OrgFields.GetField($OrgBranch)

    $OrgDocumentSetContentType.FieldLinks.Add($OrgDivisionObject)
    $OrgDocumentSetContentType.FieldLinks.Add($OrgBranchObject)
    $OrgDocumentSetContentType.Update()

    Write-Host "Associating document set content type to list"
    $ListName
    $association = $SPList.ContentTypes.
    Add($OrgDocumentSetContentType)
    $SPList.ContentTypesEnabled = $true
    $SPList.Update()

    Write-Host "Document set configuration complete"
    }
    $SPSite.Dispose()

  3. Click File | Save to save the script to your development machine's desktop. Set the filename of the script to CreateDocumentSet.ps1.
  4. Open the PowerShell console window and call CreateDocumentSet.ps1 using the following command:

    PS C:\Users\Administrator\Desktop> .\ CreateDocumentSet.ps1

  5. As a result, your PowerShell script will create a list with results as shown in the following screenshot

  6. Now, from your browser, let's switch to our SharePoint Intranet site: http://intranet. contoso.com/.
  7. Click Site Actions | Site Settings.
  8. Under Galleries, select Site content types.
  9. Locate and click the Org Document Set link.
  10. On the document sets settings page click Configure Document Set.
  11. Under the Welcome Page Columns group, under the Available columns section, select both Branch and Division columns and choose Add to add them to the list of columns visible on the document set home page, as shown in the following screenshot:

  12. Click OK to save changes.
  13. Click the Shared Documents library link from the Quick launch menu on your site.
  14. From the ribbon, click the Documents tab, then click the New Document | Org Document Set, as shown in the following screenshot:

  15. Provide the Title and other required metadata for the document set and click OK to create a new document set.
  16. In the Shared Documents library, locate the newly created document set and open it. Take note of the entered metadata and other document set property values available on the home page of the set, as shown in the following screenshot:

How it works...

Document sets represent complex content types, so their provisioning is similar to provisioning a content type.

We start by defining our script variables: a URL of the site where the document set is to be provisioned, http://intranet.contoso.com, and a document library to which the document set will be associated:

$ListName = "Shared Documents"

Once a PowerShell snap-in has been loaded, we get a hold of the instance of the current site and its root web. Our document set will inherit from SharePoint 2010 the base document set content type. First, we get a hold of the existing parent document set content type, using the following command:

$DocumentSetContentType = $RootWeb.AvailableContentTypes["Document Set"]

Next, we create an instance of a new document set content type inheriting from our parent using the following command:

$ContentType = New-Object Microsoft.SharePoint.SPContentType -
ArgumentList @($DocumentSetContentType, $RootWeb.ContentTypes, "Org Document Set")

Our new document set object takes the following parameters: parent document set content type, a web which will hold newly provisioned document set definition, and the display name of the document set.

Once our document set content type object has been created, we add it to the site:

$ct = $RootWeb.ContentTypes.Add($ContentType)

Just as in the previous recipe, we create the same set of fields which are used in our document set content type. In this case, the fields are going to be a company division and the branch.

We add both fields to the content type using the following commands:

$OrgDocumentSetContentType.FieldLinks.Add($OrgDivisionObject)
$OrgDocumentSetContentType.FieldLinks.Add($OrgBranchObject)
$OrgDocumentSetContentType.Update()

The last part is to associate the newly created content type to a Shared Documents library. We use the following command to associate our new document set content type to the library:

$association = $SPList.ContentTypes.Add($OrgDocumentSetContentType)

Lastly, we enable the content types on the library if they haven't already been enabled by setting the ContentTypesEnabled property of the library to $true.

 

Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook 50 advanced recipes for administrators and IT Pros to master Microsoft SharePoint 2010 and Microsoft PowerShell 2.0 automation with this book and eBook
Published: November 2011
eBook Price: $23.99
Book Price: $39.99
See more
Select your format and quantity:

(For more resources on Microsoft SharePoint, see here.)

Creating and editing publishing pages with PowerShell

Just about any SharePoint intranet and extranet site consists of a series of collaboration and publishing pages which your users interact with the site.

When it comes to maintaining content on the site, your organization may want to bulk change the content throughout the site, or migrate existing content to be hosted within SharePoint. As an example, you may be asked to pre-create a few hundred news article pages where your users can populate the content for them before the news release section of the site launches.

Whether you have been tasked with this assignment on an existing intranet or the new site, you can be sure that using PowerShell will minimize the impact on the environment downtime and you will have a reusable script to perform the deployment to multiple environments.

In this recipe, we will see how you can create a new SharePoint publishing page and edit its properties. We'll also take a look at how you can automatically approve the page and make it available for others to see.

Getting ready

Considering you have already set up your virtual development environment, we'll get right into authoring our script.

In this recipe, we'll be using PowerGUI to author the script, which means you will be required to be logged in with an administrator's role on the target Virtual Machine.

How to do it...

We'll take a look at how you can create publishing pages using PowerShell.

  1. Click Start | All Programs | PowerGUI | PowerGUI Script Editor.
  2. In the main script editing window of PowerGUI, add the following script:

    # Defining script variables
    $SiteUrl = "http://www.contoso.com"
    $PressReleaseFileName = "PressRelease"
    # Loading Microsoft.SharePoint.PowerShell
    $snapin = Get-PSSnapin | Where-Object {$_.Name -eq 'Microsoft.
    SharePoint.Powershell'}
    if ($snapin -eq $null) {
    Write-Host "Loading SharePoint Powershell Snapin"
    Add-PSSnapin "Microsoft.SharePoint.Powershell"
    }
    $SPSite = Get-SPSite | Where-Object {$_.Url -eq $SiteUrl}
    if($SPSite -ne $null)
    {
    Write-Host "Connecting to root site site"
    $PressReleaseWeb = $SPSite.OpenWeb("/PressReleases")
    $pubWeb = [Microsoft.SharePoint.Publishing.PublishingWeb]::GetPu
    blishingWeb($PressReleaseWeb)

    Write-Host "Retrieving 'Blank Web Part page' page layout"
    $pageLayout = $pubWeb.GetAvailablePageLayouts() | Where-Object
    {$_.Title -eq "Blank Web Part page"}

    Write-Host "Creating a new page"
    $pageFileName = $PressReleaseFileName+".aspx"
    $page = $pubWeb.GetPublishingPages().Add($pageFileName,
    $pageLayout)

    Write-Host "Setting new page metadata"
    $page.Title = $PressReleaseFileName
    $pageItem = $page.ListItem
    $pageItem["Comments"]="New press release"
    $pageItem["PublishingContactName"]="Brad"
    $pageItem["PublishingContactEmail"]="brads@contoso.com"
    $page.Update()

    Write-Host "Retrieving and updating an existing page"
    $existingPage=$pubWeb.GetPublishingPages() | Where-Object {$_.
    Name -eq "default.aspx"}
    $existingPage.CheckOut()
    $existingPageItem = $existingPage.ListItem
    $existingPageItem["Comments"]="Press release landing page"
    $existingPage.Update()

    Write-Host "Checking in and publishing changes"
    $existingPage.CheckIn("Checked in by PowerShell script")
    $existingPage.listItem.File.Publish("Published by PowerShell
    script")
    $page.CheckIn("Checked in by PowerShell script")
    $page.listItem.File.Publish("Published by PowerShell script")
    if ($existingPage.listItem.ParentList.EnableModeration)
    {
    $modInformation = $existingPage.listItem.
    ModerationInformation
    if($modInformation.Status -ne [Microsoft.SharePoint.SPModerat
    ionStatusType]::Approved)
    {
    $existingPage.ListItem.File.Approve("Approved by
    PowerShell script")
    }
    }
    if ($page.listItem.ParentList.EnableModeration)
    {
    $modInformation = $page.listItem.ModerationInformation
    if($modInformation.Status -ne [Microsoft.SharePoint.SPModerat
    ionStatusType]::Approved)
    {
    $page.ListItem.File.Approve("Approved by PowerShell
    script")
    }
    }
    $PressReleaseWeb.Dispose()
    }
    $SPSite.Dispose()

  3. Click File | Save to save the script to your development machine's desktop. Set the filename of the script to CreatingEditingPages.ps1.
  4. Open the PowerShell console window and call CreatingEditingPages.ps1 using the following command:

    PS C:\Users\Administrator\Desktop> .\ CreatingEditingPages.ps1

  5. As a result, your PowerShell script will execute and return results as shown in the following screenshot:

  6. Now, let's switch to our SharePoint Publishing Site: http://www.contoso.com/.
  7. From the Quick launch of the site, click Press Releases.
  8. Click Site Actions | View All Site Content.
  9. Under the Document Libraries category, click the Pages library./li>
  10. Take note of the newly created PressRelease page, as shown in the following screenshot:
  11. Access the content menu of the page and select View Properties.
  12. Take note of a few of the new property values we have assigned in our script, as shown in the following screenshot:

How it works...

In this recipe, we defined the URL of the site as well as the newly provisioned page name as our script variables:

$SiteUrl = "http://www.contoso.com"
$PressReleaseFileName = "PressRelease"

Note that in this recipe, we're publishing a site collection with a different URL and not our collaboration site collection.

Next, we load PowerShell SharePoint snap-in and retrieve the current site collection object. The demonstration environment contains the sub-site under the main site URL. The sub-site is used for demo press releases and we get a hold of it using the following command:

$PressReleaseWeb = $SPSite.OpenWeb("/PressReleases")

We then convert the press release web object to a publishing site object using the following command:

$pubWeb = [Microsoft.SharePoint.Publishing.PublishingWeb]::GetPublishingWeb($PressReleaseWeb)

Before we go ahead and create an instance of the page, we got a hold of the page layout which the page uses. The page layout will drive which web part zones are going to be displayed on the page. We get the Blank Web Part page page layout:

$pageLayout = $pubWeb.GetAvailablePageLayouts() | Where-Object {$_.Title -eq "Blank Web Part page"}

Once our filename for the new page has been constructed, we can go ahead and create a new page object as shown in the following code:

$page = $pubWeb.GetPublishingPages().Add($pageFileName, $pageLayout)

Now that the page has been created, we can edit its properties. Have you noticed how we first got a hold of the ListItem object of the page before editing the properties? We do this since the page object doesn't have direct access to some of the properties of the page item. The page is just an item within the page library and in order to access its underlying object functionality we use the ListItem property and make updates to the underlying object directly as follows:

$pageItem["PublishingContactEmail"]="brads@contoso.com"

As a part of this recipe, we also retrieved the existing page in order to demonstrate how you can modify the existing page on the publishing site. We start by retrieving items in the page library with the filename. The page filename is default.aspx:

$existingPage=$pubWeb.GetPublishingPages() | Where-Object {$_.Name -eq
"default.aspx"}

We then check out the file and make changes to its properties just as in the example with the newly provisioned page. Once ready, we check in both pages using the following command:

$page.CheckIn("Checked in by PowerShell script")

Since publishing pages require to be published before displayed for everyone else, we publish the page using the following command:

$page.listItem.File.Publish("Published by PowerShell script")

Most publishing pages require items to be approved before published to the site. We first check whether the moderation is required for the library using the following command:

$existingPage.listItem.ParentList.EnableModeration

If the moderation is enabled on the library, we verify that the page has not been approved yet. If the page is pending approval, we approve the item by using the following command:

$existingPage.ListItem.File.Approve("Approved by PowerShell script")

Since we opened an instance of the Press Release web on the site, we close the object of both the web and the site to prevent memory leaks.

Summary

In this article, we covered the following topics:

  • Creating basic and complex content types
  • Creating and configuring document sets
  • Creating and editing publishing pages with PowerShell

Further resources on this subject:


About the Author :


Yaroslav Pentsarskyy

Yaroslav Pentsarskyy has been involved in SharePoint solution architecture and implementation since 2003. As a Microsoft MVP since 2009 he keeps in close touch with the SharePoint product team. Yaroslav frequently presents at local and worldwide tech events as well as online; you can always find a fresh bit of SharePoint information on his blog: http://www.sharemuch.com. He is the author of two other SharePoint titles: “Top 60 custom solutions built on SharePoint 2010” and “SharePoint 2010 branding in practice”.

Yaroslav Pentsarskyy is the author of "Microsoft SharePoint 2010 and Windows PowerShell 2.0: Expert Cookbook".

Books From Packt


SharePoint Designer Tutorial: Working with SharePoint Websites
SharePoint Designer Tutorial: Working with SharePoint Websites

Microsoft SharePoint 2010 Administration Cookbook
Microsoft SharePoint 2010 Administration Cookbook

Microsoft SharePoint 2010 Power User Cookbook
Microsoft SharePoint 2010 Power User Cookbook

Microsoft Silverlight 4 and SharePoint 2010 Integration
Microsoft Silverlight 4 and SharePoint 2010 Integration

Microsoft SharePoint 2010 Development with Visual Studio 2010 Expert Cookbook
Microsoft SharePoint 2010 Development with Visual Studio 2010 Expert Cookbook

Microsoft SharePoint 2010 End User Guide: Business Performance Enhancement
Microsoft SharePoint 2010 End User Guide: Business Performance Enhancement

Microsoft SharePoint 2010 Enterprise Applications on Windows Phone 7
Microsoft SharePoint 2010 Enterprise Applications on Windows Phone 7

Microsoft SharePoint 2010 development cookbook
Microsoft SharePoint 2010 development cookbook


No votes yet

Post new comment

CAPTCHA
This question is for testing whether you are a human visitor and to prevent automated spam submissions.
N
f
p
B
6
e
Enter the code without spaces and pay attention to upper/lower case.
Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software