Purushotam's Technology Blog

Updated Resume..

purushotam — Tue, 16 Sep 2008 19:36:00 +0100

How to elevate Permissions for using Sharepoint Object model

purushotam — Sat, 05 Jul 2008 20:16:00 +0100

Many of the operations you perform with the object model—even a simple listing—will require administrative permissions. This is because SharePoint applies security restrictions to the use of the object model. However, there are many times when you would like to display information—such as a site listing—to a user that does not have administrator rights. In these cases, you must utilize the SPSecurity class to temporarily run object model code with elevated permissions. These elevated permissions allow you to run code under the identity of the application pool account.
In order to run code with elevated permissions, you must encapsulate the code in a function that has no return value. You then create an instance of the CodeToRunElevated class using the name of the function as an argument. You can subsequently execute the code by calling the RunWithElevatedPrivileges method of the SPSecurity object and passing in the CodeToRunElevated object. Below shown is an example that calls a method to list all of the available features in a farm.

<%@ Page Language="C#" MasterPageFile="~/_layouts/application.master"%>
<%@ Assembly Name="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71E9BCE111E9429C" %>
<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Import Namespace="Microsoft.SharePoint.WebControls" %>
<asp:Content ID="Content4" runat="server"
ContentPlaceHolderID="PlaceHolderMain">
<%
SPSecurity.CodeToRunElevated myCode =
new SPSecurity.CodeToRunElevated(ShowFeatures);
SPSecurity.RunWithElevatedPrivileges(myCode);
%>
</asp:Content>
<script language="C#" runat="server">
protected void ShowFeatures()
{
//Code goes here
}
</script>

How to create Simple Workflow in Sharepoint

purushotam — Wed, 02 Jul 2008 19:46:00 +0100

In my last posting, i briefed about basics of Workflow in sharepoint and in this posting, we will take close look at implementation of it.

To start with I will create a simple example workflow using SharePoint Designer. I am going to create a workflow for an imaginary company’s Human Resources department. They have placed an advertisement for a new C# developer and they expect a lot of letters and resumes. The CTO wants to read these letters and approve or decline them. If a letter is approved, the candidate will be invited for an interview. In this example, I am going to create the first part of the process: namely, a document (the letter from the candidate) will be uploaded to a document library called LettersCandidates. This document library will contain two columns: Assigned to and Status. The custom column Assigned to will contain three values: CTO, CEO, and CFO. When a document is uploaded to the document library and assigned to the CTO, the CTO will receive a new task in this Tasks list asking whether he approves or declines the document. The second custom column, Status, contains the following values: prospect, 1st interview, 2nd interview, declined, and hired.

Follow these steps to create a new document library called LettersCandidates and a new column:
1. Open a SharePoint site where you want to create a new document library.
2. Click the View All Site Content link on the left of the SharePoint site. This opens the All Site
Content page.
3. Click Create. This opens the Create page.
4. Click Document Library in the Libraries section.
5. Name the document library LettersCandidates and click Create.
6. Select Settings in the LettersCandidates document library and click Create Column.

7. Name the column Status, check the Choice radio button, and enter the values: prospect, 1st
interview, 2nd interview, declined, and hired. Click OK.
8. Click Create Column.
9. Name the column Assigned to, check the Choice radio button, and enter the values: CTO,
CEO, and CFO. Click OK.

After setting up the LettersCandidates document library and adding a column, you are ready to open the SharePoint site in SharePoint Designer. The next thing to do is to start designing the example workflow. Follow these steps to create the workflow.

1. Open the SharePoint site containing the LettersCandidates document library in SharePoint Designer.
2. In the File menu, click New and select Workflow. This opens the Workflow Designer wizard.
3. In the Give a name to this workflow text box, specify the following name: Candidates Notification WF.
4. In the What SharePoint list should this workflow be attached to drop-down list, select the LettersCandidates document library.
5. In the Select workflow start options for items in LettersCandidates section, do the following.

Uncheck the Allow this workflow to be manually started from an item check box. Check the Automatically start this workflow when an item is created check box and uncheck the Automatically start this workflow when an item is changed check box. This way the workflow will run each time an item is created. Following figure shows the first page of the Workflow Designer wizard.

6. Click Next.
7. In the Step Name text box, specify the following name: AssignTaskStep.
8. Click the Conditions drop-down list and select Compare LettersCandidates Field. The condition if field equals value is inserted, where field and value are the parameters that must be filled in.
9. Click the field parameter and select the Assigned to column. The field parameter shows a drop-down list filled with the specified document library’s metadata.
10. Click the value parameter and select the CTO value. The value parameter shows a dropdown list filled with the values from the specified column. Figure 4-9 shows the value parameter’s drop-down list.

11. Click the Actions drop-down list and select Collect data from a user (output to variable:collect1). The action Collect data from this user is inserted, where data and this user are parameters that must be filled in. The parameter variable:collect1 will be where we save the data that is collected from the user.
12. Click data. This opens the Custom Task wizard. Click Next.
13. In the Name text box, specify the following name: ApprovalCTO. Click Next.
14. Click the Add button to define a custom task field that the user can fill out. This opens the Add Field dialog box.
15. In the Field name text box, specify the following name: DecisionCTO. In the Information type drop-down list, choose choice (menu to choose from). Click Next.
16. In the Choices list, enter the following two choices: Approve, Decline.
17. Uncheck the Allow fill-in choices check box. Click Finish twice.
18. Click this user. This opens the Select Users dialog box. Select a user from the list of users, click Add, and click OK. Figure below shows the AssignTaskStep workflow step.

19. Click Add workflow step. This adds a new workflow step to the workflow.

20. In the Step Name text box, specify the following name: ChangeStatus.
21. Click the Conditions drop-down list and select Compare any data source. The condition if value equals value is inserted, where value and value are the parameters that must be filled in.
22. Click the display data binding icon next to the first value parameter. This opens the Define Workflow Lookup window. The Source drop-down list shows the SharePoint site’s available lists. The Field drop-down list shows all fields available in the specified list. In the Source drop-down list, select Tasks. In the Field drop-down list, select DecisionCTO. In the Value drop-down list, select Approve, as shown in Figure here..

23. Click OK.
24. Click the Actions drop-down list and select Set Field in Current Item. The action Set field to value is inserted, where field and value are parameters that must be filled in. Click the field parameter and select the Status value. The field parameter shows a drop-down list filled with the specified document library’s metadata.
25. Click the value parameter and select 1st interview. The value parameter shows a dropdown list filled with the values from the specified column. Below figure shows you the ChangeStatus workflow step.

26. Click the Check Workflow button to check whether your workflow contains any errors.
27. Click Finish. The workflow is validated and associated with the document library. The next set of figures walks you through the example workflow in a SharePoint site. Figure below shows you a letter from Candidate A in the LettersCandidates document library. The Candidates Notification Workflow is in progress.

The workflow will assign a task to the CTO. This task will also be send as an e-mail to the CTO. The task can be edited and the CTO can approve or decline the document. This is shown in Figure.

After the CTO has approved or declined the document, the status of the document will change. Take a look at figure..

....usssshhh... i think you might be tired by this time. take some rest or even a nap could be better and move on...

let me see what i can do for next posting... until then bye..

Basics of Windows Workflow Foundation

purushotam — Sat, 28 Jun 2008 17:16:00 +0100

SharePoint 2007 incorporates an infrastructure that supports the use of existing document-centric workflows as well as the creation of new document-centric workflows by either developers or information workers.

Windows Workflow Foundation (WF) forms the basis of the SharePoint 2007 workflow functionality. Windows Workflow Foundation is a part of the Microsoft .NET Framework 3.0.

Note: The Microsoft .NET Framework 3.0 was formerly known as WinFX. It adds four new technologies to the
.NET Framework 2.0: Windows Workflow Foundation, Windows Communication Foundation (WCF, formerly known
as Indigo), Windows Presentation Foundation (WPF, formerly known as Avalon), and Windows Cardspace (WCF,
formerly known as InfoCard).

