SharePoint Nilaa - what succeeds and acquires

Install and uninstall assemblies from GAC

2014-05-23T02:59:00.001-07:00

Its easy to install and uninstall a bunch of dlls thru the powershell scripts

install.ps1

set-alias -name Gacutil -value "C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools\gacutil.exe"

get-childitem | where {$_.extension -eq ".dll"}| Foreach-Object {Gacutil /i $_}

uninstall.ps1

set-alias -name Gacutil -value "C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools\gacutil.exe"

get-childitem | where {$_.extension -eq ".dll"}| Foreach-Object {Gacutil /u $_.BaseName}

Steps to test

1. Create folder, then create 2 ps1 files by pasting the code written above

2. Copy the dlls that need to be deployed to GAC into that folder

3. Open Windows Powershell

4. Navidate to that folder by executing cd <folder path>

5. Optionally run the command to allow ps1 to run from the prompt Set-ExecutionPolicy Unrestricted

6. To install all the dlls of that folder run ./install.ps1

7. To install all the dlls of that folder run ./uninstall.ps1

Note: the value given for Gacutil will be different depending on the framework installed in your box. You may have to change it accordingly.

Compare CAML and LINQ

2012-11-20T05:34:00.001-08:00

Yesterday - I interviewed couple of candidates for a new lead developer position in my project. Unfortunately none of those candidates were able to compare CAML and LINQ properly which is a basic question. Let me share my notes here

CAML - Collaborative Application Markup Language is an XML based markup language that helps developers to both construct and display data. CAML can be used by developers to query against SharePoint lists and views, when programming against the SharePoint API. CAML is also supported by SharePoint Web Services.

LINQ - Language-Integrated Query is relatively new feature that extends powerful query capabilities to the language syntax of C# and Visual Basic. It introduces standard, easily-learned patterns for querying and updating data, and the technology can be extended to support potentially any kind of data store including SharePoint Lists. The LINQ to SharePoint Provider is defined in the Microsoft.SharePoint.Linq namespace. It translates LINQ queries into Collaborative Application Markup Language (CAML) queries. It is no longer necessary for developers to know how to write CAML queries. LINQ queries can be used in server code.

Disadvantages of CAML:

CAML query is text based so, if we are joining two lists across a lookup field there may be various problems associated with that.
There is no mechanism to know until run time if the query is written correctly or not. If the query is not correct, then it will simply fail at run time. Means it won't support at design time
When writing the query, you have no idea what CAML elements are legal in the syntax without having a reference open.
The query is somewhat difficult to understand. We cannot determine easily what the query is doing and what lists are being joined.
The data returned from the query is placed in a SPListItem collection, which does not provide strongly typed business entities.

Advantages of LINQ over CAML:

First advantage is, it is an object-oriented query language.
It can provide strongly typed objects at design time; we can create queries in code and can check that they are correct because we can the compiles the code.
The results are returned from queries are strongly typed objects, so the items and fields can provide compile-time checking.

Disadvantages of Using LINQ

LINQ translates the LINQ queries into Collaborative Application Markup Language (CAML) queries thus adding an extra step for retrieving the items.

Developer Dashboard in SP2010 and new 2013

2012-11-08T05:17:00.000-08:00

Have you ever told to figure out why your SharePoint page is consuming much time? In projects where the page render SLAs are at an aggressive end - like one of my current project - we SharePoint engineers will have a real good time...

In the older versions (MOSS 2007, SPS 2003) this was too tuff - personally I used to follow a manual approach in isolating the issue by removing web parts one by one etc... I believe SharePoint product team invested a lot and came up real good feature in SP2010 named Developer Dashboard.

Developer Dashboard is designed to provide additional performance and tracing information that can be used to debug and troubleshoot issues with page rendering time. This used often by the administrators whenever there is a need to identify / improve page performance. Enabling this great feature will help you get critical information about execution time, log correlation ID, critical events, database queries, service calls, SPRequests allocation and web part events offsets etc.

We can set the DashBoard in the following 3 levels

OnDemand. : In this mode you should see on the left hand side of the ribbon a small icon next to the login credentials. On clicking that icon - SharePoint will toggle the dashboard display beneath the page output. This toggle option will be available only to site collection admins. Looks promising right...

On. : In this mode you will not see the small icon at the top of the page but the Developer Dashboard will be available on the bottom of your entire page always.

Off. : In this mode you neither see the dashboard nor the icon to display it.

By default the Developer Dashboard will be turned off - it can be enabled easily using object model code, STSADM commands or PowerShell script.

The following script/command will enable developer dashboard in "OnDemand" mode. To switch it on and of , use "on" and "off" parameter values respectively.

PowerShell