Windows Workflow Foundation is not a stand-alone application; instead, it has a run-time workflow engine that can execute short-term as well as persistable workflows. The Windows Workflow Foundation run time provides additional services that are important for executing workflows such as tracking, notifications, and transactions.
Any application or service can leverage WF workflow services by hosting WF in its process. SharePoint 2007 acts as a host for WF and adds a couple of custom implementations for workflow services as well.

SharePoint 2007 offers two different tools for working with and creating workflows: SharePoint Designer 2007 and Visual Studio 2005 Designer. Both will be discussed in this chapter. SharePoint Designer 2007 is a great tool for creating ad hoc workflows. It places the tools to create workflows well within the grasp of normal information workers. Visual Studio 2005 Designer, on the other hand, allows developers to create advanced, enterprise-level workflows.

Note Actually, you can associate a workflow created in SharePoint Designer with more than one list. The
auto-generated code contains hard-coded GUIDs representing a list. If you change those GUIDs, it is possible to
associate a workflow with another list.

In the following sections, we will delve deeper into the concepts related to Windows Workflow Foundation.
Activities
I will begin by looking at the basic structure of a workflow. A workflow represents a business process that consists of a set of transactions which form a model to describe a real-world problem. Business transactions form the elementary building blocks of a business process. A business transaction involves two parties:

• The initiator is responsible for starting a business transaction by issuing some sort of
request.
• The executor is responsible for performing some kind of action based on a request.

Conceptually, the life cycle of a business transaction consists of three phases:
1. Order phase: This phase starts when the initiator makes a request for some kind of action to
be performed. This phase ends with a promise by the executor to perform that action.
2. Execution phase: In this phase, the executor performs the requested action. The action succeeds
or fails. Either way, a result is reached, thus ending this phase of the business transaction
life cycle.
3. Result phase: In this phase, the executor communicates which result was reached, which is
either accepted or rejected by the initiator.
In Windows Workflow Foundation, the abstract concept of business transactions (a concept that has meaning in the external world) is translated to activities (a concept that has meaning in the software world). Activities are the building blocks of a workflow; every single step within a workflow requires an activity. Windows Workflow Foundation utilizes three different kinds of activities:
• Simple activity: A simple activity represents a simple action in its most basic form. An example of such a simple activity is the DelayActivity.
• Composite activity: A composite activity is an activity that aggregates one or more child activities within a single activity. An example of such a composite activity is the IfElse activity.
• Rule activity: A rule activity (also called a data-driven activity) drives the flow of a workflow. An example of this type of activity is the EventDriven activity.

Out of the box, the Windows Workflow Foundation framework contains a set of activities that provide functionality for the creation of workflows that contain control flow, conditions, event handling, and state management, and are able to communicate with other applications and services.

If you design a workflow, you can choose to make use of one of the activities belonging to this default set or you can create your own activities. Developers are free to create their own custom activity libraries and use them in other workflows. You can also use code activities to add custom code to a workflow. Code activities allow you to add basic behavior to a workflow; if you want complex behavior, such as the ability to create a composite activity that is able to contain other activities, you should create your own custom activity.

Activities can be sequential, in which case the order of workflow actions is specified at design time. Alternatively, activities can be event-driven. In such scenarios, the order of workflow actions is determined at run time in response to external events. Each activity contains the following logic/data:

• Metadata responsible for describing design time properties of the activity.
• Instance data describing the activity run-time state.
• Activity behavior in the form of programmed execution logic.
• Validation logic that can be used to validate activity metadata. This is optional.

Following figure shows a basic workflow that consists of several activities and uses custom activity libraries.

Components
Windows Workflow Foundation provides services as well as a framework and consists of the following
components (see Figure):
• Base activity library: This library contains all activities that are available out of the box.
Activities are essential building blocks for creating custom workflows and are discussed in the previous section, “Activities.”
• Runtime engine: The workflow runtime engine is able to interpret and execute workflows created using Windows Workflow Foundation. The runtime engine is also responsible for keeping track of workflow state.
• Runtime services: The WF workflow runtime engine can be hosted by different host applications, including SharePoint. This is a very flexible system, which is made possible via the workflow runtime services. The workflow runtime services are also responsible for handling any communication between the host application and the workflow.

Windows Workflow Foundation ships with a couple important tools that facilitate workflow creation: a visual designer and a debugger.
The workflow runtime engine is hosted in-process within a host application (never as a stand-alone process) and is responsible for creating and maintaining running workflow instances. For each application domain (in .NET, the fundamental process that executes code), there can be only one workflow runtime engine. A workflow runtime engine is able to run multiple workflow
instances concurrently. The runtime engine needs to be hosted by a host process, such as a console application, Windows form-based application, ASP.NET web site, or a web service. Because a workflow is hosted in-process, it can easily and efficiently communicate with its host application.

The workflow runtime engine utilizes many WF services when a workflow instance runs. The following services are included in the runtime engine:

• Execution
• Tracking
• State management
• Scheduler
• Rules

Besides the runtime engine itself, WF contains multiple runtime services. Runtime services are pluggable, so applications can provide these services in unique ways within their execution environment.

Workflow Styles
Windows Workflow Foundation supports two styles of workflow: sequential and state machine. Before you start creating a workflow project, it is important to figure out what style of workflow you want to use.

The sequential workflow style is used for repetitive operations such as designing a set of activities that must always be performed in the same order. The workflow follows the sequence until the last activity is completed, and the workflow always remains in control of what happens next.

Such workflows are not necessarily entirely deterministic; you can use branching logic such as IfElseActivity activities or ParallelActivity activities and let the exact sequence of events vary.
For example, imagine you are creating a workflow that describes the process of installing software. This is a typical scenario where you always follow the steps one by one and in the same order.
Therefore, you can represent this process using a sequential workflow. The following figure shows an example.

The state machine workflow style is used when you want to model your workflow as a state machine. State machine workflows are made up of different states, one being the starting state, which is the state that is entered once the workflow process begins. Each state can receive a certain set of events. Based on these events, the workflow can transition from one state to another
state. In state machine workflows, the end user is always in control. That is why this type of workflow is also known as a human-oriented workflow. It is not required to define a final state, but if you do happen to have a final state in a workflow and the transition is made to that state, the workflow will end.

An example of a state machine workflow is an online shop where one state of the workflow process describes the situation where the customer can submit an order and wait for approval of the credit card data. Another state in the workflow process describes the situation where the customer, for the time being, is satisfied with selecting a couple of products and wants to place
the order at a later time. Therefore, each customer finds himself in one of the states in the workflow process and goes to another state depending on his choices.

The following Figure shows a statemachine workflow.

Although you certainly can, you do not have to rush out and start creating your own workflows immediately, because, out of the box, SharePoint 2007 ships with a set of default workflows. They are..

Approval :

This is probably the most basic and often-used workflows you can imagine. You can submit a document for approval; approvers can accept or reject a document or request changes.

Collect Feedback:

Gathers feedback information from a group of reviewers.

Collect Signatures:

Collects signatures from a group of approvers and requires the use of Microsoft Office clients.

Disposition Approval:

Centered on document expiration and retention.

Group Approval:

An advanced version of the Approval workflow.

Issue Tracking:

Dedicated to an issue process involving tasks, task assignments, and task completion.

Translation Management:

Facilitates a translation process involving documents, tasks, and translators.

Three-state:

Tracks the status of an item through three states.

In my next posting, we will take a close look at implementing workflow in sharepoint.

Using SPUserToken in Sharepoint (aka Impersonation in Sharepoint)

purushotam — Sun, 22 Jun 2008 23:13:00 +0100

If you want to impersonate another user account to interact with the SharePoint object model, you can use the SPUserToken object. In Microsoft Office SharePoint Server 2007, several constructors of SPSite objects accept an SPUserToken object as one of the parameters to establish a different security context.

To demonstrate the use of the SPUserToken object, I will programmatically check out a file on behalf of a different user. We have created a test document called Test.doc and uploaded it to the Shared Documents document library (as shown in fig below). Make sure that versioning is enabled on the Shared Documents document library. Later in this section, we will use the version history of this
document to check whether the code involving the SPUserToken object has succeeded.