$sp =[Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings;

$sp.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::OnDemand;

$sp.RequiredPermissions = 'EmptyMask';

$sp.TraceEnabled = $true;

$sp.Update();

STSADM

stsadm -o setproperty -pn developer-dashboard -pv ondemand

Object Model

SPWebService sp = SPWebService.ContentService;

sp.DeveloperDashboardSettings.DisplayLevel = SPDeveloperDashboardLevel.OnDemand;

sp.DeveloperDashboardSettings.Update();

Note: DeveloperDashboardSettings has a property called RequiredPermissions. You can assign a collection of base permissions (like EditLists, CreateGroups, ManageAlerts, or whatever you want) to it; only those people that have those permissions will be able to see the output.

Note: Developer Dashboard is a farm level setting. So If you code the above object model snippet up in a web part and try to execute it in a non-central admin site, it will throw a security exception.

Note : code from Sandboxed component won’t be showing up in Dashboard since its running in completely different process from the page request.

What is there in Dashboard

In the Dashboard you will find information about the controls, queries and execution time that occur as part of the page rendering process. Usually it provides information from the perspective of the event pipeline, the web server and database. On the left side you can see the different events that fired in the page processing pipeline and its processing duration. On the top right hand side you see information about the page processing as whole, including the overall execution time, the amount of memory used in the processing of the page request and the correlation ID. Correlation IDs are great info when trying to link the page render to entries in the ULS log. Underneath the server information you will find a list of the different database calls that were made through the object model by various components in the page itself as well as the controls it hosts. There is an additional option to to see the call stack of every database call - by clicking the database call hyperlinks.

Why to use SPMonitorScope as a best practice

Developer DashBoard does not display the entire set of events instead the code you have in your override for OnInit or Render will be captured in this pipeline. To ensure the trace of code in other places use the new object model class called the SPMonitoredScope it helps to keep track of useful usage and tracing information just like the developer dashboard uses. You may use it as shown below

using (SPMonitoredScope scpBtnGetScore = new SPMonitoredScope("BtnGetScore_Click"))

{//add your custom code here}

In my understanding this is the only option to understand an manage the custom components once you deploy it in PROD.

Whats new in SP2013

Developer Dashboard in SP2013 is using dedicated WCF service (diagnosticsdata.svc) it allows Detailed request information per page with chant view and additional detailed information included for request analyzing. There is an Interactive addition in the new Developer Dashboard with which you can now View ULS logs (under a dedicated tab) for particular request. This will definitely save developer since it avoids the dependency with admin teams to get ULS logs that they need. Now Developer Dashboard is running in separate window to avoid affecting rendering of actual page.

Don’t know why the OnDemand option is deprecated: Only ON & OFF settings are available. Will share more details soon...

Back to basics 8 : Client side apps in SharePoint 2010

2012-10-21T11:30:00.000-07:00

Traditional server-side controls approach to building a web-based user experience include master pages, application pages, themes, cascading style sheets (CSS), Web Parts, delegate controls, navigation controls and providers, and so on. SharePoint uses these resources to construct an ASP.NET page dynamically. This is then converted into HTML, packaged into an HTTP response, and sent to the web browser on the client. Here All the logic execute on the server and proceeds with a full page postback.

Info flow is Browser -Get/Put/Post---> ASP.net page (with web controls) --> SharePoint Object Model --> ASP.net page -HTML--> Browser.

This approach has the disadvantages like limited interactivity, high response time etc. Rich Internet Application technologies like Ajax, Silverlight, Flash provide more engaging user experience since it execute some logic on browser rather than relying entirely on server side execution. RIA tech use async communication without reloading entire page - it disassembles request from response and results more responsive work and ability to perform work in parallel.

AJAX (Async JavaScript and XML) is a set of technologies that allow us to retrieve data asynchronously from the server and manipulate data in client computer without disrupting entire page. AJAX traditionally rely on Javascript XMLHttpRequest API to send async requests to web server and to return the response to the calling script, the script could then use the response to retrieve and manipulate the DOM of current page (value of a table cell etc). Popular Javascript frameworks such as JQuery (jQuery is a fast and concise JavaScript Library that simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development. AJAX is a technique to do an XMLHttpRequest (out of band Http request) from a web page to the server and send/retrieve data to be used on the web page. AJAX stands for Asynchronous Javascript And XML. It uses javascript to construct an XMLHttpRequest, typically using different techniques on various browsers. jQuery is a javascript framework that makes working with the DOM easier by building lots of high level functionality that can be used to search and interact with the DOM. Part of the functionality of jQuery implements a high-level interface to do AJAX requests. jQuery implements this interface abstractly, shielding the developer from the complexity of multi-browser support in making the request. In nutshell Ajax is a technology / paradigm, whereas jquery is a library (which provides - besides other nice functionality - a convenient wrapper around ajax).AJAX is a way of sending information between browser and server without refreshing page. It can be done with or without library like jQuery. AJAX is the underlying technology for every website that doesn't do a refresh to perform some server-side functionailty. AJAX is provided by javascript using the XMLHttpRequest object which is the heart of AJAX. jQuery, Prototype, Dojo, and all other client side frameworks, are just providing a wrapper for the XMLHttpRequest object so that it makes it browser compatible and easy to use. This is because using the XMLHttpRequest object natively can be quite difficult and may not work across all browsers the way you intend.

Silverlight is a development platform that enables you to create rich, engaging applications that run in web browsers and on other devices. Silverlight developers use a specialized, lightweight version of the Microsoft .NET Framework to create applications. Alongside the benefits of a familiar .NET development experience, Silverlight offers capabilities in areas such as graphics, animation, and multimedia that go well beyond what you can achieve with Ajax.It's increasingly common to use a combination of Silverlight applications, Ajax elements, and traditional server-side controls together to provide a full range of functionality for SharePoint users. Silverlight applications can also interact directly with Ajax elements on a page.

Client Side application is any logic that interacts with SP data from an external computer including browser, stand alone solutions and mobile devices. Client Side logic development will provide the advantages like richer UX, option to modify data from other app like custom solution. Usually compiled Silverlight applications (XAP files) are hosted within HTML object elements, which can either be embedded in the page or generated dynamically through JavaScript. In the case of a SharePoint web page, Silverlight applications are typically hosted within a Web Part. SharePoint 2010 includes a Silverlight Web Part that is specifically designed for hosting XAPs within a SharePoint page. Just like web pages that contain Ajax-enabled components, the browser must use a traditional synchronous page load at least once in order to render the page and download associated resources, such as the Silverlight XAP and any JavaScript files. Silverlight applications can also interact directly with Ajax elements on a page.

Client Object model provide a subset of classes in server side (microsoft.sharepoint.dll) assembly and are implemented as a WCF service (/_vti_bin/client.svc) , but they use web bindings to implement efficient request batching(Bindings are used to specify the transport, encoding, and protocol details required for clients and services to communicate with each other. WCF uses bindings to generate the underlying wire representation of the endpoint, so most of the binding details must be agreed upon by the parties that are communicating.). Commands are serialized into XML and sent to the server in a single HTTP request. For every command, a corresponding server object model call is made, and the server returns a response to the client in compacted JavaScript Object Notation (JSON) format, which the proxy parses. The client APIs provide a familiar, object-oriented interface to the WCF service, so developers are shielded from the details of the service. In particular, the client-side runtime handles all communication between the clients and server.

Three Client object model Sp2010

Client Object Model for Silverlight apps : object model will either be downloaded as part of the .xap file or the file Microsoft.SharePoint.Client.xap seperate.
Client Object Model for .Net : called only if the object model assembles installed in client computer (silvelight redistribution package) Info Flow is ... Managed Control & Logic (Managed Client) --> Managed COM --> Proxy -XML request-> Client.svc (SharePoint server) --> Server Object Model --> Content DB --> Server Object Model --> Client.svc -JSON Response-> Managed COM --> Managed Control & Logic (Managed Client)
Client Object Model for JavaScript : the constituent .js files downloaded automatically into users computer when a page references the object model is accessed. Info Flow is ... Javascript Control & Logic (Browser) --> Javascrict COM --> Proxy -XML request-> Client.svc (SharePoint server) --> Server Object Model --> Content DB --> Server Object Model --> Client.svc -JSON Response-> Javascript COM --> Javascript Control & Logic (Browser)

In older SharePoint versions the options to access data from client apps were limited to ASP.Net web Services. The lack of a strongly typed object model and the need to construct complex CAML queries to perform simple data operations made the development of SharePoint client apps challenging and somewhat limited. SP2010 has new data access mechanisms that make it easier to build RIA that consume and manipulate SharePoint data.

There are 3 approaches to access SharePoint data from client apps.

Client side object model : 3 seperate APIs that provide a subset of Server Object Model for client side usage. ECMA Script client object model, Silverlight client Object Model and .Net managed client object model
REST (Representational State Transfer) Interface uses WCF Data Services to expose SP Lists and ListItems as addressable resources that can be accessed through HTTP requests. REST interface maps read, create, update and delete operations to GET, POST, PUT and DELETE HTTP verbs.
ASP.Net web services are nothing but the ASMX web services that were available in prior sharepoint version

For future compatability, its advisable to use CSOM and REST.

Of the three principal approaches to client-side data access, using the CSOM APIs is the only approach that provides the kind of hierarchical, strongly-typed representation of SharePoint objects, such as sites and Webs, that compares to server-side development. The CSOM is the only approach for any client-side data access scenarios beyond list queries. The CSOM allows you to query SharePoint lists by creating CAML queries. This is the most efficient way to query lists, although it requires that developers revert to creating CAML queries. Specific cases where you should favor the use of the CSOM include the following:

You need to perform advanced list operations, such as complicated joins or paging. You can also perform joins through REST requests, although this is subject to various limitations.
You need to manipulate SharePoint objects, such as sites or Webs.
You need client-side access to other areas of SharePoint functionality, such as security. Although the CSOM APIs mirror the server APIs in terms of functionality, the way CSOM actually works necessitates some changes to the way in which you approach your development tasks. The CSOM uses a set of specialized Windows Communication Foundation (WCF) services to communicate with the SharePoint server. Each API is optimized to work efficiently with remote clients and with the asynchronous loading model used by the Ajax and Silverlight frameworks.

Note: All the CSOM APIs include a ClientContext class that manages the interaction between client-side application code and the SharePoint server. Before you perform any operations in client-side code, you must instantiate a ClientContext object with the URL of a SharePoint site

The client-side code uses the ClientContext class to define a series of operations to execute against a SharePoint site. In this example, the operations are the following:
Retrieve the Parts list.
Retrieve the Inventory Locations list.
Build a query for the Parts list.
Build a query for the Inventory Locations list.
Execute the query against the Parts list.
Execute the query against the Inventory Locations list.
Load the Parts query results (which causes them to be returned to the client).
Load the Inventory Locations query results.
The client code calls the ClientContext.ExecuteQueryAsync method. This instructs the CSOM to send a request containing all operations to the server.
The SharePoint server executes the series of operations in order and returns the results to the client. The CSOM notifies the client-side code of the results by invoking the callback method associated with the onQuerySucceed delegate. This request batching process helps to improve performance and reduce network traffic in two ways. First, fewer Web service calls occur between the client and the SharePoint server, which reduces the "chattiness" of the client-server interface. For example, you can perform two list queries in a single request. Second, as a set of operations occur on the server in a single request, the data being acted on doesn't need to be moved between the client and the server for the intermediate operations—only the list of operations and the final result set are passed between the client and the server.

Request batching requires a different mindset when you create queries from client-side code. First, be aware that you do not have access to any results until you call ExecuteQueryAsync (or ExecuteQuery) and receive the call back with the results. If you need to implement conditional logic in the client-side code that can't be expressed in the command list that you send to the server, you will need to execute multiple queries. Second, you should aim to group your operations to minimize the number of service calls. This means you may need to think about how you sequence your logic in order to take full advantage of request batching.

Representational State Transfer (REST) interface is a WCF data service that allows us to use construct HTTP request to query SharePoint list data. Like all RESTful Web services, the SharePoint REST interface maps HTTP verbs to data operations, as
GET - Retrieve
POST - Create
PUT - Update (update all fields and use default values for any undefined fields)
DELETE - Delete
MERGE - Update (update only the fields that are specified and changed from current version)
In practice, many firewalls and other network intermediaries block HTTP verbs other than GET and POST. To work around this issue, WCF Data Services (and the OData standard) support a technique known as "verb tunneling." In this technique, PUT, DELETE, and MERGE requests are submitted as a POST request, and an X-HTTP-Method header specifies the actual verb that the recipient should apply to the request.

The SharePoint REST interface is based on the REST-based Open Data protocol (OData) for Web-based data services, which extends the Atom and AtomPub syndication formats to exchange XML data over HTTP. Because OData is a platform-independent open standard, the SharePoint REST interface is a great way to access SharePoint list data from platforms on which the CSOM may be unavailable to you, such as from non-Windows–based operating systems. However, the REST interface only provides access to list data—if you need to manipulate other data on your SharePoint site, you will need to use the CSOM. The REST implementation can also return the output in JavaScript Object Notation (JSON) format as an alternative to an ATOM feed. JSON is a compact representation of the returned results that can be easily parsed by JavaScript clients.

Ref:

http://msdn.microsoft.com/en-us/library/ee537247.aspx
http://msdn.microsoft.com/en-us/library/ff798413.aspx
http://msdn.microsoft.com/en-us/library/ff521587(v=office.14).aspx
http://msdn.microsoft.com/en-us/library/ff798339.aspx
http://msdn.microsoft.com/en-us/library/ff521587(office.14).aspx
http://msdn.microsoft.com/en-us/library/ee535480(v=office.14).aspx
http://msdn.microsoft.com/en-us/data/ff478141.aspx

Back to basics 7 : How Sharepoint works

2012-10-13T15:59:00.000-07:00

A web application in SharePoint terminology is closely related to what is called a website in IIS terminology. An IIS website monitors for incoming requests through a particular port, and it checks for a particular host header or IP address, or both. Every SharePoint Foundation web application is hosted in an IIS website that has the same name as the web application. It can be helpful, especially when you are trying to see the relation between SharePoint and IIS from a high and broad perspective, to think of the SharePoint web application and its corresponding IIS website as a single entity. For one thing, although there is usually a one-to-one relation between SharePoint web applications and IIS websites, this is not always the case. It is possible to extend a SharePoint web application to multiple IIS websites, although that is not a common design. Just as in any application that is built on the ASP.NET-IIS integrated pipeline, when a front-end web server receives a request from a client for a page or other resource in a SharePoint site, the request is passed through a pipeline of units that process the request. This processing includes authenticating the user, verifying the user’s authorization, building the response, sending the response, and finally, logging the request.

The response to any request is produced by an HTTP handler object. Requests are assigned to one or another HTTP handler object (or to a handler factory class that creates HTTP handler objects) depending on the resource requested and the HTTP verb in the request. The assignment is determined by a stack of configuration files named applicationhost.config, machine.config, and web.config.

The request pipeline also contains HTTP modules. Modules are assemblies that typically contain one or more event handlers or define new events that other modules can handle. An HTTP module can register for one or more events in the life cycle of the request. They are often used to preprocess requests or postprocess the response. The result of a module’s preprocessing is stored in the HttpContext object. For example, the value of the User property is produced by an authentication module.

The processing of a request by HTTP modules and an HTTP handler is governed by an HttpApplication object or an object derived from that class. SharePoint installs a global.asax file in the root of each web application (IIS website) that identifies SPHttpApplication as the class from which an HTTP application object is created.

Back to basics 6 - Whats SharePoint

2012-10-08T15:57:00.000-07:00

SharePoint enables information workers who have no knowledge of website design or website administration to create, almost instantly, attractive and functioning websites. This is by the SharePoint features that allows delegated administration. This relieves IT departments from the burden of creating and administering the sites, and it empowers the Info Workers to create their own sites for teams, blogs, wikis, and other purposes. SharePoint provides a platform on which Info Workers can create collaboration solutions that include document libraries and workspaces, workflows, wikis, blogs, and team-oriented lists, such as Events, Announcements, and Tasks. Microsoft SharePoint Workspace provides an offline experience for these collaboration solutions.

SharePoint also allows Business processes to be systematized and modeled with workflows that are triggered by associated events; for example, the addition of a document to a document library. SharePoint Server Enterprise Content Management (ECM) features include document management, records management, and web content management. The Microsoft Business Connectivity Services (BCS) features of SharePoint enable data from non-SharePoint sources, such as a SAP installation or Oracle database, to be accessed (read/write) just as if it were an ordinary SharePoint list.

SharePoint can provide an intranet system with many of the functions that an operating system provides for a computer, including storing and copying files, hosting services, starting applications, and securing data. SharePoint can also host extranet and Internet-facing solutions. SharePoint deployments make data available through a client object model, the REST-based Windows Communication Foundation (WCF) Data Services (formerly ADO.NET Data Services), and many out-of-the-box ASMX web services. In addition, the SharePoint Service Application Framework provides a platform that enables developers to build scalable middle-tier services that can provide data or processing resources to other SharePoint features.

SharePoint stores data as multicolumn lists in a Microsoft SQL Server database. You can query the data by using LINQ and also using Collaborative Application Markup Language (CAML). The data can be mirrored, backed up, restored, and, depending on the edition of SQL Server being used, you may be able to take snapshots of the data store. Besides its native UI of webpages (including special versions for mobile devices), which can contain ECMAScript (JavaScript, JScript), SharePoint also supports access from Microsoft Silverlight applications and the Microsoft SharePoint Workspace client application. With the SharePoint client object model, you can access SharePoint using Windows Presentation Foundation (WPF), Windows Forms, or any other managed code application.

Back to basics : 5 All about onet xml

2012-10-02T14:50:00.000-07:00

The global Onet.xml file defines list templates for hidden lists, list base types, a default definition configuration, and modules that apply globally to the deployment. Each Onet.xml file in a subdirectory of the %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\SiteTemplates directory can define navigational areas, list templates, document templates, configurations, modules, components, and server email footers that are used in the site definition to which it corresponds.

When Microsoft SharePoint Foundation is installed, several Onet.xml files are installed—one in %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\GLOBAL\XML that applies globally to the deployment, and several in different folders within %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\SiteTemplates. Each file in the latter group corresponds to a site definition that is included with SharePoint Foundation.

Depending on where an Onet.xml file is located and whether it is part of a site definition or a web template, the markup in the file does some or all of the following:

Specifies the web-scoped and site collection-scoped Features that are built-in to websites that are created from the site definition or web template.
Specifies the list types, pages, files, and Web Parts that are built-in to websites that are created from the site definition or web template.
Defines the top and side navigation areas that appear on the home page and in list views for a site definition.
Specifies the list definitions that are used in each site definition and whether they are available for creating lists in the user interface (UI).
Specifies document templates that are available in the site definition for creating document library lists in the UI, and specifies the files that are used in the document templates.
Defines the base list types from which default SharePoint Foundation lists are derived. (Only the global Onet.xml file serves this function. You cannot define new base list types.)
Specifies SharePoint Foundation components.
Defines the footer section used in server email.

You can perform the following kinds of tasks in a custom Onet.xml file that is used for either a custom site definition or a custom web template:

Specify an alternative cascading style sheet (CSS) file, JavaScript file, or ASPX header file for a site definition.
Modify navigation areas for the home page and list pages.
Add a new list definition as an option in the UI.
Define one configuration for the site definition or web template, specifying the lists, modules, files, and Web Parts that are included when the configuration is instantiated.
Specify Features to be included automatically with websites that are created from the site definition or web template

You can perform the following kinds of tasks in a custom Onet.xml file that is used for a custom site definition, but not in one that is used for a custom web template:

Add a document template for creating document libraries
Define more than one configuration for a site definition, specifying the lists, modules, files, and Web Parts that are included when the configuration is instantiated.
Define a custom footer for email messages that are sent from websites that are based on the site definition.
Define custom components, such as a file dialog box post processor, for websites that are based on the site definition.

Back to basics :4 Sharepoint config files

2012-09-27T07:38:00.000-07:00

I always excited about the SharePoint product team's vision on the way they aligned multiple moving parts to achieve the business objectives of the product. One of the main things in that context is the configuration entity. SharePoint configuration settings exist at several levels. As in all ASP.NET applications that use the integrated pipeline,

some fundamental settings are in the machine.config file,
the global web.config file, and
the applicationhost.config file, which is the IIS configuration store.

SharePoint makes no changes in the default versions of the first two files. It does make some changes in the IIS configuration store. Each IIS website and, therefore, each SharePoint web application, can have a web.config file in its root folder. This file is substantially customized by SharePoint whenever a SharePoint web application is created.

SharePoint also takes advantage of the fact that web.config files can be applied to specific virtual or physical folders within a web application. For example, SharePoint puts a web.config file in the virtual directory _layouts\mobile (which is mapped to the physical directory %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\LAYOUTS\MOBILE\). Among other things, the web.config file registers a series of filters that control how a page is rendered, based on the capabilities of the mobile device that has requested the page.

Farm-wide configuration settings are stored in the SharePoint configuration database on the computer that is running SQL Server in the farm. Configuration for specific types of websites is contained in various kinds of XML files, such as the Onet.xml file, and configuration for specific instances of websites is contained in the content database. In addition, several classes in the SharePoint object model have property bags that can be used to store custom configuration information for specific objects, such as objects that represent websites, Features, alerts, and files.

Back to basics - 3 Sharepoint Solutions

2012-09-20T06:59:00.000-07:00

SharePoint solutions are generally packaged in SharePoint solution package files . SharePoint solution package files can contain several kinds of elements, including assemblies, user controls, custom ASP.NET pages, XML configuration files, resource files, images, list definitions, Web Parts, Features, and others. JavaScript files and Silverlight .xap files can also be deployed to the servers by using SharePoint Solution Packages.

There are 2 kinds of solutions

Farm solutions that are deployed by farm administrators to the farm's solution store, which is in the farm's configuration database. This is done by using either the SharePoint Management Shell or the object model. Solution Deployment step requires a farm administrator and can be done by using either Central Administration or SharePoint Management Shell, or the object model. Some examples of how elements are deployed: user control files (.ascx) are copied to %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\ControlTemplates and assemblies are deployed to the global assembly cache or to a web application's \bin folder. If there are SharePoint Features in the farm solution, they are in this step copied to a subfolder of %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\TEMPLATE\FEATURES.

Sandboxed solutions that are deployed to a specific site collection's Solution Gallery by a site collection administrator. The gallery is a special SharePoint list, so it is in the content database. Solution deployment to the gallery is done through the Site Actions UI of the site collection or by using SharePoint Management Shell. The deployment step is taken by a site collection administrator. There are limits on what kinds of elements can be in sandboxed solutions and where they can be deployed. For example, nothing can be deployed to the file system of the servers from a sandboxed solution. Features in sandboxed solutions are deployed to the content database.

Installation of a SharePoint solution package is a multi-step process:
1. Adding: A solution package file is added to one of two stores based on the solution type(farm, sandboxed).
2. Deploying: The solution package is unpacked and its elements are deployed to their appropriate places. It is also in this second step that any Features in the solution are installed in the Feature Gallery of the farm, web application, site collection, or website, depending on the scope of the Feature.

Within a SharePoint solution package, there can be an additional level of encapsulation because a solution can have one or more SharePoint Features. A Feature can be installed at the scope of the farm, the web application, the site collection, or the website. After it is installed, a Feature must be activated by owners of any website within the scope; so Activating becomes a third step of installation for Features. Features can contain content types, controls, custom actions, custom fields, files, workflows, list instances, list templates, event receivers, and document converters; although some of these cannot be included in certain scopes. (Features that are deployed in sandboxed solutions can be scoped only to a site collection or website. For site collection-scoped features in sandboxed solutions, the second and third steps are combined. The Features are activated when the solution is deployed.)

Some SharePoint solutions target one of the client object models, either exclusively or in addition to targeting the server object model: the JavaScript, Silverlight, and Microsoft .NET Framework client object models. The script files that define the JavaScript object model are downloaded to a client computer when a page that references them is opened. Similarly, a Silverlight .xap executable is downloaded to the client computer when a page that is hosting it is accessed. The SharePoint assemblies that contain the Silverlight client object model are encased in the .xap file. Those assemblies are Microsoft.SharePoint.Client.Silverlight.dll and Microsoft.SharePoint.Client.Silverlight.Runtime.dll.
Stand-alone .NET Framework applications (such as a WPF application) that target the SharePoint client object model are installed just as any other client applications: using MSI files or ClickOnce. The assemblies that contain this client object model, Microsoft.SharePoint.Client.dll and
Microsoft.SharePoint.Client.Runtime.dll, must be distributed as part of the solution.

Back to Basics 3 - SharePoint Security

2012-09-06T06:23:00.001-07:00

SharePoint extends a strong security framework around its deployments to protect from unauthorized users, and errant code. SharePoint's role based security controls user access at different levels right from web app to list item. SharePoint solely depend on the authentication mechanism extended by external systems - Windows Auth or non-Windows Auth. The authorization process implemented within sharepoint assumes the user is properly authenticated.

The default authentication mechanism supported by SharePoint is "Windows Claims based auth" which is built on top of Windows Identity Foundation. In this model, user presents an identity to the Farm as a set of claims (eg: user name, email) and the external identity system is configured to give SharePoint all the
info that it needs about the user with each request along with cryptographic assurance that the identity data come from a trusted source. SharePoint 2010 also support Windows classic authentication and ASP.Net forms based auth.

Access to all securable sharepoint objectts controlled thru a role based membership system by which users, groups are assigned rles to authorize their access to SharePoint objects. SharePoint follows a inheritance model in granting / revoking user access. A role definition will logically group a set of rights (read list item, create item etc.) that can be associated with a user , group as part of setting role assignment. SharePoint supports both Domain groups and SharePoint Groups. Domain groups will exist outside SharePoint with a less flexibility to manage (add users, remove etc) it but it can be used anywhere within the scope of the Active Directory Service. SharePoint groups are scoped to the site collection level and will be visible within the scope of that site collection.

As part of code security , SharePoint supports app pool seperation, ability to keep code in GAC and BIN which provides different levels of acces, sandboxed solutions

Every web application runs in an IIS application pool that processes HTTP requests. The pool itself runs in a user account known as the application pool identity. In a multiserver farm, this is usually a domain user. The application pool identity is the user identity for code that runs in an IIS worker process. However, access to various SharePoint objects is determined by the permissions of the user who has made the request that is being processed. The isolation of web applications into separate application pools ensures that if one of them crashes, the others are not affected. The IIS worker process calls assemblies that may operate under their own additional restrictions. If the assembly is loaded out of the global assembly cache, it operates in full trust. However, if the assembly is loaded out of the web application's \bin directory, it is subject to the trust limitations that are defined by a CAS policy.If the request is for a sandboxed solution, the SharePoint execution manager that runs in the IIS worker process spawns a sandboxed worker process. The latter process runs within a highly restrictive CAS policy, is limited to a subset of the SharePoint server object model, and can only access resources within the site collection to which the solution was deployed.

Back to Basics - 2 SharePoint 2010 Server Object Model

2012-09-04T05:18:00.001-07:00

Server Object Model in SharePoint is a large and critical classes helps developers to manage

Physical object hierarchy : classes represent physical components like servers and farms.
Content hierarchy : classes that represents publishable items of data and the nested containers of data.
Services hierarchy : includes classes that represent web services, Windows services, other types of services, instances of services, and CFSIs of services.

Main classes in Physical object hierarchy are

SPFarm : represents a sharepoint farm and its config DB.*
SPServer : represenets a physical server in the farm.*
SPService : represents a farm-wide service. *
SPSolution : represents a solution on a farm.

Main classes in Content hierarchy are

SPWebApplication : represents a sharepoint web app. *
SPContentDatabase : represents a content database that contains all the data and the customized page files that constitute the site collections that belong to the database. *
SPWeb : represents a single website.
SPSite : represents a collection of websites within a SharePoint web application that are grouped together for mainly administrative reasons (Among the SharePoint elements that can be scoped to the site collection level are master pages, Web Parts, themes, lists, content types, and Features. A site collection can also be a unit of backup and restoration. It is also the level at which groups of users are created and assigned default permissions. Site collections are the largest possible scope for a search in SharePoint Foundation, although broader search scopes are possible in SharePoint Server 2010. The content of a site collection is always included within a single content database.)
SPList : represents a sharepoint list and it has members for programmatically adding, deleting, and retrieving list items, and also for managing metadata about the list such, as its content types and fields.
SPListItem : represents individual items of a list and it has members for managing the item's fields, the values of its fields, its content type, and any associated workflows.
SPFolder : represents Folders of a List which give a hierarchical structure.
SPField : represents field (column) on a list item.

Main Calsses in Services hierarchy are

Child class of SPService : represent sharepoint service which provides members that get info about the jobs the service is performing.
Child class of SPServiceApplication : represents CFSI of a service *
Child class of SPServiceInstance : represents each instance of a service. A given CFSI can run on multiple servers, in which case each server has its own actual instance (a running process) of the CFSI. If the service has no CFSIs, it still has instances on each server on which it runs, but there can be no more than one instance of such a service on a given server.
SPServiceProxy & SPServiceApplicationProxy : Applications that consume services that conform to the framework are represented by proxies. The consumer proxy for a service is represented by an SPServiceProxy object and the proxy for the CFSI is represented by an SPServiceApplicationProxy object.*

* inherits from SPPersistedObject, which means that the object that instantiates the class persists in the configuration database

Notes after first Upgrade from SP2010 to 2013 preview

2012-09-01T15:12:00.001-07:00

Ohh... as and when a new SharePoint version releases - techies like us will be asked to think and act on upgrade. Now its from SP2010 to SP2013 - I m just done with the first candidate upgrade from SP2010 to Sp2013. As most of us guessed, Database attach is the only method supported by SharePoint team right now. As we all aware this is a costly option where we will upgrade the data and sites on a separate farm from the source.

Before the upgrade, it is recommended to gather info from the source farm (SP2010) - settings like AAM, Auth Providers and Auth Modes, Quota Templates, Managed Paths, Se;f Service Site Mgmt, email settings, custom components (WSPs etc) Certificates. environment info like - sites list, DB details and number of users. It is also recomended to do a clean up to eliminate poential upgrade errors, major clean up activities are to check and repair all DB consistency errors and turning off Web Analytics service application.

To proceed with database attach upgrade, a new farm should be available and the usual SP2013 setup steps should be employed to setup that. Let me refresh the steps in high level

Install software - DB server (SQL Server 2008 R2 or SQL Server 2012), Web / App Server - SP2013 prerequisites and SP2013 product
Run config wizard in Web / App Servers
Do not use config wizard to configure setup BCS, MMS, PPS, Search, Secure Store, UPS. We willl do it as part of upgrade

Once the environment is setup properly, copy the following DBs to new environment

Site Content DBs
BCS DB
MMS DB
PPS DB
Secure Store DB
Search DB
UPS DBs (profile, social, sync)

Note: You may set the DBs read only if you wish to restrict changes in source DBs

Next step is to upgrade service applications using the existing DBs and creating service app proxies using Powershell cmdlets like
New-SPProfileServiceApplication (Adds a User Profile Service application to a farm.)
New-SPProfileServiceApplicationProxy (Creates a User Profile Service application proxy on the local farm.)

Note: Please refer MSDN for full set of cmdlets @ technet

Now we can create and configure web applications, deploy customizations like wsps, site defs, CSS, web parts, web services, features, assemblies and web.config changes, form templates et al. No ned to create site collections since it will be created automatically when we upgrade content DB.

Make sure you are running Test-SpContentDatabase cmdlet before proceed with the next ste which is the Content DB upgrade. This step will verify the new environment has all of the components we need before we actually upgrade the DB.

Use Mount-ContentDatabase cmdlet to upgrade the DB. Note that this wont upgrade UI for the sites contained ion the DB.

Once the DBs are upgraded, site coll admins can upgrade their sites. I recomemnd the following steps for this

Run site collection health checks to identify and address potential issues in their site collections.
Optionally create an upgrade evaluation site collection. This will allow us to preview the new UI and address issues before actual upgrade.
Finally the Actual upgrade

You are all set to use the first upgraded SP2013 site!!!!

Right SharePoint 2013 APIs for your needs – A ready reckoner

2012-08-23T05:15:00.000-07:00

SharePoint products team amazes me every time they introduce a product version release. There are several options available when it comes to access SharePoint 2013 using APIs. Per my understanding the following will be the factors that decide which option to use

Type of customization like web parts, Silverlight App, SharePoint App Page, timer job and more. All these customization are different in most aspects and choosing right API option would eventually decide its eventual success
Enterprise governance rules will be the key differentiator in deciding the API option.
Development skill level is the other factor. Expertize in a the technologies like .NET Framework, Silverlight, PowerShell, JavaScript, ASP.NET, REST/OData will ensure the best development practices are applied in design / development of custom components
Devices we are targeting like farm server, client computer, mobile devices etc. The customization targeting different device should use appropriate API option.

Let me share a high level mapping based on the current info ...

API Option	Custom Component
Server Object Model	PowerShell script for farm / web app maintenance, tracking etc
	Timer job to perform scheduled actions on web app
	Web Parts to be displayed in sites
Silverlight client object model	Web Parts to be displayed in sites
	SharePoint App
	Silverlight Application that integrate with SharePoint site data
	ASP.Net web application that integrate SharePoint site data
REST/Odata Endpoints	ASP.Net web application that integrate SharePoint site data
	SharePoint App
	HTML/Javascript application that consume SharePoint site data
	App for office
	LAMP web application that integrate SharePoint site data
	iOS/Android app for mobile devices that access SharePoint site data
Javascript APIs	Web Parts to be displayed in sites
	ASP.Net web application that integrate SharePoint site data
	SharePoint App
	App for office
	HTML/Javascript application that consume SharePoint site data
.Net Client Object Model	.Net application that consume SharePoint site data
Mobile Silverlight API	Silverlight app for windows phone
Mobile Silverlight API	XNA app for Windows Phone

more to follow...

Back to Basics - 1 : Right from web apps and site collections

2012-08-11T09:59:00.000-07:00

Basically a SharePoint Web application is a logical abstraction on top of IIS. Physically, a Web Application is a "collection of one or more IIS Web sites configured to map incoming HTTP requests to a set of SharePoint sites." A mapping of each SharePoint site to one or more content databases that are specified within Central Administration.

Ideally we should primarily utilize separate Web apps for exposure to differing environments for example have intranet and extranet Web apps using HTTP and SSL respectively. As far as scalability is concerned, Web apps support up to 300 content databases and a recommended limit of around 2000 site collections per content DB assuming your infrastructure is up to it.

Adding additional Web apps adds additional administrative and infrastructure burden and - wherever possible - I would suggest using as few as possible. The decision to go with Web apps vs. site collections should be made as part of a wider discussion around your infrastructure.

When we need more than one web application? if there a need of

different authentication provider
different service applications group association
application pool isolation (e.g. for fault tolerance or security)
different url (with alternate access mappings)
different web.config
different bin folder
differing throttling settings
differing security policies. (e.g. set up a "finance" Web app with a locked down user policy, whereas a collaborative Web app may be less restrictive)

What additional overheads are associated with a Web application?

Additional RAM required per Web app (even with 0 users) > more hardware required.
Timer jobs (around 30 per Web app, several of which run every few minutes (e.g. alerts & workflow) and many which run daily (e.g. workflow processing and gradual site deletions)
More Content databases - per SQL instance limit, backup concerns, storage space
IIS sites > administrative overheads (host headers, IP addresses, SSL certificates, Web configuration files, assemblies).
Other operational overheads: DNS / request routing; SharePoint solution management

I would suggest having different site collection for different department, because

site collection is root level for many settings starting from permissions, site collection features like branding, master page, css, etc.
Also, there are features like Move-SPSite which moves one site collection to a separate content database.
If your SP Farm grows in time, it will be more scalable if each department having its own site collection is moved in separate content db.
With this kind of structure, you will prevent having huge databases, have better performance, etc.

Record Management capabilities of SharePoint 2010

2012-08-05T09:41:00.000-07:00

Last year I was part of an initiative to assess SharePoint 2010 capabilities around records / document management. Spend few weeks to compare business requirements and found the following info...

Functionality	Description	Customizations Required to address majority of enterprises' need	Rating out of 5
Declare record in-place manually	Option to mark a sharepoint document as record manually to prevent further changes and deletion	NA	5
Declare records by manually moving it to record center	The “send to Record Center” option to manually declare records and send them to the RecordCenter is located in Compliance Details overlay. It would be better if its available in the ribbon / pull down menu to make it more usable.	Custom command in ribbon to trigger "send to record center" action	4.5
Declare records automatically based on rule	Process to define rules that mark a sharepoint document as record to prevent further changes and deletion	NA	5
Retain records and their associated metadata for their retention time period	Whenever user changes the metadata of a record in Record Center, system is not synchronizing the metadata changes to the record link which is located in the document center.	Custom component to i. Prevent metadata updation of a record link ii. Propagate metadata changes to record links in document center, whenever metadata values of the linked record has been changed	4
Ensure Record integrity throughout their retention time period	Only Selected metadata fields should be editable. metadata column edit permissions should be based on the user role / state of record matrix	Custom feature to restrict updation of critical metadata / record content by applying field level locking based on the following parameters i. Permission Level of the user ii. Stage of document (record, hold)	0
Dispose records in accordance with the Records Retention Schedule	Retention and disposition process of out-of-the-box SharePoint 2010 executes on individual items. The high volume of records for disposition will cause a critical usability issue of managing disposition of individual items. It is recommended to have a batch disposition option. Out-of-the-box SharePoint terminates the expiration process whenever user cancels disposition approval request. It is recommended to have a “Cancelled Records Repository” to restart “disposition of rejected records” / put them on hold / assign a different content type. A workflow to redirect records to record library / document library on an event of cancelled item metadata updation is recommended.	Custom disposition process with the following high level functionalities i. Disposition schedules should run on scheduled intervals (monthly, quarterly, yearly) ii. Records/documents of sub site (project or dept) should be batched together and send for disposition approval iii. Record Stewards should be able to pick and choose items from the list and approve disposition. iv. Record Stewards should also able to apply hold, and change metadata to items by specifying valid remarks. These disposition cancelled records will be sent to Record Administrator for approval v. The Record Administrator should be able to review the disposition of cancelled records and apply the changes suggested by the Record Steward / himself. When Record Administrator approves the changes obtained through disposition cancellation, record should move to Record Center or document center.	1.5
Discover Records for hold and apply hold in batch	The following changes in eDiscovery for Hold are recommended: i. Search refinement with advanced search feature to find actual record set for hold ii. Pick and choose option from the search results Every legal hold search should find the documents and links to records. On applying hold to record links, it should apply hold to the linked records. The following advanced options to streamline the hold process in batch are recommended: i. Apply hold to multiple records after selecting them from a list. ii. Applying hold to a library / folder	Advanced Search functionality to search records to apply hold. Custom solution to apply hold only for those records chosen from the search results. Custom solution to Select multiple records from a library and apply hold. Provision to apply hold on all records/documents of a specific library or folder The eDiscovery search in Document Center should find documents and links to record along with in-place records.	3
Apply legal Hold to a Record manually	Option to hold a record from further processing and change	NA	5
Release legal Hold from a Record manually	Option to release hold a record to allow further processing and change	Component to apply hold to the linked record on applying hold in record link.	1.5
Release legal Hold from set of Records	“Search and Release Hold” option should be available which would enable user to release hold by selecting records from search result	Advanced Search functionality to search records on hold. Custom solution to release hold only for those items chosen from the hold search results. Component to Select multiple records from a library and release hold. Component to release hold from the linked record on releasing hold from a record link	1.5
Delete an in place record / record in record center / record link/ record on hold	Since SharePoint considers a link to a record as an independent entity, users with “contribute” access can delete record links. This action should be restricted to Administrators to ensure accessibility.	Custom feature to prevent record link deletion	3.5
Move an in place record / record in record center / record link/ record on hold	Since SharePoint considers a link to a record as an independent entity, users with “contribute access” can move / edit a record link. This action should be limited to Record Administrators (to make it consistent with Record Center). Also, the system should prevent metadata changes of record link in Document Center. The ability to move documents on hold should be restricted to Record Administrators.	Custom feature to restrict record link and hold records movement.	1
Create a new version of an in place record / record in record center / record link/ record on hold	SharePoint allows users with “contribute access” to edit all metadata fields. However, only selected metadata fields should be editable based on the logged-in user’s role and status of the record. Updation of metadata (like dates) should recalculate the information management processing dates.	Custom feature to restrict updation of critical metadata / record content by applying field level locking based on the following parameters i. Permission Level of the user ii. Stage of document (record, hold)	0
Upload a new version of an in place record / record in record center / record link/ record on hold	SharePoint allows users with “contribute access” to replace both in-place records and record links with a new version. This should not be allowed.	Custom feature to prevent in place, record link updation with a new version of document. Custom component to i. Prevent metadata updation of a record link Propagate metadata changes to record links in document center, whenever metadata values of the linked record have been changed.	0
Modify an in place record / record in record center / record link/ record on hold metadata	SharePoint allows users with “contribute access” to edit all metadata fields. However, only selected metadata fields should be editable based on the logged-in user’s role and status of the record. Updation of metadata (like dates) should recalculate the information management processing dates.	Custom feature to restrict updation of critical metadata / record content by applying field level locking based on the following parameters i. Permission Level of the user Stage of document (record, hold)	0
Email an in place record / record in record center / record link/ record on hold	When we send link to record by attaching it with an email, it should attach the actual record, not the link file.	Custom feature that attaches record with an e-mail when user tries to send a link to record from document center.	4
Apply information management policies	Allow information management policies to process metadata and perform associated actions including record declaration	NA	5
Apply information security by setting up permissions for the library	For certain record types, System must ensure item level permission setting on upload	Custom code component to apply item level permission while uploading a document.	4.5
Generate File Plan Report	SharePoint 2010s out-of-the-box file plan report is not sufficient to address user needs. A custom implementation to display hierarchical report of taxonomy with record retention details is recommended.	Custom Hierarchical file plan report that displays: i. Site information organization (Site Collections>Sites>Libraries>Folders>Content Type) ii. Record retention details (Libraries>Content Types)	1
Generate Records Audit Report	Out of the box report neither satisfy specify user requirements nor compliant with data sensitivity guideline. Requires custom code components on top of the log data to make it usable.	Custom audit log report that can perform search SharePoint audit log data and present info related to: i. User actions ii. Action during a period iii. Specific actions (like delete) iv. Failed attempts [optional]"	1
Find a record	It is recommended to use FAST 2010 for search integration.	Custom options to distinguish records, information on hold within search results.	3.5
Find an in place record / record in record center / record link/ record on hold	Search results do not distinguish in-place records from documents. There should be some mechanism to distinguish type of documents and records.	Option to filter search results based on the type of item (document / in-place record / hold / record link).	3.5

Bottomline: SharePoint 2010 records management policies would be suited for a small enterprise with a limited number of record types and less repositories and have a straight forward business process to manage info.

Manage Structured and Unstructured Data - SharePoint 2010 way - Part 1

2012-08-03T05:32:00.000-07:00

Now a day’s majority of enterprises business processes and functions are facilitated or supported by the use of electronic systems. Many of these systems create, manage and/or store electronic data that is identified as either “structured” or “unstructured”.

“Structured data” typically is created and stored according to a pre-defined data model and fits into relational tables, or can be stored in rows and columns. By comparison, “unstructured data” has minimal identifiable structure, and may include e-mail files, word-processing text documents, PowerPoint presentations, JPEG and GIF image files, and MPEG video files.

Unstructured data may be stored in collaborative environments, in document management systems, on file shares, etc. The management of unstructured data poses a significant challenge to most organizations today, since it relies heavily on individual user management and falls outside the purview of the traditional IT System information management model. Most unstructured content is created in an ad hoc fashion by individual business users, with little consistency in creation, naming, storing, disposing, etc. If left unmanaged, the sheer volume of unstructured data that is generated each year within an enterprise can be costly in terms of storage. In addition to these “hard dollar” costs, significant inefficiencies result from ineffective use of knowledge worker time when searching and finding needed information, and then (hopefully) classifying that information.

Unmanaged data can also pose a liability if information cannot be located in the event of an audit, investigation or litigation. There is further risk related to records and information that should have been disposed of in accordance with retention policy, but continues to be retained.

Im starting a series of posts around SharePoint 2010's capabilities to manage structured /unstructured data .... more to follow....

Update created by column of a list item with a value using event handler

2012-08-01T20:36:00.000-07:00

We tried several options to update created by column of a list item with a value using event handler
We found the way to do it .... Its below

public override void ItemAdded(SPItemEventProperties properties)
{
base.ItemAdded(properties);
ChangeCreatedBy(properties);
}
private void ChangeCreatedBy(SPItemEventProperties properties)
{
string strAuthor = @"domain\first.last";
try
{
Guid siteID = properties.ListItem.ParentList.ParentWeb.Site.ID;
Guid webID = properties.ListItem.ParentList.ParentWeb.ID;
Guid listID = properties.ListItem.ParentList.ID;
Guid newItemID = properties.ListItem.UniqueId;
SPSecurity.RunWithElevatedPrivileges(delegate() {
using (SPSite site = new SPSite(siteID))
{
using (SPWeb web = site.OpenWeb(webID))
{
SPUser usrAuthor = web.EnsureUser(strAuthor);
SPList questionList = web.Lists[listID];
SPListItem listItem = questionList.Items[newItemID];
listItem["Author"] = usrAuthor ;
listItem.SystemUpdate(false);
}
}
});
}
catch (Exception ex)
{
//call log error routine
}
}

Disable Publish button using Javascript

2012-07-30T20:27:00.001-07:00

I wont suggest you to use the following approach to disable Publish button of a NewItem.aspx page. The suggested approach is to configure security by excluding "Approve Items" permission for a permission level and assign it to SharePoint Group.

I agree that wont be the case every time - MyTeam faced same challenge today where we had a specific requirement to disable publish option from NewItem Page. Here is the quick and easy way to do it.

1. Save the following script in a .js file

<script language = "javascript">

varButtonClassName ="ms-ButtonHeightWidth"

varButtonClassName = new RegExp("(^|\\s)" + varButtonClassName + "(\\s|$)") ;

varRibbonClassName ="ms-cui-ctl-large"

varRibbonClassName = new RegExp("(^|\\s)" + varRibbonClassName + "(\\s|$)") ;

varPublishText = "Publish"

varPublishText = new RegExp("(^|\\s)" + varPublishText + "(\\s|$)") ;

elements = document.getElementsByTagName("*");

for (var l=0, ll=elements.length; l<ll;l+=1)

{

node = elements[l];

if(varButtonClassName.test(node.className))

{ if(varPublishText.test(node.value)) node.disabled = true; } if(varRibbonClassName.test(node.className))

{ if(varPublishText.test(node.value)) node.disabled = true; }

}

</script>

2. Upload the .js file into a library in the site
3. Edit NewItem.aspx from SharePoint UI and add a Content Editor Web Part below the data entry web part
4. Edit the web part and refer the uploaded .js file to it
5. Save web part properties
6. Exit page edit
7. Refresh the page ......... See the magic :)

Update created by column using powershell

2012-07-29T21:46:00.002-07:00

Was busy in implementing a test site - my BA asked whether we can show the CEO's name instead of her name in the created by column of all items in a list.

$SPSite = New-Object Microsoft.SharePoint.SPSite("<site collection url>")
$SPWeb = $SPSite.AllWebs["<site name>"]
$SPList = $SPWeb.Lists["<List Name>"]
$SPListItemCollection = $SPList.Items
$targetUser =$SPWeb.EnsureUser(“<user Windows ID>”)
foreach ($ListItem in $SPListItemCollection)
{
$ListItem["Author"] = $targetUser
$ListItem.ModerationInformation.Status = "Approved"
$ListItem.Update()
}
$SPWeb.Update()

Worked like a gem .... BA happy, CEO tooo :)

Development options in SharePoint 2013

2012-07-26T06:11:00.000-07:00

Looks like there are couple of new things introduced in SP2013 for development. On a high level the following are the development options available

SharePoint Apps
Mobile Apps
Reusable components
Classic farm solutions
Publishing sites

SharePoint Apps: Like ITunes apps, Android apps - SharePoint also introduce a new development option to develop stand alone solution having less features bundled together, installs/uninstalls easily. The new feature called corporate app catalogue would be the enterprise wide repository for apps and privileged information workers will be able to find and use it in their sharepoint sites. Per Microsoft Apps never runs on SharePoint servers - its logic always stays in cloud. Will share more details soon. I believe the components like lists, content types, custom pages, web parts, workflow will be right fit for apps.see my related post on app culture
Mobile Apps : SP2013 introduce a client API for Windows phones, it can access SharePoint web sites and data. androids, i phones can use REST/OData end points for the same.
Reusable components : Microsoft claims VS2012 and SP2013 together can help developers to encapsulate and reuse app elements like code, script, markups etc.
Classic farm solution : Same old WSP based solutions that utilizes server object model code to perform admin tasks like timer jobs.
Publishing Sites: SharePoint publishing sites provide large-scale content publishing with a high degree of maintainability and regulation compliance. They also provide management of documents, records, taxonomy, and content types.

More to follow...

Query that retrieve User Profile properties of a specific SharePoint 2010 user

2012-07-24T21:58:00.001-07:00

Have you ever thought of a query that retrieve User Profile properties of a specific SharePoint 2010 user?

I have been searching for this guy for long ... today I found it.

SELECT userprof.NTName, proplist.PropertyName, usrprofval.PropertyVal
FROM [<<ProfileDB>>].[dbo].[UserProfile_Full] userprof WITH(NOLOCK)
JOIN [<<ProfileDB>>].[dbo].[userProfileValue] usrprofval
ON usrprofval.RecordID = userprof.RecordID
JOIN [<<ProfileDB>>].[dbo].[PropertyList] proplist
ON proplist.PropertyID = usrprofval.PropertyID
WHERE userprof .NTName = '<<windowsID>>'

Note: Reading from the SharePoint databases programmatically, or manually, can cause unexpected locking within Microsoft SQL Server which can adversely affect performance.

How SharePoint 2013 preview different from SP2010

2012-07-23T20:51:00.000-07:00

This is the first in my series of blogs that compares new SP2013 preview with SP2010

Web Analytics in SP2010 is discontinued and Analytical Processing for SharePoint 2013 is part of Search Service. Microsoft claims Scalability and performance improvements in its new avatar. Analytics processing component in SP2013 runs analytics jobs to analyze content in the search index and user actions. Looks like the analytics feature is more integrated with search features than an independent entity the way it is in SP2010. The other disappointing thing is the SP2010 analytics info like browser traffic, top users of a site, referring URL, quota usage analytics wont be available.
Visual Upgrade is NOT available; replaced with much more comprehensive upgrade process called deferred site collection upgrade. Visual upgrade was limited to old master pages, css and html files but the new deferred site collection process the additional areas including SPFeature. There is no direct migration path from MOSS 2007 to SP2013. The Moss2007 site must move to SP2010 before upgrading to SP2013. Another thing the upgrade to SP2013 is irreversible. Due to All these constraints - Im doubtful about the success of this change.
As part of simplifying the site template selection process, the following changes have been introduced

Document Workspace site template has been replaced by the Team Site site template
All 5 Meeting Workspace site templates are not available. This looks like a strategic move to promote other Microsoft products like Lync (to conduct online meeting), OneNote (to capture Meeting notes), Team Site / MySites (to share meeting minutes etc). Microsoft annouces the existing site will work till a major version release.
Personalization Site, Group Work Site, Visio Process Repository site templates have been removed because of less usage in SP2010. Microsoft annouces the existing site will work till a major version release.

Because of a design limitation - workbooks with external data connections that use Windows Auth cannot be refreshed in browser; you will be asked to open in excel client.
Due to less usage , to reduce security issues and to simplify number of ways to connect SharePoint - The imaging web service for creating and managing picture libraries would be removed from next major release.

More to follow...

sharepoint 2013 - databases behind the scenes

2012-07-22T18:57:00.001-07:00

We all know - how the SQL server databases are related to SharePoint products and technologies. On releasing the SharePoint 2013 preview – let me try to create a ready reckoner for SharePoint databases

DB Category	DB Name	DB Name Syntax	Description
System DBs (Core DB)	Configuration	SharePoint_Config	Stores details about other SharePoint DBs, IIS web sites, web apps, trusted solutions, site templates and web app/farm settings. Only one DB supported per farm
	Central Admin Content	SharePoint_AdminContent_<GUID>	Centtral admin site's content database. Only one DB supported per farm.
	Content	WSS_Content_<GUID>	Stores all site content (list data, docs, web part properties, audit logs, user names, rights etc.) Can contain more than one site collection data. MS recomends the size to limit 200GB to ensure perfoemance. But can support upto 1TB if it’s a low IO system like Record Center. Scale out to multiple DBs for a web app.
User Profile DBs	Profile	<UPSA>_ProfileDB_<GUID>	Stores and manages users and their social information
	Synchronization	<UPSA>_SyncDB_<GUID>	Stores user profile configuration and staging data for use when profile data is syncd with directory services.
	Social Tagging	<UPSA>_SocialDB_<GUID>	Stores social tags and notes created by users along with their URLs.
Search Service DBs	Search Admin	<SSA>_DB_<GUID>	Stores search application configuration and ACL for crawl component.
	Analytics Reporting	<SSA>_Analytics ReportingStoreDB_<GUID>	Stores the results for usage analysis reports and extracts info from link DB.
	Crawl	<SSA>_CrawlStoreDB_<GUID>	Stores the state of crawled data and crawl history MS suggests add additional crawl DB per 10 mil items
	Link	<SSA>_LinkStoreDB_<GUID>	Stores the info ie extracted by content processing component and click through info. Growth: 1GB per 1mil docs ; 1GB per 1mil queries
Other Service App DBs	App License Management	AppMng_Service_DB_<GUID>	Stores the ap licenses and permissions that are downloaded from the Global Marketplace
	Secure Store Service	Secure_Store_Service_DB_<GUID>	Stores and maps credentials such as accounts and password
	Usage	WSS_Logging	Stores health monitoring and usage data temporaitly. It also used for reporting and diagnostics. One usage DB per farm
	Word Conversion	WordConversion_<GUID>	Stores information about pending and completed document conversion
	Subscription Settings Service	SubscriptionSettings_<GUID>	Stores features and settings information for hosted customers.
sp 2013 (STD/ENT) Service App DBs	Word Automation Services	WordAutomationServices_<GUID>	Stores information about pending and completed document conversion
	Business data Connectivity	BDC_Service_DB_<GUID>	Stores external content types and relate objects
	Managed Metadata Service	<MMS>_<GUID>	Stores managed metadata and syndicated content types
	Machine Translation Services	TranslationService_<GUID>	Stores info about pending and completed batch document translations
sp 2013 ENT Service App DBs	Project Server	<Project web App Content DB>	Store project and portfolio management data, time related data etc
	PowerPivot Service App	<PPSA>_<GUID>	Stores data refresh schedules and PowerPivot usage. This requires SQLServer 2012 analytical services (BI / ENT edition)
	Taxonomy	<MMS>_<GUID>	Taxonomy related info
	Performance Point Services	<PerfPointSA>_<GUID>	Stores temporary objects and persisted user comments and settings
	State Service	<SS>_<GUID>	Stores temporary state info for inforpath forms services

Hope this helps J

Is SharePoint moving towards an App culture?

2012-07-18T05:02:00.000-07:00

We are in a world of apps - yes you guessed it right Im talking about the stuff like Android apps , Iphone apps etc. After reading SharePoint 13 preview in Technet - I think SharePoint is also moving towards the App culture..

Architects/Developers like me have been building server-side farm solutions that extend core SharePoint capabilities right from SharePoint 2003 (Im not sure wht was there prior to SPS2003). New SharePoint offers a new flexible development model that creates apps for SharePoint that take advantage of standard web technologies like JavaScript, OAuth, and OData.

I believe the new app for SharePoint development model will extend the ability to build apps that take advantage of SharePoint capabilities and that run in the cloud instead of on our SharePoint farm. This flexible development model, along with the integration of standard web technologies, makes SharePoint development work more like other kinds of web development that we are already be doing. This change in philosophy would help the enterprises and users to discover, purchase and install sharepoint solutions quick and easy. The group benefited most out of this approach change is the solution providers who can simplify market and sell their solutions thru an app store - not necessarily Microsoft app store.
SharePoint Apps going to use the SharePoint client side techniques or REST to access SP entities and data. App for sharepoint cannot contain custom code that runs on Server and cannot call server object model APIs. In a nutshell App are for end users not for Admins.

The related major change we are seeing in SP13 preview is - deprecation of Sand-boxed solution (introduced in SP2010 - it was helping the site collection admins to manage solution of their own without touching farm servers)..

Whats there in new SharePoint

2012-07-17T07:18:00.000-07:00

I was pretty excited to see latest version release of office suite 2013 along with new version of SharePoint.

Its catch word says SharePoint Server 15 enhances the workload experiences by enabling new compelling scenarios that engage and work with the user.

Had a quick look at Technet site and came to knew that the platform stays the same but few new things introduced....

Let me share few thing real quick

There are few platform level improvements and new capabilities

Shredded Storage
SQL Improvements
Cache Service
Request Management
Themes
Sharing

Content Management

Site-level retention policies was a pain point when we did Records Management for one of the Pharma major in SharePoint 2010 . Now the compliance levels extended to sites
The new policies include - Retention policy for sites and Team Mailbox associated with site
This feature could help us the common business functions like Project closure and site level expiration policy
The discovery and legal hold feature were primitive in SP2010 – Microsoft claims there is exponential improvement in this area. Can’t wait to know it …

Looks like there are handful of changes in Service applications

(I’m yet to explore more details) there are New service applications available and improvements on existing ones
Office Web Apps is no longer a service application
Web Analytics is moved to part of search

I will detail more about customization, architecture in the upcoming posts