In the next example, I will programmatically check out and then check in a document. I have created a web part called SuperPart that is responsible for doing this. The code retrieves the current site collection from the current SharePoint context and gets the PrivilegesTest SharePoint site from this site collection. By default, you are not allowed to check out and check in files in SharePoint using HTTP GET requests. To get around that, my code sample allows unsafe updates on the PrivilegesTest SharePoint site. An instance of SPFile associated with the test document can be retrieved from the PrivilegesTest SPWeb instance. Finally, the code adds some information to the test document’s versioning comment. The code responsible for checking out and checking in the
test document looks like this (it will be added to the Load event of a web part shortly):

SPSite objSite = SPControl.GetContextSite(Context);
SPWeb objWeb = objSite.AllWebs[“PrivilegesTest”];
objWeb.AllowUnsafeUpdates = true;
SPFile objFile = objWeb.GetFile(“Shared Documents/Test.doc”);
objFile.CheckOut();
SPUser objUser = objFile.CheckedOutBy;
objFile.CheckIn(“check-in version: “ + objFile.UIVersion + å
“ by “ + objUser.Name);

The complete code looks like this...
using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
namespace KwikSliver.ImpersonationAndElevationDemo
{
[Guid(“47500629-54d5-4ac4-ac44-097b4ce2e3eb”)]
public class SuperPart : System.Web.UI.WebControls.WebParts.WebPart
{
public SuperPart()
{
this.ExportMode = WebPartExportMode.All;
}
protected override void OnLoad(EventArgs e)
{
SPSite objSite = SPControl.GetContextSite(Context);
SPWeb objWeb = objSite.AllWebs[“PrivilegesTest”];
objWeb.AllowUnsafeUpdates = true;
SPFile objFile = objWeb.GetFile(“Shared Documents/Test.doc”);
objFile.CheckOut();
SPUser objUser = objFile.CheckedOutBy;
objFile.CheckIn(“check-in version: “ + objFile.UIVersion + “ by “ +
objUser.Name);
}
}
}

In this example, I first navigated to a page containing the SuperPart web part while logged in as user SuperB. This caused the SuperPart web part to load and execute, which checked out and then checked in a document in a document library under the SuperB system account. Then, I logged in as user NormalA and went back to the same page, causing the creation of a new version of Test.doc under the identity of NormalA. Figure down below shows the version history of the test document.

The version history can be used to check our results. As you can see, the document was first updated by a system account, followed by an update by the NormalA user.

Now we are ready to show how to impersonate a user account using the SPUserToken object. We will access the default page of the PrivilegesTest site while logged in as SuperB, but we will check out and check in the file using the NormalB account. To make it easier to concentrate on the impersonation part of the code, copy the code concerning document modification to a new private method called CheckInAndOut() in the web part.

First, the web part needs to retrieve a valid SPUser object from the current SharePoint site representing the NormalB user account. We will use the AllUsers collection of the current SharePoint site to retrieve the NormalB user account. Then, we will need to create an instance of an SPSite object in the context of the NormalB user account. This is done by passing a valid user token representing
the NormalB user account. This token is retrieved from a property called UserToken that is a member of an SPUser object. The UserToken object needs to be passed to an SPSite object’s constructor in order to impersonate a given user. This is shown in the following code fragment:

SPUser user = web.AllUsers[@”web1\NormalB”];
SPSite objSite = new SPSite(“http://web1”, user.UserToken);
The complete code for the web part that uses the NormalB account to check out and then check in a document is listed here..

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
namespace KwikSilver.ImpersonationAndElevationDemo
{
[Guid(“47500629-54d5-4ac4-ac44-097b4ce2e3eb”)]
public class SuperPart : System.Web.UI.WebControls.WebParts.WebPart
{
public SuperPart()
{
this.ExportMode = WebPartExportMode.All;
}
protected override void CreateChildControls()
{
try
{
string strValue = String.Empty;
SPSite site = SPControl.GetContextSite(Context);
SPWeb web = site.AllWebs[“PrivilegesTest”];
SPUser user = web.AllUsers[@”web1\NormalB”];
CheckInAndOut(user);
}
catch (Exception err)
{
Controls.Add(new LiteralControl(err.Message));
}
}

private void CheckInAndOut(SPUser user)
{
SPSite objSite = new SPSite(“http://web1”, å
user.UserToken);
SPWeb objWeb = objSite.AllWebs[“PrivilegesTest”];
objWeb.AllowUnsafeUpdates = true;
SPFile objFile = objWeb.GetFile(“Shared Documents/Test.doc”);
objFile.CheckOut();
SPUser objUser = objFile.CheckedOutBy;
objFile.CheckIn(“check-in version: “ + objFile.UIVersion + “ by “ +
objUser.Name);
Controls.Add(new LiteralControl(objFile.Name +
“ checked out by: “ + objUser.Name));
}
}
}

The result of executing this web part is shown in Figure below:

It does not matter which account you use to log in to the SharePoint site containing the SuperPart web part; the web part uses the SPUserToken object to impersonate the NormalB account and then checks out test.doc using this account. You can also use the document version history to check this.

In this posting, you have learned how to use the SharePoint SPUserToken object. We have used the SPUserToken object to add a new version to the version history of a document stored in a SharePoint list.

How to implement WCF service in Sharepoint 2007

purushotam — Wed, 11 Jun 2008 21:43:00 +0100

In this posting, you will learn how to implement a WCF service that uses the application pool identity to connect to Microsoft Office SharePoint Server 2007.

The example in this section is created using Visual Studio 2008.
In the example we will discuss in this section, we will create a WCF service that is hosted by Internet Information Server. Then, we will specify an application pool identity and use that in our impersonation scenario to run some code the end user is normally not allowed to execute. In the next procedure, you will see how to create a new virtual directory for a WCF service.

In the next procedure, you will see how to create a new virtual directory for a WCF service.
1. Create a new folder at the following location: C:\Inetpub\wwwroot\TestWCFHost.
2. Open a command prompt and type inetmgr. This opens Internet Information Services (IIS)
Manager.
3. Expand the [server name] (local computer) node.
4. Expand the Web Sites node.
5. Locate a SharePoint web site where you want to add a virtual directory for your custom WCF
service, right-click it, and choose New äVirtual Directory. This opens the Virtual Directory
Creation Wizard.
6. Click Next.
7. Enter the following alias: TestWCFHost.
8. Click Next.
9. Enter the following path: C:\Inetpub\wwwroot\TestWCFHost.
10. Click Next.
11. Accept the default Virtual Directory Access Permissions and click Next.
12. Click Finish.
13. Right-click the newly created TestWCFHost node and choose Properties. This opens the
TestWCFHost Properties window.
14. Click Create.
15. Click OK.

We will create a custom application pool for this virtual directory, specify an application pool
identity under which the server will run, and associate them with each other. This is explained in the
next procedure.
1. In Internet Information Services (IIS) Manager, right-click the Application Pools node and
choose New Application Pool. This opens the Add New Application Pool dialog window.
2. Specify the following Application pool ID: WCFAppPool.
3. Click OK.
4. Right-click the newly created WCFAppPool node and choose Properties. This opens the
WCFAppPool Properties window.
5. Click the Identity tab.
6. Select the Configurable radio button.
7. Specify a user name and password.
8. Click OK.
9. Right-click the previously created TestWCFHost virtual directory (located under the Web
Site node) and choose Properties. This opens the TestWCFHost Properties window.
10. In the Application pool drop-down list, choose WCFAppPool.
11. Click OK.

At this point, you have created the container that will hold the WCF service. Now, we will use
Visual Studio 2008 to create the WCF service. This is discussed in the following procedure:
1. Start Visual Studio 2008
2. Click File New Web Site. This opens the New Web Site dialog window.
3. In the Templates section, choose WCF service.
4. Select HTTP from the Location drop-down list.
5. In the Location text box, type the URL of the virtual directory you created earlier in this section.
In our case, this is http://[sharepoint web application]/TestWCFHost.

As a result, several default files are created automatically. Delete the following files: Service.svc,
App_Code\Service.cs, and App_Code\IService.cs. You will notice that creating a WCF service is quite
similar to creating a classic .asmx web service. The following procedure discusses creating a WCF
service:
1. Right-click your project and choose Add New Item. This opens the Add New Item – [URL WCF service host] dialog window.
2. In the Templates section, choose WCF Service.
3. Enter the following name: MyWCFService.svc.
4. Ensure that the selected Language drop-down list is set to Visual C#.
5. Click Add.
This creates three files: MyWCFService.svc (located in the root of the project), and IMyWCFService.cs and MyWCFService.cs (both located in the App_Code folder). The MyWCFService.svc file contains of a single line of code that refers to a code-behind file.

and here is the file..

<%@ ServiceHost Language=”C#” Debug=”true” Service=”KwikSilver.MyWCFService” CodeBehind=”~/App_Code/MyWCFService.cs” %>

Next, we will take a closer look at the IMyWCFService class file. In WCF, all services expose contracts
that explicitly define what a service does. There are four different types of contracts:
• Service contracts that describe the operations that can be performed by the client.
• Data contracts that describe the data that is passed to and from the service.
• Fault contracts that describe errors that are raised by the service.
• Message contracts that describe how a service can interact directly with a message.

In this example, only service contracts are relevant. You can create a service contract by adding a .cs file that defines a new interface. Then, you need to decorate the interface with a [ServiceContract] attribute that exposes a normal CLR interface as a WCF contract. Every method within such an interface that needs to be exposed in the WCF contract needs to be decorated
with the [OperationContract] attribute. code below shows the implementation for the IMyWCFService WCF service contract:

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
namespace KwikSilver
{
[ServiceContract]
public interface IMyWCFService
{
[OperationContract]
string DoWork();
}
}

This service contract needs to be implemented by a class. To demonstrate that impersonation has worked, we will use a piece of code that fails if the identity executing the code is not an administrator. The code retrieves the current SharePoint site and shows the collection of site groups of which the current user is a member:

string strValue = String.Empty;
RevertToSelf();
SPWeb objCurrentWeb = SPControl.GetContextWeb(Context);
foreach (SPRole objRole in objCurrentWeb.CurrentUser.Roles)
{
strValue += “Role: “ + objRole.Name + “<br/>”;
}

This code fails unless you are an administrator. If we modify the code a bit so you can pass the URL of the site collection and the user name as arguments, the code looks like this:

public string GetUserRoles(string strUrl, string strUserName)
{
string strResult = String.Empty;
using (SPSite objSiteCollection = new SPSite(strUrl))
{
using (SPWeb objSite = objSiteCollection.OpenWeb())
{
SPUser objUser = objSite.Users[strUserName];
foreach (SPRole objRole in objUser.Roles)
{
strResult += objRole.Name + “, “;
}
}
}
return strResult;
}

and finally here is the complete code..

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Security.Principal;
using Microsoft.SharePoint;

namespace KwikSilver
{
public class MyWCFService : IMyWCFService
{
public string DoWork()
{
// e.g. SHAREPOINT\system as the user name.
return GetUserRoles(“[site collection URL]”, @”[user name] “);
}
public string GetUserRoles(string strUrl, string strUserName)
{
try
{
string strResult = String.Empty;
using (SPSite objSite = new SPSite(strUrl))
{
using (SPWeb objWeb = objSite.OpenWeb())
{
SPUser objUser = objWeb.Users[strUserName];
foreach (SPRole objRole in objUser.Roles)
{
strResult += objRole.Name + “, “;
}
}
}
return strResult;
}
catch (Exception err)
{
return err.Message;
}
}
}
}

Before you can use the WCF service, you need to adjust the web.config file to define endpoints that can be accessed by a client. This is done by adding a new <service> element to the <services> node of the web.config file. The <service> element allows you to define the service name via the name property. You can also add an <endpoint> element that defines a service contract that is used
for the WCF service (service contracts were discussed earlier in this chapter) and a binding that is used by the service. Bindings define aspects about the transport mechanism, such as the protocol or the message encoding type that are used. In this example, we will use WsHttpBinding, which uses HTTP as the transport protocol. The following code fragment shows how to define a new service endpoint that uses the IWcfImpersonator service contract and uses HTTP as the transport protocol:

<service name=”KwikSilver.MyWCFService”>
<endpoint address=”” binding=”wsHttpBinding” contract=”KwikSilver.IMyWCFService” />
</service>

You will also need to make sure that the WCF service emits metadata that is used by the client to retrieve a service description. You can do this by defining a service behavior for the service. Service behaviors affect all endpoints of a service, and you can specify which service behavior applies to a service by using the <service> element’s behaviorConfiguration attribute. This is shown in the
following code fragment:

<service name=”KwikSilver.MyWCFService” behaviorConfiguration=”MyServiceTypeBehaviors”>

The following service behavior needs to be added to the <serviceBehaviors> section of the web.config file, and specifies that any service associated to this behavior exposes metadata:
<behavior name=”MyServiceTypeBehaviors” >
<serviceMetadata httpGetEnabled=”true” />
</behavior>

If you open a browser and browse to the svc file (http://[sharepoint web application]/TestWCFService/MyWCFService.svc), you should see a page similar to figure..

The next procedure explains how to create a test client for this WCF service.
1. Right-click the solution and choose Add New Project. This opens the Add New Project dialog window.
2. In the Templates section, choose Windows Forms Application.
3. Enter the following Name: WCFTestClient.
4. Click OK.
5. Right-click the WCFTestClient project and choose Add Service Reference. The Add Service Reference dialog window appears.
6. In the Service URI text box, enter the URL of the MyWCFService.svc file. This is shown in figure..

7. In the Service reference name text box, enter a friendly name that represents the service. In this case, I have specified a value of MyWCFServiceReference.
8. Click OK.
9. Open the code view window of the Windows form and add the code above to the Form load event:

private void Form1_Load(object sender, EventArgs e)
{
MyWCFServiceReference.MyWCFServiceClient objService = å
new MyWCFServiceReference.MyWCFServiceClient();
string strResult = objService.DoWork();
objService.Close();
}

You have now created a test client for your WCF service. Try it out and if everything works fine, you can add a service reference to this WCF service within web parts or SharePoint pages. In this section, you learned how to create a WCF service that is hosted in IIS and runs under a custom application pool identity.WCF services can be used to execute code under this custom
application pool identity that a normal end user would not be allowed to run.

How to deploy webpart using solution package in Sharepoint 2007

purushotam — Thu, 05 Jun 2008 18:58:00 +0100

In earlier versions for Sharepoint, biggest challenge was deploying webparts on production servers. But this is now easy and peezy with Sharepoint 2007... hats off to the new version!. In this posting i will demonstrate how can one aciveve deploying devleoped webparts easily.

If you want to deploy a web part, you can use SharePoint solution files. Basically, SharePoint solution files are cabinet files (.cab) with a different extension, namely .wsp. When you use Visual Studio 2005 extensions for Windows SharePoint Services 3.0 to create a web part, as was discussed in my prevuois postings, a web part solution file is created automatically for you. In this section, you will learn how to create a SharePoint solution file that allows you to deploy a web part to other SharePoint servers and/or SharePoint web applications.

To demonstrate web part deployment, we will create a new web part called MyWebPart.cs that uses the ASP.NET 2.0 Wizard control to implement a wizard. The Wizard server control enables you to build a sequence of steps that are displayed to the end user. You could use the Wizard control to either display or gather information in small steps. The Wizard control lets you define a group of views in which only one view at a time is active and is rendered to the client. Each view consists of four zones: sidebar, header, content, and navigation. The optional sidebar part contains an overview of all the steps in the wizard. The header contains the header information. The content part contains whichever control or controls you like. The navigation part consists of buttons to
navigate through the steps in the wizard.

When you are constructing a step-by-step process that includes logic for every step taken, use the Wizard control to manage the entire process. The Wizard control’s navigation buttons fire server-side events whenever the user clicks one of the buttons, helping to navigate to other wizard views on the same page. Navigation can be linear and nonlinear; in other words, you can jump from
one view to another or navigate randomly to whichever view you like. All the controls in a wizard view are part of the page, so you can access them in code using their control IDs.

In this example, I have defined six different steps. Each step is a WizardStep control and contains a text box. The state of the text boxes in the wizard is maintained automatically. The order in which the steps are defined is completely based upon the order in which they are added to the wizard via the Add() method of the Wizard object’s WizardSteps property. The WizardSteps property contains a collection of WizardSteps. Changing this order changes the order in which the end user sees them. The following figure shows the first step.

The first step, the start step, always has one button called Next. The following steps will have two buttons, as seen in Figure below:

There are six steps in this example. The final step, step 6, has a Previous and a Finish button, as you can see in Figure below:

The MyWebPart web part creates a very simple wizard; the Wizard control itself has a lot more options that I will not cover in this posting (sometime later!). The code for the web part using the Wizard control is shown in fig below:

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
namespace KwikSilver.Sharepoint.WebpartDemo
{
[Guid(“3d82fb59-c294-497d-9d47-d85c21540b06”)]
public class MyWebPart : System.Web.UI.WebControls.WebParts.WebPart
{

public MyWebPart()
{
}
protected override void CreateChildControls()
{

Wizard objWizard = new Wizard();
objWizard.HeaderText = “Wizard Header”;
for (int i = 1; i <= 6; i++)
{
WizardStepBase objStep = new WizardStep();
objStep.ID = “Step” + i;
objStep.Title = “Step “ + i;
TextBox objText = new TextBox();
objText.ID = “Text” + i;
objText.Text = “Value for step “ + i;
objStep.Controls.Add(objText);
objWizard.WizardSteps.Add(objStep);
}
Controls.Add(objWizard);
}

}

}

Now that we have created a web part, we are ready for the next step, the creation of a SharePoint solution file.
In the first part of the process, we will add a manifest file (Manifest.xml) to our web part library solution. The manifest file is used by Visual Studio 2005 and defines how to populate the cabinet file that is used to deploy the MyWebPart web part. The next procedure explains how to create a Manifest.xml file and how to add IntelliSense support to it:

1. In the WebpartDemo project, choose Add äNew Item. This opens the Add New Item -
WebpartDemodialog box.
2. In the Templates section, choose XML file.
3. In the Name text box, add the following value: Manifest.xml.
4. Click the Add button.
5. Click the Code window of Manifest.xml.
6. In the Properties window, click Schemas.
7. Click the ... button. This opens the XSD Schemas dialog box.
8. Click the Add button. This opens the Open XSD Schema dialog box.
9. Locate wss.xsd ([drive letter]:\Program Files\Common Files\Microsoft Shared\web server
extensions\12\TEMPLATE\XML) and choose Open.
10. Click OK.
11. Add the code shown below to Manifest.xml:

<?xml version=”1.0” encoding=”utf-8” ?>
<Solution xmlns="http://schemas.microsoft.com/sharepoint/"
SolutionId="312ae869-37dc-4a74-9ecc-359fb3c1461d">
<Assemblies>
<Assembly DeploymentTarget=”WebApplication”
Location=”WebpartDemo.dll”>
<SafeControls>
<SafeControl Assembly=”WebpartDemo,
Version=1.0.0.0,
Culture=neutral,
PublicKeyToken=9f4da00116c38ec5”
Namespace=”KwikSilver.Sharepoint.WebpartDemo”
TypeName=”*”
Safe=”True” />
</SafeControls>
</Assembly>
</Assemblies>
</Solution>

After adding the Manifest.xml file to the web part library project, you can go ahead and create a
cabinet project to deploy the MyWebPart web part to another SharePoint server or SharePoint web
application. The next procedure explains how to create a SharePoint solution file:
1. Open the WebpartDemo web part library solution.
2. Choose File Add New Project. This opens the Add New Project dialog box.
3. In the Project types section, expand the Other Project Types node and choose Setup and
Deployment.
4. In the Templates section, choose CAB Project.
5. In the Name text box, add the following value: WebpartDemoCab.
6. Click OK.
7. Right-click WPLibraryCab and choose Add äProject Output. This opens the Add Project
Output Group dialog box.
8. In the Project drop-down list, choose WebpartDemo.
9. Select Primary output and Content Files.
10. Click OK.
11. Build WebpartDemoCab.
12. Locate WebpartDemoCab.cab and rename it to WebpartDemo.wsp.
13. Open a command prompt, and type the following command:
stsadm -o addsolution -filename WebpartDemo.wsp

Now, the SharePoint solution is added to SharePoint. You can deploy it further using the stsadm tool, or deploy the solution via the user interface of the SharePoint 3.0 Central Administration tool. The next procedure explains how to deploy the solution using the SharePoint 3.0 Central Administration tool:
1. Open SharePoint 3.0 Central Administration.
2. Click Operations. This opens the Operations page.
3. In the Global Configuration section, choose Solution Management. This opens the Solution
Management page. This is shown in Figure.

Click the MyWebpartDemoCab.wsp link. This opens the Solution Properties page, which is shown in Figure below:

5. Click Deploy Solution. This opens the Deploy Solution page, as shown in..

6. In the Deploy to ? section, choose a Web application to deploy this solution.
7. Click OK. This opens the Solution Management page that is shown in Figure down below:

.

At this point, the SharePoint solution is deployed to a specific SharePoint server and a specific SharePoint web application. Before you are able to use the web parts deployed using a SharePoint solution, you need to add them to the web part gallery of the site collection:

8. Browse to the web application you have chosen in the previous step.
9. Choose Site Actions Site Settings. This opens the Site Settings page.
10. In the Galleries section, click Web Parts. This opens the Web Part Gallery page.
11. Click New. The web parts in the MyWebPartDemo assembly should be listed; select them
and click the Populate Gallery button.
You have seen how to create a SharePoint solution (.wsp) file that can be used to deploy web parts. After completing all the steps described in this section, you are ready to start using the web parts deployed via the SharePoint solution.

Hope this helps a lot!..

How to develop editor for a webpart in Sharepoint 2007

purushotam — Sun, 18 May 2008 19:29:00 +0100

In my previous postings on webparts, i have demonstrated how to do it from scratch. In this article, i will explain how to incorporate editor for a webpart. If you have sufficient permissions, you are allowed to configure web parts. When you start configuring web parts via the user interface, a web part tool pane opens. Any configuration information stored in the pane is persisted in the SharePoint content database. In my previous posting, you learned how to create properties that can be configured using the web part tool pane. The figure below shows an example of a web part tool pane.

Out of the box, SharePoint offers different editors for different types of data. For instance, a string property is represented by the text box editor, while a Boolean property is represented by check boxes. In this section, you will learn how to create custom editor parts, which will be shown in the web part tool pane when you are configuring a web part.

All editor parts inherit from the EditorPart base class, so that is the first step you need to take when creating a custom editor part. Editor parts look a lot like normal web parts. For instance, if you want to add child controls to an editor part, you need to override its CreateChildControls() method. The following code fragment adds a text area consisting of five lines to an editor part:

protected override void CreateChildControls()
{

_txtNormalBox = new TextBox();
_txtNormalBox.ID = “txtNormalBox”;
_txtNormalBox.Text = “[Custom editor part]”;
_txtNormalBox.TextMode = TextBoxMode.MultiLine;
_txtNormalBox.Rows = 5;
Controls.Add(_txtNormalBox);

}

You will also need to override the ApplyChanges() method of an EditorPart instance. This
method is responsible for mapping values in the editor part to corresponding properties in the
associated web part. The following code fragment shows how the ApplyChanges() method sets a
property in an instance of the MyWebPart web part called NormalValue:

public override bool ApplyChanges()
{

MyWebPart objMyWebPart = (MyWebPart)WebPartToEdit;
objMyWebPart.NormalValue = _txtNormalBox.Text;
return true;

}

The final piece of an editor part that must be implemented is the SyncChanges() method. This method is the opposite of the ApplyChanges() method; it retrieves property values from a web part and stores them in the editor part. The following code fragment shows an implementation for the SyncChanges() method that retrieves the NormalValue property of a MyWebPart web part and stores it in the text area of the web part editor tool pane:

public override void SyncChanges()
{

// Make sure the text area child control is created.
EnsureChildControls();
MyWebPart objMyWebPart = (MyWebPart ) WebPartToEdit;
_txtNormalBox.Text = objMyWebPart.NormalValue;

}

So far, you have seen how to create an editor part. Before a custom editor part is shown in the web part editor tool pane, you need to implement support for this in your web part. In this example, we are creating a web part called MyWebPart. First, we need to add one or more properties that are read from and written to within the editor part. The custom editor part in this section expects the
presence of a NormalValue property in a web part, so that is the first thing that needs to be implemented.

The following code snippet shows how to implement the NormalValue property:

private string _strNormalValue = String.Empty;
[Personalizable(PersonalizationScope.Shared), WebBrowsable(false), WebDisplayName(“Normal value”), WebDescription(“Normal value description”)]
public string NormalValue
{

get { return _strNormalValue; }
set { _strNormalValue = value; }

}

After that, you need to override the CreateEditorParts() method. This method is responsible for returning a collection of custom editor part controls that are shown in the web part editor tool pane when a web part is in edit mode. Basically, this method is used to create a new instance of one or more custom editor parts and add those to the editor part collection. This collection is used
when the web part tool pane is rendered. The following code fragment shows how to add the MyWebPartEditorPart editor part to the collection of customer editor parts that is shown when the MyWebPart web part is being edited:

public override EditorPartCollection CreateEditorParts()
{

MyWebPartEditorPart objEditor = new MyWebPartEditorPart ();
objEditor.ID = ID + “normalEditor1”;
objEditor.Title = “Normal Editor title”;
objEditor.ToolTip = “Normal Editor tooltip”;
objEditor.TabIndex = 100;
objEditor.GroupingText = “Normal editor grouping text”;
ArrayList objEditorParts = new ArrayList();
objEditorParts.Add(objEditor);
EditorPartCollection objEditorPartsCollection = new
EditorPartCollection(objEditorParts);
return objEditorPartsCollection;

}

and here is the complete code:

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
namespace KwikSliver.Sharepoint.WebpartDemo
{

public class MyWebPartEditorPart : EditorPart
{
TextBox _txtNormalBox;
protected override void CreateChildControls()
{
_txtNormalBox = new TextBox();
_txtNormalBox.ID = “txtNormalBox”;
_txtNormalBox.Text = “[Custom editor part]”;
_txtNormalBox.TextMode = TextBoxMode.MultiLine;
_txtNormalBox.Rows = 5;
Controls.Add(_txtNormalBox);
}
public override bool ApplyChanges()
{
MyWebPart objMyWebPart = (MyWebPart )WebPartToEdit;
objMyWebPart.NormalValue = _txtNormalBox.Text;
return true;
}
public override void SyncChanges()
{
EnsureChildControls();
MyWebPart objMyWebPart = (MyWebPart)WebPartToEdit;
_txtNormalBox.Text = objMyWebPart .NormalValue;
}
}

}

and below shown is the code for implementation of the MyWebPart web part. This web part displays the custom MyWebPartEditorPart web part in edit mode:

using System;
using System.Collections;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using System;
using System.Collections;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
using Microsoft.SharePoint.Administration;
using Microsoft.SharePoint.Utilities;
namespace KwikSilver.Sharepoint.WebpartDemo
{
[Guid(“288802c4-4dfe-45b6-bb28-49dda89ec225”)]
public class MyWeblPart : System.Web.UI.WebControls.WebParts.WebPart
{

protected override void RenderContents(HtmlTextWriter writer)
{
writer.Write(“Normalvalue: “ + NormalValue);
}
public override EditorPartCollection CreateEditorParts()
{
MyWeblPartEditorPart objEditor = new MyWeblPartEditorPart ();
objEditor.ID = ID + “normalEditor1”;
objEditor.Title = “Normal Editor title”;
objEditor.ToolTip = “Normal Editor tooltip”;
objEditor.TabIndex = 100;
objEditor.GroupingText = “Normal editor grouping text”;
ArrayList objEditorParts = new ArrayList();
objEditorParts.Add(objEditor);
EditorPartCollection objEditorPartsCollection = new EditorPartCollection(objEditorParts);
return objEditorPartsCollection;
}
private string _strNormalValue = String.Empty;
[Personalizable(PersonalizationScope.Shared), WebBrowsable(false), WebDisplayName(“Normal value”), WebDescription(“Normal value description”)]
public string NormalValue
{
get { return _strNormalValue; }
set { _strNormalValue = value; }
}

}
}

and here is the end result for all the efforts made above!..

How to develop menu for a Webpart in Sharepoint 2007

purushotam — Wed, 14 May 2008 13:07:00 +0100

In this posting i will demonstrate how to create menu for a webpart in Sharepoint 2007.

Every web part on a SharePoint page has a web part menu that contains standard options such as the ability to minimize or close the web part. An example of a standard web part menu is shown in figure down below:

In this section, you will learn how to create custom web part menu verbs that are added to the verbs menu in a web part’s header. To start with, it is good to realize that there are three kinds of web part menu verbs:

• Client-side verbs. These verbs perform some kind of action on the client side.
• Server-side verbs. These verbs perform some kind of action on the server side.
• Both. These verbs perform actions on both the client and server side.

You can create a client-side verb by creating a new instance of the WebPartVerb class. The first argument that needs to be passed to the WebPartVerb constructor for a client-side verb is the verb’s id. This needs to be unique. The second argument refers to the client-click event handler. This typically refers to a piece of JavaScript that needs to be executed once an end user clicks on a web part menu verb. The following code fragment shows how to create a client-side verb:

If you want to create a server-side verb, you need to instantiate a new WebPartVerb class, pass it a unique verb id, and specify a server-side event handler to be executed once an end user clicks on the verb. The next code fragment shows how to create a server-side verb:

WebPartVerb objSecond = new WebPartVerb(“SecondVerbId”,new WebPartEventHandler(SecondVerbHandler));
objSecond.Text = “second verb text”;
objSecond.Description = “second verb description”;

The final web part menu verb type, the kind that performs both client-side and server-side actions, is created by passing a unique verb id, a server-side event handler, and a client-side event handler. You can add custom web part verbs by overriding the Verbs property of a web part and adding custom verbs to it. The code listing shows how to add custom verbs to the web part menu and define an event handler that handles a server-side verb click event:

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
using Microsoft.SharePoint.Administration;
using Microsoft.SharePoint.Utilities;
using System.Net;
using System.Net.Mail;
namespace KwikSilver.Sharepoint.WebpartDemo
{

[Guid(“288802c4-4dfe-45b6-bb28-49dda89ec225”)]
public class MyMenuWebPart : System.Web.UI.WebControls.WebParts.WebPart
{
public override WebPartVerbCollection Verbs
{
get
{

WebPartVerb objFirst = new WebPartVerb(“FirstVerbId”, “javascript:alert(‘Hello from verb!’);”);
objFirst.Text = “first verb text”;
objFirst.Description = “first verb description”;
objFirst.ImageUrl = “_layouts/images/kwiksilver/favicon.gif”;
WebPartVerb objSecond = new WebPartVerb(“SecondVerbId”, new WebPartEventHandler(SecondVerbHandler));
objSecond.Text = “second verb text”;
objSecond.Description = “second verb description”;
WebPartVerb[] objVerbs = new WebPartVerb[] {objFirst, objSecond};
WebPartVerbCollection objVerbCollection = new WebPartVerbCollection(base.Verbs, objVerbs);
return objVerbCollection;
}

}
protected void SecondVerbHandler(object sender, WebPartEventArgs args)
{

//Do something...

}
}

}

This code adds two web part verbs to the web part menu: a client-side verb and a server-side verb. Both verbs are shown in Figure.

and Figure down below shows what happens when you click on the client-side verb. Some JavaScript will
be executed that displays an alert box.

In this posting, you have seen that adding verbs to a web part menu enhances the user interface experience and is quite easy to accomplish.

In my next posting, you will find how to create webpart with custom editor in it.

How to develop Configurable Webpart for Sharepoint 2007

purushotam — Wed, 07 May 2008 23:51:00 +0100

In this posting, i would concentrate on developing a web part which could have configuration settings.

If you are building a generic web part, you probably will need to be able to configure it on a per-web
part basis. You can use web part properties and the Web Part Editor tool pane to configure web
parts, as you will see in this section. Such configuration information is stored in the SharePoint content
database.

To demonstrate web part configuration via properties, we will create a web part that uploads a
local file to a SharePoint document library. File upload in ASP.NET 1.x was possible, although you
did have to jump through some hoops to get everything working. For example, you had to add
enctype=”multipart/form-data” to the page’s <form> element. The new ASP.NET 2.0 FileUpload
server control makes the process of uploading files to the hosting server as simple as possible.
The FileUpload control displays a text box and a Browse button that allow users to select a file
to upload to the server. The user specifies the file to upload by entering the fully qualified path to
the file on the local computer (for example, C:\Temp\Test.txt) in the text box of the control. The
user can also select the file by clicking the Browse button and then locating it in the Choose File dialog
box. You need to hook up an event handler to a Submit button, which calls the SaveAs() method
of the FileUpLoad control. Via this method, you can specify the location where the file will be saved.
The file will not be uploaded to the server until the user clicks the Submit button.
To build this web part, we need three configurable properties to store the following information:

• Site collection URL
• Site URL
• Name of the document library that is going to hold the uploaded file

If you want to create a configurable property, you first need to add the [Personalizable]
attribute to a property to indicate that the property supports personalization. You also need to specify
the personalization scope that associates the scope of a web part property to the state a web part
page is running in. This determines which configuration data is retrieved from the SharePoint configuration
database. You can set the personalization scope to either Shared or User.
Setting the personalization scope of a web part to Shared ensures that the data associated with
a page running in Shared mode is retrieved. In this case, the configuration information applies to all
users viewing the web part.

You can also set the personalization scope of a web part to User to make sure that the data
associated to a page running in User mode is retrieved. Such configuration information indicates
that configuration information is retrieved for the currently executing user.

In this example, we are not interested in user-specific data; we are interested in application specific
data. As a result, we will set the personalization scope to Shared. You will also need to set
the [WebBrowsable] attribute to true to make it appear in the web part tool pane. In addition, you
can use the [WebDisplayName] and [WebDescription] attributes to define a friendly name and
description for the web part property. This information is shown in the web part tool pane. The following
code fragment shows a web part property containing the URL of a site collection that is
personalizable, stores configuration on an application-wide basis, and defines a friendly name and
description:

private string _strSiteCollectionUrl;
[Personalizable(PersonalizationScope.Shared),
WebBrowsable(true),
WebDisplayName(“Site Collection URL”),
WebDescription(“Enter the URL of the site collection that contains the
list a document is uploaded to”)]
public string SiteCollectionUrl
{
get { return _strSiteCollectionUrl; }
set { _strSiteCollectionUrl = value; }
}

The web part in this section opens a site collection containing the document library that will
hold the uploaded file. Then, it opens the site that contains this document library, and finally, it
opens the document library itself. In this example, we are saving uploaded files to the root folder of
the document library by using the Add() method of the RootFolder object’s Files collection. By passing
the input stream of the FileUpload control to the Add() method, you can save a file to a
document library. The next code fragment shows how to save a file uploaded via the FileUpload
control in a document library, overwriting files that have the same name:

using (SPSite objSite = new SPSite(SiteCollectionUrl))
{

using (SPWeb objWeb = objSite.OpenWeb(SiteUrl))
{

SPList objList = objWeb.Lists[ListName];
if (_objFileUpload.HasFile)
{

objList.RootFolder.Files.Add(_objFileUpload.FileName, å
_objFileUpload.PostedFile.InputStream, true);

}

The complete code for a configurable web part that uses the FileUpload control to upload a file
to a SharePoint document library is shown down below:

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;

namespace KwikSilver.Sharepoint.WebpartDemo
{

[Guid(“288802c4-4dfe-45b6-bb28-49dda89ec225”)]
public class MyFileUploadlPart : System.Web.UI.WebControls.WebParts.WebPart
{
FileUpload _objFileUpload = new FileUpload();
protected override void CreateChildControls()
{
Controls.Add(_objFileUpload);
Button btnUpload = new Button();
btnUpload.Text = “Save File”;
this.Load += new System.EventHandler(btnUpload_Click);
Controls.Add(btnUpload);
}
private void btnUpload_Click(object sender, EventArgs e)
{
using (SPSite objSite = new SPSite(SiteCollectionUrl))
{
using (SPWeb objWeb = objSite.OpenWeb(SiteUrl))
{
SPList objList = objWeb.Lists[ListName];
if (_objFileUpload.HasFile)
{
objList.RootFolder.Files.Add(_objFileUpload.FileName,
_objFileUpload.PostedFile.InputStream, true);
}
}
}
}
private string _strSiteCollectionUrl;
[Personalizable(PersonalizationScope.Shared), WebBrowsable(true),
WebDisplayName(“Site Collection URL”),
WebDescription(“Enter the URL of the site collection that contains
the list a document is uploaded to”)]
public string SiteCollectionUrl
{
get { return _strSiteCollectionUrl; }
set { _strSiteCollectionUrl = value; }
}
private string _strSiteUrl;
[Personalizable(PersonalizationScope.Shared),
WebBrowsable(true), WebDisplayName(“Site Collection URL”),
WebDescription(“Enter the URL of the site that contains
the list a document is uploaded to”)]
public string SiteUrl
{
get { return _strSiteUrl; }
set { _strSiteUrl = value; }
}
private string _strListName;
[Personalizable(PersonalizationScope.Shared),WebBrowsable(true),WebDisplayName(“List name”), WebDescription(“Enter the name of the list that will contain the uploaded document”)]
public string ListName
{
get { return _strListName; }
set { _strListName = value; }
}
}

}

The following figure shows the FileUpload web part (called MyFileUploadPart) in action. First, the web part
allows you to choose a local file (test.txt) that you want to upload to a SharePoint document library.

and the local file test.txt is uploaded to a document library called Shared Documents as in fig below:

Creating Web Part for Sharepoint

purushotam — Mon, 05 May 2008 21:16:00 +0100

In this article, I will demonstrate how to create a simple web part.

If you have installed VSeWSS (make sure you have installed Visual Studio 2005 Extensions, if not you can download from: http://www.microsoft.com/downloads/details.aspx?familyid=19f21e5e-b715-4f0c-b959-8c6dcbdc1057&displaylang=en)
and then start Visual Studio 2005, you will find that a new set of Visual Studio project templates is available when you create
a new project.
The new project templates are available in the Visual C# SharePoint section, as shown in Figure down below:

The following project templates are added by Visual Studio 2005 extensions for Windows SharePoint Services 3.0:

• Team Site Definition
• List Definition
• Empty
• Blank Site Definition
• Web Part

Visual Studio 2005 extensions for Windows SharePoint Services 3.0 also contains a set of item templates that can be used
within SharePoint projects for Visual Studio 2005. The following item templates are added by VSeWSS:

• List Definition
• Content Type
• Web Part
• List Definition from Content Type
• Field Control
• Module

The item templates for Visual Studio are found in the Visual C# Project Items SharePoint section of the Add New Item – [name of project] window. This is shown in Figure down below:

In the next procedure, we will add a new web part and have it write a “Hello!” message to the page that contains the web part.

1. Right-click the WPLibrary folder in the Solution Explorer, and choose Add New Item. This opens the Add New Item - [name of project] window.
2. Under Visual C# Project Items SharePoint, select the Web Part item template.
3. In the Name text field, enter the following name: MyWebPart.
4. Click Add. This adds a new MyWebPart folder that includes a class called MyWebPart.cs.
5. Open MyWebPart.cs. This is an ASP.NET 2.0 web part.
6. Add the following code to the body of the MyWebPart.cs class:

protected override void RenderContents(HtmlTextWriter writer)
{
writer.Write(“Hello!”);
}

One of the nice features of the Web Part project template is the ability to package a web part within the project as a SharePoint feature. Features make it easy to deploy and activate web parts (and they can do a lot more than that).
You have fine-grained influence over the settings of a web part feature.

The following procedure explains how to configure feature settings:

1. Right-click the WPLibrary project and choose Properties.
2. Click the SharePoint solution tab.

At this point, you are almost ready to deploy the web parts in your web part solution.
First, you must configure to which SharePoint site the web part solution needs to be deployed. This is explained in the next procedure:

1. Right-click WPLibrary and choose Properties.
2. Click the Debug tab.
3. In the Start Action section, make sure the Start browser with URL radio button is selected.
4. Enter the SharePoint site URL into the Start browser with URL text field.

Deploying a web part has never been easier; all you need to do is press F5 (or Debug Start Debugging).
When you do this, a couple of things happen:

1. The web part solution is compiled.
2. The web part solution is packaged as a feature.
3. If a previous version of the web part feature exists, it is removed.
4. The web part library is added to the Global Assembly Cache (GAC).
5. The web part feature is deployed to the SharePoint site URL you specified earlier.
6. If deployment is successful, the web part feature is activated.
7. The web parts in the web part library are added to the <SafeControls> list in the web.config file of the SharePoint web application that contains the web part.
8. The web part gallery is modified so that the site can use the web parts.
9. Internet Information Services (IIS) is restarted.
10. If debugging is enabled, Visual Studio 2005 automatically tries to attach to the w3wp process hosting the web part.

Now, you should go ahead and add the web part to a web part page. The following procedure explains how to do this:

1. Navigate to the SharePoint site URL you specified earlier.
2. Choose Site Actions Edit Page. This opens the page in Edit Mode.
3. Choose a web part zone and click the Add a Web Part link. This opens the Add Web Parts Web Page Dialog window.
4. Locate the All Web Parts äMiscellaneous section and select the MyWebPart Web Part checkbox.
5. Click the Add button.

This adds the MyWebPart web part to the page. If you want to go ahead and debug this web part, follow these steps:

1. Open a command prompt and type inetmgr. This opens Internet Information Services (IIS) Manager.
2. Expand the [computer name] (local computer) node.
3. Expand the Web Sites node.
4. Locate the SharePoint web site that contains your web part, right-click it, and choose Properties. This opens the [web site name] Properties window.
5. Click the Home Directory tab.
6. Copy the value of the Local Path text field.
7. Open Windows Explorer and navigate to the local path you copied in the previous step. This opens the root folder of the SharePoint web application that contains your web part.
8. Set a break point to a line of code in the web part.
9. Press F5.

After deployment, Visual Studio 2005 attaches automatically to the process hosting your web part, and break mode is entered automatically. This is shown in Figure down below:

and.. That's it. You now have created simple webpart. In next posting i will discuss how to develop a configurable webpart.

WCF Hello World Part -2

purushotam — Tue, 08 Apr 2008 21:46:00 +0100

In my previous post, I have created a WCF service. In this part, I will create a client to consume the WCF Service created. Since this is an hello world example, Let's create a web method in WCF service. Todo that, create a method first on interface and then implement it in the service as shown in code.

[ServiceContract]
    public interface IHelloWorldService
    {

        [OperationContract]
        string GetData(int value);

        [OperationContract]
        CompositeType GetDataUsingDataContract(CompositeType composite);

        // TODO: Add your service operations here
        [OperationContract]
        string GetGreetings(string name);
    }

 public class HelloWorldService : IHelloWorldService
    {
        ...

        public string GetGreetings(string name)
        {
            return string.Format("Hello {0}, Welcome to WCF World!", name);
        }

    ....
    }

Now, lets create a client to consume this service. I prefer to create a web client. In order to do this, one needs a service proxy, which will communicate to the service using Soap as transport mechanism. There are 2 ways to create a proxy. 1. by using Visual Studio 2. by using svcutil.exe utility by WCF framework. for this example, i will simply use Visual Studio as we used to do earlier versions of .net. Add a new website by name WCFHelloWorld-Web and add a service reference and point to the WCF service created as show shown fig below. Add namespace of WCF Service to codebehind of aspx file, in this case ServiceReference1 is the namespace. using this namespace, create a proxy object as class variable in the aspx.cs file and in aspx file create some server controls in order to type some input and display as label. I have created UI as follows: and in button event handler, pass the textbox input to webservice's GetGreetings method and display on UI with label as shown below:

using ServiceReference1;

public partial class _Default : System.Web.UI.Page 
{
    HelloWorldServiceClient proxy = new HelloWorldServiceClient();

    protected void Page_Load(object sender, EventArgs e)
    {
        
    }
    protected void btnSumbit_Click(object sender, EventArgs e)
    {
               lblGreetings.Text = proxy.GetGreetings(txtName.Text);
    }
}

Hit F5 to see the aspx page in browser. Input some name and hit Get Greetings button, you should be able to see display output as shown in fig below: that's it.. simple to create a web cilent and consume a WCF service. I will take you in depth in next part of this series, until then bye.

WCF Hello World Part -1

purushotam — Thu, 03 Apr 2008 21:44:00 +0100

This is my first posting on WCF, i thought I would start with Hello World on WCF and i dont know to what extent WCF will take me!. For a reader who finds this posting, this is would be a head start on WCF and am gonna discuss challenges and issues on WCF in part by part.so, here i am.first of all I would like to brief What tools i will be using at the moment.1. Visual Studio 2008 for this posting. I may wish to revisit this part again for my next posting.Ok then. Lets fire up Visual Studio 2008 and create WCF Service by name WCFHelloWorld as shown in fig below:So When i have created, Visual Studio creates some files for me. those are1. Service1.svc2. IService1.cs3. Web.Config4. App_Code folder with web project settings and references.What might interests is 2 files 1 and 2 from above. In eariler version of .Net, you would have created Web Services and seen asmx files instead.now, I am gonna rename those files to fit into my demonstration as WCFHelloWorld.So, I rename Service1.svc as WCFHelloWorld.svc and IService1.cs as IWCFHelloWorld.cs.I leave it with you, how you rename the files and organise and make it compilable at least for now. finally i get my compilable as shown below:

Note: Keep in mind that WCF is a runtime for Web Services. In earlier versions of .Net, Asp.Net was runtime for Web Services. now WCF is runtime for Web Services and .Net remoting!. Those who have worked on .Net Remoting, here is a good news, now they can enjoy exploring separate runtime!.

When you build is succeeded, press F5 and opens in browser as shown below:At this moment, I have created web service and launched it. In next part of this demo, will create a client and consume this web service.I have tried to make it simple, hence have not been able to delve in detail but taking this as an example, in some part later of this demo will go in depth, until then bye...

----------------end of part -1 ------------

SQL SERVER - Fix : Error : 40 - could not open a connection to SQL server

purushotam — Sat, 08 Dec 2007 20:38:00 +0000

Recently i was setting up development environment at home. When i had to connect SQL server remotely from another VPC, i could not connect it even after enabling allow remote connections on my Sql Server. the error messaage was... An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: SQL Network Interfaces, error: 26 - Error Locating Server/Instance Specified)
for some reason it did not work as suggested by many.. but after banging my head to wall... cpu and then to lcd monitor, figured the solution. but dont worry, figured what was the problem at last………

the probelm is the Instance name from the client is not resolved, to do that follow the below shown steps.
1. Navigate to C:\Windows\System32\drivers\etc
2. Open hosts file in notepad
3. Add the entry at the end of line, as i did for example 192.168.131.65 KSSQLSRVR 192.168.131.65 KSSQLSRVR\SPDEV01
those were my instances i am tried to connect remotely

sweeeeet... it worked! should work for anyone who have this problem...